开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
setup.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

setup.c：源码内容
  1. /*
  2.  *  linux/arch/arm/kernel/setup.c
  3.  *
  4.  *  Copyright (C) 1995-2001 Russell King
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License version 2 as
  8.  * published by the Free Software Foundation.
  9.  */
  10. #include <linux/config.h>
  11. #include <linux/kernel.h>
  12. #include <linux/stddef.h>
  13. #include <linux/ioport.h>
  14. #include <linux/delay.h>
  15. #include <linux/utsname.h>
  16. #include <linux/blk.h>
  17. #include <linux/console.h>
  18. #include <linux/bootmem.h>
  19. #include <linux/seq_file.h>
  20. #include <linux/init.h>
  22. #include <asm/elf.h>
  23. #include <asm/hardware.h>
  24. #include <asm/io.h>
  25. #include <asm/procinfo.h>
  26. #include <asm/setup.h>
  27. #include <asm/mach-types.h>
  29. #include <asm/mach/arch.h>
  30. #include <asm/mach/irq.h>
  32. #ifndef MEM_SIZE
  33. #define MEM_SIZE (16*1024*1024)
  34. #endif
  36. #ifndef CONFIG_CMDLINE
  37. #define CONFIG_CMDLINE ""
  38. #endif
  40. #if defined(CONFIG_FPE_NWFPE) || defined(CONFIG_FPE_FASTFPE)
  41. char fpe_type[8];
  43. static int __init fpe_setup(char *line)
  44. {
  45. memcpy(fpe_type, line, 8);
  46. return 1;
  47. }
  49. __setup("fpe=", fpe_setup);
  50. #endif
  52. extern unsigned int mem_fclk_21285;
  53. extern void paging_init(struct meminfo *, struct machine_desc *desc);
  54. extern void convert_to_tag_list(struct param_struct *params, int mem_init);
  55. extern void bootmem_init(struct meminfo *);
  56. extern void reboot_setup(char *str);
  57. extern int root_mountflags;
  58. extern int _stext, _text, _etext, _edata, _end;
  60. unsigned int processor_id;
  61. unsigned int __machine_arch_type;
  62. unsigned int system_rev;
  63. unsigned int system_serial_low;
  64. unsigned int system_serial_high;
  65. unsigned int elf_hwcap;
  67. #ifdef MULTI_CPU
  68. struct processor processor;
  69. #endif
  71. unsigned char aux_device_present;
  72. char elf_platform[ELF_PLATFORM_SIZE];
  73. char saved_command_line[COMMAND_LINE_SIZE];
  75. static struct meminfo meminfo __initdata = { 0, };
  76. static struct proc_info_item proc_info;
  77. static const char *machine_name;
  78. static char command_line[COMMAND_LINE_SIZE];
  80. static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
  81. static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } };
  82. #define ENDIANNESS ((char)endian_test.l)
  84. /*
  85.  * Standard memory resources
  86.  */
  87. static struct resource mem_res[] = {
  88. { "Video RAM",   0,     0,     IORESOURCE_MEM },
  89. { "Kernel code", 0,     0,     IORESOURCE_MEM },
  90. { "Kernel data", 0,     0,     IORESOURCE_MEM }
  91. };
  93. #define video_ram   mem_res[0]
  94. #define kernel_code mem_res[1]
  95. #define kernel_data mem_res[2]
  97. static struct resource io_res[] = {
  98. { "reserved",    0x3bc, 0x3be, IORESOURCE_IO | IORESOURCE_BUSY },
  99. { "reserved",    0x378, 0x37f, IORESOURCE_IO | IORESOURCE_BUSY },
  100. { "reserved",    0x278, 0x27f, IORESOURCE_IO | IORESOURCE_BUSY }
  101. };
  103. #define lp0 io_res[0]
  104. #define lp1 io_res[1]
  105. #define lp2 io_res[2]
  107. #ifdef CONFIG_CPU_32
  108. static const char *cache_types[16] = {
  109. "write-through",
  110. "write-back",
  111. "write-back",
  112. "undefined 3",
  113. "undefined 4",
  114. "undefined 5",
  115. "write-back",
  116. "write-back",
  117. "undefined 8",
  118. "undefined 9",
  119. "undefined 10",
  120. "undefined 11",
  121. "undefined 12",
  122. "undefined 13",
  123. "undefined 14",
  124. "undefined 15",
  125. };
  127. static const char *cache_clean[16] = {
  128. "not required",
  129. "read-block",
  130. "cp15 c7 ops",
  131. "undefined 3",
  132. "undefined 4",
  133. "undefined 5",
  134. "cp15 c7 ops",
  135. "cp15 c7 ops",
  136. "undefined 8",
  137. "undefined 9",
  138. "undefined 10",
  139. "undefined 11",
  140. "undefined 12",
  141. "undefined 13",
  142. "undefined 14",
  143. "undefined 15",
  144. };
  146. static const char *cache_lockdown[16] = {
  147. "not supported",
  148. "not supported",
  149. "not supported",
  150. "undefined 3",
  151. "undefined 4",
  152. "undefined 5",
  153. "format A",
  154. "format B",
  155. "undefined 8",
  156. "undefined 9",
  157. "undefined 10",
  158. "undefined 11",
  159. "undefined 12",
  160. "undefined 13",
  161. "undefined 14",
  162. "undefined 15",
  163. };
  165. #define CACHE_TYPE(x) (((x) >> 25) & 15)
  166. #define CACHE_S(x) ((x) & (1 << 24))
  167. #define CACHE_DSIZE(x) (((x) >> 12) & 4095) /* only if S=1 */
  168. #define CACHE_ISIZE(x) ((x) & 4095)
  170. #define CACHE_SIZE(y) (((y) >> 6) & 7)
  171. #define CACHE_ASSOC(y) (((y) >> 3) & 7)
  172. #define CACHE_M(y) ((y) & (1 << 2))
  173. #define CACHE_LINE(y) ((y) & 3)
  175. static inline void dump_cache(const char *prefix, unsigned int cache)
  176. {
  177. unsigned int mult = 2 + (CACHE_M(cache) ? 1 : 0);
  179. printk("%s size %dK associativity %d line length %d sets %dn",
  180. prefix,
  181. mult << (8 + CACHE_SIZE(cache)),
  182. (mult << CACHE_ASSOC(cache)) >> 1,
  183. 8 << CACHE_LINE(cache),
  184. 1 << (6 + CACHE_SIZE(cache) - CACHE_ASSOC(cache) -
  185. CACHE_LINE(cache)));
  186. }
  188. static inline void dump_cpu_cache_id(void)
  189. {
  190. unsigned int cache_info;
  192. asm("mrc p15, 0, %0, c0, c0, 1" : "=r" (cache_info));
  194. if (cache_info == processor_id)
  195. return;
  197. printk("CPU: D %s cachen", cache_types[CACHE_TYPE(cache_info)]);
  198. if (CACHE_S(cache_info)) {
  199. dump_cache("CPU: I cache", CACHE_ISIZE(cache_info));
  200. dump_cache("CPU: D cache", CACHE_DSIZE(cache_info));
  201. } else {
  202. dump_cache("CPU: cache", CACHE_ISIZE(cache_info));
  203. }
  204. }
  206. #else
  207. #define dump_cpu_cache_id() do { } while (0)
  208. #endif
  210. static void __init setup_processor(void)
  211. {
  212. extern struct proc_info_list __proc_info_begin, __proc_info_end;
  213. struct proc_info_list *list;
  215. /*
  216.  * locate processor in the list of supported processor
  217.  * types.  The linker builds this table for us from the
  218.  * entries in arch/arm/mm/proc-*.S
  219.  */
  220. for (list = &__proc_info_begin; list < &__proc_info_end ; list++)
  221. if ((processor_id & list->cpu_mask) == list->cpu_val)
  222. break;
  224. /*
  225.  * If processor type is unrecognised, then we
  226.  * can do nothing...
  227.  */
  228. if (list >= &__proc_info_end) {
  229. printk("CPU configuration botched (ID %08x), unable "
  230.        "to continue.n", processor_id);
  231. while (1);
  232. }
  234. proc_info = *list->info;
  236. #ifdef MULTI_CPU
  237. processor = *list->proc;
  238. #endif
  240. printk("CPU: %s %s revision %dn",
  241.        proc_info.manufacturer, proc_info.cpu_name,
  242.        (int)processor_id & 15);
  244. sprintf(system_utsname.machine, "%s%c", list->arch_name, ENDIANNESS);
  245. sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS);
  246. elf_hwcap = list->elf_hwcap;
  248. cpu_proc_init();
  249. }
  251. static struct machine_desc * __init setup_machine(unsigned int nr)
  252. {
  253. extern struct machine_desc __arch_info_begin, __arch_info_end;
  254. struct machine_desc *list;
  256. /*
  257.  * locate architecture in the list of supported architectures.
  258.  */
  259. for (list = &__arch_info_begin; list < &__arch_info_end; list++)
  260. if (list->nr == nr)
  261. break;
  263. /*
  264.  * If the architecture type is not recognised, then we
  265.  * can co nothing...
  266.  */
  267. if (list >= &__arch_info_end) {
  268. printk("Architecture configuration botched (nr %d), unable "
  269.        "to continue.n", nr);
  270. while (1);
  271. }
  273. printk("Machine: %sn", list->name);
  275. return list;
  276. }
  278. /*
  279.  * Initial parsing of the command line.  We need to pick out the
  280.  * memory size.  We look for mem=size@start, where start and size
  281.  * are "size[KkMm]"
  282.  */
  283. static void __init
  284. parse_cmdline(struct meminfo *mi, char **cmdline_p, char *from)
  285. {
  286. char c = ' ', *to = command_line;
  287. int usermem = 0, len = 0;
  289. for (;;) {
  290. if (c == ' ' && !memcmp(from, "mem=", 4)) {
  291. unsigned long size, start;
  293. if (to != command_line)
  294. to -= 1;
  296. /*
  297.  * If the user specifies memory size, we
  298.  * blow away any automatically generated
  299.  * size.
  300.  */
  301. if (usermem == 0) {
  302. usermem = 1;
  303. mi->nr_banks = 0;
  304. }
  306. start = PHYS_OFFSET;
  307. size  = memparse(from + 4, &from);
  308. if (*from == '@')
  309. start = memparse(from + 1, &from);
  311. mi->bank[mi->nr_banks].start = start;
  312. mi->bank[mi->nr_banks].size  = size;
  313. mi->bank[mi->nr_banks].node  = PHYS_TO_NID(start);
  314. mi->nr_banks += 1;
  315. }
  316. c = *from++;
  317. if (!c)
  318. break;
  319. if (COMMAND_LINE_SIZE <= ++len)
  320. break;
  321. *to++ = c;
  322. }
  323. *to = '';
  324. *cmdline_p = command_line;
  325. }
  327. void __init
  328. setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz)
  329. {
  330. #ifdef CONFIG_BLK_DEV_RAM
  331. extern int rd_size;
  333. rd_image_start = image_start;
  334. rd_prompt = prompt;
  335. rd_doload = doload;
  337. if (rd_sz)
  338. rd_size = rd_sz;
  339. #endif
  340. }
  342. /*
  343.  * initial ram disk
  344.  */
  345. void __init setup_initrd(unsigned int start, unsigned int size)
  346. {
  347. #ifdef CONFIG_BLK_DEV_INITRD
  348. if (start == 0)
  349. size = 0;
  350. initrd_start = start;
  351. initrd_end   = start + size;
  352. #endif
  353. }
  355. static void __init
  356. request_standard_resources(struct meminfo *mi, struct machine_desc *mdesc)
  357. {
  358. struct resource *res;
  359. int i;
  361. kernel_code.start  = __virt_to_phys(init_mm.start_code);
  362. kernel_code.end    = __virt_to_phys(init_mm.end_code - 1);
  363. kernel_data.start  = __virt_to_phys(init_mm.end_code);
  364. kernel_data.end    = __virt_to_phys(init_mm.brk - 1);
  366. for (i = 0; i < mi->nr_banks; i++) {
  367. unsigned long virt_start, virt_end;
  369. if (mi->bank[i].size == 0)
  370. continue;
  372. virt_start = __phys_to_virt(mi->bank[i].start);
  373. virt_end   = virt_start + mi->bank[i].size - 1;
  375. res = alloc_bootmem_low(sizeof(*res));
  376. res->name  = "System RAM";
  377. res->start = __virt_to_phys(virt_start);
  378. res->end   = __virt_to_phys(virt_end);
  379. res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  381. request_resource(&iomem_resource, res);
  383. if (kernel_code.start >= res->start &&
  384.     kernel_code.end <= res->end)
  385. request_resource(res, &kernel_code);
  386. if (kernel_data.start >= res->start &&
  387.     kernel_data.end <= res->end)
  388. request_resource(res, &kernel_data);
  389. }
  391. if (mdesc->video_start) {
  392. video_ram.start = mdesc->video_start;
  393. video_ram.end   = mdesc->video_end;
  394. request_resource(&iomem_resource, &video_ram);
  395. }
  397. /*
  398.  * Some machines don't have the possibility of ever
  399.  * possessing lp0, lp1 or lp2
  400.  */
  401. if (mdesc->reserve_lp0)
  402. request_resource(&ioport_resource, &lp0);
  403. if (mdesc->reserve_lp1)
  404. request_resource(&ioport_resource, &lp1);
  405. if (mdesc->reserve_lp2)
  406. request_resource(&ioport_resource, &lp2);
  407. }
  409. /*
  410.  *  Tag parsing.
  411.  *
  412.  * This is the new way of passing data to the kernel at boot time.  Rather
  413.  * than passing a fixed inflexible structure to the kernel, we pass a list
  414.  * of variable-sized tags to the kernel.  The first tag must be a ATAG_CORE
  415.  * tag for the list to be recognised (to distinguish the tagged list from
  416.  * a param_struct).  The list is terminated with a zero-length tag (this tag
  417.  * is not parsed in any way).
  418.  */
  419. static int __init parse_tag_core(const struct tag *tag)
  420. {
  421. if (tag->hdr.size > 2) {
  422. if ((tag->u.core.flags & 1) == 0)
  423. root_mountflags &= ~MS_RDONLY;
  424. ROOT_DEV = to_kdev_t(tag->u.core.rootdev);
  425. }
  426. return 0;
  427. }
  429. __tagtable(ATAG_CORE, parse_tag_core);
  431. static int __init parse_tag_mem32(const struct tag *tag)
  432. {
  433. if (meminfo.nr_banks >= NR_BANKS) {
  434. printk(KERN_WARNING
  435.        "Ignoring memory bank 0x%08x size %dKBn",
  436. tag->u.mem.start, tag->u.mem.size / 1024);
  437. return -EINVAL;
  438. }
  439. meminfo.bank[meminfo.nr_banks].start = tag->u.mem.start;
  440. meminfo.bank[meminfo.nr_banks].size  = tag->u.mem.size;
  441. meminfo.bank[meminfo.nr_banks].node  = PHYS_TO_NID(tag->u.mem.start);
  442. meminfo.nr_banks += 1;
  444. return 0;
  445. }
  447. __tagtable(ATAG_MEM, parse_tag_mem32);
  449. #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
  450. struct screen_info screen_info = {
  451.  orig_video_lines: 30,
  452.  orig_video_cols: 80,
  453.  orig_video_mode: 0,
  454.  orig_video_ega_bx: 0,
  455.  orig_video_isVGA: 1,
  456.  orig_video_points: 8
  457. };
  459. static int __init parse_tag_videotext(const struct tag *tag)
  460. {
  461. screen_info.orig_x            = tag->u.videotext.x;
  462. screen_info.orig_y            = tag->u.videotext.y;
  463. screen_info.orig_video_page   = tag->u.videotext.video_page;
  464. screen_info.orig_video_mode   = tag->u.videotext.video_mode;
  465. screen_info.orig_video_cols   = tag->u.videotext.video_cols;
  466. screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
  467. screen_info.orig_video_lines  = tag->u.videotext.video_lines;
  468. screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
  469. screen_info.orig_video_points = tag->u.videotext.video_points;
  470. return 0;
  471. }
  473. __tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
  474. #endif
  476. static int __init parse_tag_ramdisk(const struct tag *tag)
  477. {
  478. setup_ramdisk((tag->u.ramdisk.flags & 1) == 0,
  479.       (tag->u.ramdisk.flags & 2) == 0,
  480.       tag->u.ramdisk.start, tag->u.ramdisk.size);
  481. return 0;
  482. }
  484. __tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
  486. static int __init parse_tag_initrd(const struct tag *tag)
  487. {
  488. setup_initrd(tag->u.initrd.start, tag->u.initrd.size);
  489. return 0;
  490. }
  492. __tagtable(ATAG_INITRD, parse_tag_initrd);
  494. static int __init parse_tag_initrd2(const struct tag *tag)
  495. {
  496. unsigned long start = 0;
  498. if (tag->u.initrd.size) {
  499. start = (unsigned long)phys_to_virt(tag->u.initrd.start);
  501. setup_initrd(start, tag->u.initrd.size);
  502. }
  503. return 0;
  504. }
  506. __tagtable(ATAG_INITRD2, parse_tag_initrd2);
  508. static int __init parse_tag_serialnr(const struct tag *tag)
  509. {
  510. system_serial_low = tag->u.serialnr.low;
  511. system_serial_high = tag->u.serialnr.high;
  512. return 0;
  513. }
  515. __tagtable(ATAG_SERIAL, parse_tag_serialnr);
  517. static int __init parse_tag_revision(const struct tag *tag)
  518. {
  519. system_rev = tag->u.revision.rev;
  520. return 0;
  521. }
  523. __tagtable(ATAG_REVISION, parse_tag_revision);
  525. static int __init parse_tag_cmdline(const struct tag *tag)
  526. {
  527. #ifndef CONFIG_NO_TAG_CMDLINE
  528. strncpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE);
  529. #endif
  530. default_command_line[COMMAND_LINE_SIZE - 1] = '';
  531. return 0;
  532. }
  534. __tagtable(ATAG_CMDLINE, parse_tag_cmdline);
  536. /*
  537.  * Scan the tag table for this tag, and call its parse function.
  538.  * The tag table is built by the linker from all the __tagtable
  539.  * declarations.
  540.  */
  541. static int __init parse_tag(const struct tag *tag)
  542. {
  543. extern struct tagtable __tagtable_begin, __tagtable_end;
  544. struct tagtable *t;
  546. for (t = &__tagtable_begin; t < &__tagtable_end; t++)
  547. if (tag->hdr.tag == t->tag) {
  548. t->parse(tag);
  549. break;
  550. }
  552. return t < &__tagtable_end;
  553. }
  555. /*
  556.  * Parse all tags in the list, checking both the global and architecture
  557.  * specific tag tables.
  558.  */
  559. static void __init parse_tags(const struct tag *t)
  560. {
  561. for (; t->hdr.size; t = tag_next(t))
  562. if (!parse_tag(t))
  563. printk(KERN_WARNING
  564. "Ignoring unrecognised tag 0x%08xn",
  565. t->hdr.tag);
  566. }
  568. void __init setup_arch(char **cmdline_p)
  569. {
  570. struct tag *tags = NULL;
  571. struct machine_desc *mdesc;
  572. char *from = default_command_line;
  574. ROOT_DEV = MKDEV(0, 255);
  576. setup_processor();
  577. mdesc = setup_machine(machine_arch_type);
  578. machine_name = mdesc->name;
  580. if (mdesc->soft_reboot)
  581. reboot_setup("s");
  583. if (mdesc->param_offset)
  584. tags = phys_to_virt(mdesc->param_offset);
  586. /*
  587.  * Do the machine-specific fixups before we parse the
  588.  * parameters or tags.
  589.  */
  590. if (mdesc->fixup)
  591. mdesc->fixup(mdesc, (struct param_struct *)tags,
  592.      &from, &meminfo);
  594. /*
  595.  * If we have the old style parameters, convert them to
  596.  * a tag list before.
  597.  */
  598. if (tags && tags->hdr.tag != ATAG_CORE)
  599. convert_to_tag_list((struct param_struct *)tags,
  600.     meminfo.nr_banks == 0);
  602. if (tags && tags->hdr.tag == ATAG_CORE)
  603. parse_tags(tags);
  605. if (meminfo.nr_banks == 0) {
  606. meminfo.nr_banks      = 1;
  607. meminfo.bank[0].start = PHYS_OFFSET;
  608. meminfo.bank[0].size  = MEM_SIZE;
  609. }
  611. init_mm.start_code = (unsigned long) &_text;
  612. init_mm.end_code   = (unsigned long) &_etext;
  613. init_mm.end_data   = (unsigned long) &_edata;
  614. init_mm.brk    = (unsigned long) &_end;
  616. memcpy(saved_command_line, from, COMMAND_LINE_SIZE);
  617. saved_command_line[COMMAND_LINE_SIZE-1] = '';
  618. parse_cmdline(&meminfo, cmdline_p, from);
  619. bootmem_init(&meminfo);
  620. paging_init(&meminfo, mdesc);
  621. request_standard_resources(&meminfo, mdesc);
  623. /*
  624.  * Set up various architecture-specific pointers
  625.  */
  626. init_arch_irq = mdesc->init_irq;
  628. #ifdef CONFIG_VT
  629. #if defined(CONFIG_VGA_CONSOLE)
  630. conswitchp = &vga_con;
  631. #elif defined(CONFIG_DUMMY_CONSOLE)
  632. conswitchp = &dummy_con;
  633. #endif
  634. #endif
  635. }
  637. static const char *hwcap_str[] = {
  638. "swp",
  639. "half",
  640. "thumb",
  641. "26bit",
  642. "fastmult",
  643. "fpa",
  644. "vfp",
  645. "edsp",
  646. NULL
  647. };
  649. static const char *proc_arch[16] = {
  650. "undefined 0",
  651. "4",
  652. "4T",
  653. "5",
  654. "5T",
  655. "5TE",
  656. "undefined 6",
  657. "undefined 7",
  658. "undefined 8",
  659. "undefined 9",
  660. "undefined 10",
  661. "undefined 11",
  662. "undefined 12",
  663. "undefined 13",
  664. "undefined 14",
  665. "undefined 15"
  666. };
  668. static void
  669. c_show_cache(struct seq_file *m, const char *type, unsigned int cache)
  670. {
  671. unsigned int mult = 2 + CACHE_M(cache) ? 1 : 0;
  673. seq_printf(m, "%s sizett: %dn"
  674.       "%s assoctt: %dn"
  675.       "%s line lengtht: %dn"
  676.       "%s setstt: %dn",
  677. type, mult << (8 + CACHE_SIZE(cache)),
  678. type, (mult << CACHE_ASSOC(cache)) >> 1,
  679. type, 8 << CACHE_LINE(cache),
  680. type, 1 << (6 + CACHE_SIZE(cache) - CACHE_ASSOC(cache) -
  681.     CACHE_LINE(cache)));
  682. }
  684. static int c_show(struct seq_file *m, void *v)
  685. {
  686. int i;
  688. seq_printf(m, "Processort: %s %s rev %d (%s)n",
  689.    proc_info.manufacturer, proc_info.cpu_name,
  690.    (int)processor_id & 15, elf_platform);
  692. seq_printf(m, "BogoMIPSt: %lu.%02lun",
  693.    loops_per_jiffy / (500000/HZ),
  694.    (loops_per_jiffy / (5000/HZ)) % 100);
  696. /* dump out the processor features */
  697. seq_puts(m, "Featurest: ");
  699. for (i = 0; hwcap_str[i]; i++)
  700. if (elf_hwcap & (1 << i))
  701. seq_printf(m, "%s ", hwcap_str[i]);
  703. seq_puts(m, "n");
  705. if ((processor_id & 0x0000f000) == 0x00000000) {
  706. /* pre-ARM7 */
  707. seq_printf(m, "CPU parttt: %07xn", processor_id >> 4);
  708. } else if ((processor_id & 0x0000f000) == 0x00007000) {
  709. /* ARM7 */
  710. seq_printf(m, "CPU implementort: 0x%02xn"
  711.       "CPU architecture: %sn"
  712.       "CPU variantt: 0x%02xn"
  713.       "CPU partt: 0x%03xn",
  714.    processor_id >> 24,
  715.    processor_id & (1 << 23) ? "4T" : "3",
  716.    (processor_id >> 16) & 127,
  717.    (processor_id >> 4) & 0xfff);
  718. } else {
  719. /* post-ARM7 */
  720. seq_printf(m, "CPU implementort: 0x%02xn"
  721.       "CPU architecture: %sn"
  722.       "CPU variantt: 0x%xn"
  723.       "CPU partt: 0x%03xn",
  724.    processor_id >> 24,
  725.    proc_arch[(processor_id >> 16) & 15],
  726.    (processor_id >> 20) & 15,
  727.    (processor_id >> 4) & 0xfff);
  728. }
  729. seq_printf(m, "CPU revisiont: %dn", processor_id & 15);
  731. #ifdef CONFIG_CPU_32
  732. {
  733. unsigned int cache_info;
  735. asm("mrc p15, 0, %0, c0, c0, 1" : "=r" (cache_info));
  736. if (cache_info != processor_id) {
  737. seq_printf(m, "Cache typet: %sn"
  738.       "Cache cleant: %sn"
  739.       "Cache lockdownt: %sn"
  740.       "Cache unifiedt: %sn",
  741.    cache_types[CACHE_TYPE(cache_info)],
  742.    cache_clean[CACHE_TYPE(cache_info)],
  743.    cache_lockdown[CACHE_TYPE(cache_info)],
  744.    CACHE_S(cache_info) ? "harvard" : "unified");
  746. if (CACHE_S(cache_info)) {
  747. c_show_cache(m, "I", CACHE_ISIZE(cache_info));
  748. c_show_cache(m, "D", CACHE_DSIZE(cache_info));
  749. } else {
  750. c_show_cache(m, "Cache", CACHE_ISIZE(cache_info));
  751. }
  752. }
  753. }
  754. #endif
  756. seq_puts(m, "n");
  758. seq_printf(m, "Hardwaret: %sn", machine_name);
  759. seq_printf(m, "Revisiont: %04xn", system_rev);
  760. seq_printf(m, "Serialtt: %08x%08xn",
  761.    system_serial_high, system_serial_low);
  763. return 0;
  764. }
  766. static void *c_start(struct seq_file *m, loff_t *pos)
  767. {
  768. return *pos < 1 ? (void *)1 : NULL;
  769. }
  771. static void *c_next(struct seq_file *m, void *v, loff_t *pos)
  772. {
  773. ++*pos;
  774. return NULL;
  775. }
  777. static void c_stop(struct seq_file *m, void *v)
  778. {
  779. }
  781. struct seq_operations cpuinfo_op = {
  782. start: c_start,
  783. next: c_next,
  784. stop: c_stop,
  785. show: c_show
  786. };