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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
setup.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：17k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

setup.c：源码内容
  1. /*
  2.  *  linux/arch/x86-64/kernel/setup.c
  3.  *
  4.  *  Copyright (C) 1995  Linus Torvalds
  5.  *
  6.  *  Nov 2001 Dave Jones <davej@suse.de>
  7.  *  Forked from i386 setup code.
  8.  */
  10. /*
  11.  * This file handles the architecture-dependent parts of initialization
  12.  */
  14. #include <linux/errno.h>
  15. #include <linux/sched.h>
  16. #include <linux/kernel.h>
  17. #include <linux/mm.h>
  18. #include <linux/stddef.h>
  19. #include <linux/unistd.h>
  20. #include <linux/ptrace.h>
  21. #include <linux/slab.h>
  22. #include <linux/user.h>
  23. #include <linux/a.out.h>
  24. #include <linux/tty.h>
  25. #include <linux/ioport.h>
  26. #include <linux/delay.h>
  27. #include <linux/config.h>
  28. #include <linux/init.h>
  29. #include <linux/blk.h>
  30. #include <linux/highmem.h>
  31. #include <linux/bootmem.h>
  32. #include <asm/processor.h>
  33. #include <linux/console.h>
  34. #include <linux/seq_file.h>
  35. #include <asm/mtrr.h>
  36. #include <asm/uaccess.h>
  37. #include <asm/system.h>
  38. #include <asm/io.h>
  39. #include <asm/smp.h>
  40. #include <asm/msr.h>
  41. #include <asm/desc.h>
  42. #include <asm/e820.h>
  43. #include <asm/dma.h>
  44. #include <asm/mpspec.h>
  45. #include <asm/mmu_context.h>
  46. #include <asm/bootsetup.h>
  47. #include <asm/proto.h>
  49. /*
  50.  * Machine setup..
  51.  */
  53. struct cpuinfo_x86 boot_cpu_data = { 
  54. cpuid_level: -1, 
  55. };
  57. unsigned long mmu_cr4_features;
  59. /* For PCI or other memory-mapped resources */
  60. unsigned long pci_mem_start = 0x10000000;
  62. /*
  63.  * Setup options
  64.  */
  65. struct drive_info_struct { char dummy[32]; } drive_info;
  66. struct screen_info screen_info;
  67. struct sys_desc_table_struct {
  68. unsigned short length;
  69. unsigned char table[0];
  70. };
  72. struct e820map e820;
  74. unsigned char aux_device_present;
  76. extern int root_mountflags;
  77. extern char _text, _etext, _edata, _end;
  79. static int disable_x86_fxsr __initdata = 0;
  81. char command_line[COMMAND_LINE_SIZE];
  82. char saved_command_line[COMMAND_LINE_SIZE];
  84. struct resource standard_io_resources[] = {
  85. { "dma1", 0x00, 0x1f, IORESOURCE_BUSY },
  86. { "pic1", 0x20, 0x3f, IORESOURCE_BUSY },
  87. { "timer", 0x40, 0x5f, IORESOURCE_BUSY },
  88. { "keyboard", 0x60, 0x6f, IORESOURCE_BUSY },
  89. { "dma page reg", 0x80, 0x8f, IORESOURCE_BUSY },
  90. { "pic2", 0xa0, 0xbf, IORESOURCE_BUSY },
  91. { "dma2", 0xc0, 0xdf, IORESOURCE_BUSY },
  92. { "fpu", 0xf0, 0xff, IORESOURCE_BUSY }
  93. };
  95. #define STANDARD_IO_RESOURCES (sizeof(standard_io_resources)/sizeof(struct resource))
  97. struct resource code_resource = { "Kernel code", 0x100000, 0 };
  98. struct resource data_resource = { "Kernel data", 0, 0 };
  99. struct resource vram_resource = { "Video RAM area", 0xa0000, 0xbffff, IORESOURCE_BUSY };
  102. /* System ROM resources */
  103. #define MAXROMS 6
  104. static struct resource rom_resources[MAXROMS] = {
  105. { "System ROM", 0xF0000, 0xFFFFF, IORESOURCE_BUSY },
  106. { "Video ROM", 0xc0000, 0xc7fff, IORESOURCE_BUSY }
  107. };
  109. #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
  111. static void __init probe_roms(void)
  112. {
  113. int roms = 1;
  114. unsigned long base;
  115. unsigned char *romstart;
  117. request_resource(&iomem_resource, rom_resources+0);
  119. /* Video ROM is standard at C000:0000 - C7FF:0000, check signature */
  120. for (base = 0xC0000; base < 0xE0000; base += 2048) {
  121. romstart = bus_to_virt(base);
  122. if (!romsignature(romstart))
  123. continue;
  124. request_resource(&iomem_resource, rom_resources + roms);
  125. roms++;
  126. break;
  127. }
  129. /* Extension roms at C800:0000 - DFFF:0000 */
  130. for (base = 0xC8000; base < 0xE0000; base += 2048) {
  131. unsigned long length;
  133. romstart = bus_to_virt(base);
  134. if (!romsignature(romstart))
  135. continue;
  136. length = romstart[2] * 512;
  137. if (length) {
  138. unsigned int i;
  139. unsigned char chksum;
  141. chksum = 0;
  142. for (i = 0; i < length; i++)
  143. chksum += romstart[i];
  145. /* Good checksum? */
  146. if (!chksum) {
  147. rom_resources[roms].start = base;
  148. rom_resources[roms].end = base + length - 1;
  149. rom_resources[roms].name = "Extension ROM";
  150. rom_resources[roms].flags = IORESOURCE_BUSY;
  152. request_resource(&iomem_resource, rom_resources + roms);
  153. roms++;
  154. if (roms >= MAXROMS)
  155. return;
  156. }
  157. }
  158. }
  160. /* Final check for motherboard extension rom at E000:0000 */
  161. base = 0xE0000;
  162. romstart = bus_to_virt(base);
  164. if (romsignature(romstart)) {
  165. rom_resources[roms].start = base;
  166. rom_resources[roms].end = base + 65535;
  167. rom_resources[roms].name = "Extension ROM";
  168. rom_resources[roms].flags = IORESOURCE_BUSY;
  170. request_resource(&iomem_resource, rom_resources + roms);
  171. }
  172. }
  174. unsigned long start_pfn, end_pfn; 
  175. extern unsigned long table_start, table_end;
  177. #ifndef CONFIG_DISCONTIGMEM
  178. static void __init contig_initmem_init(void)
  179. {
  180. unsigned long bootmap_size, bootmap; 
  181. bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
  182. bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
  183. if (bootmap == -1L) 
  184. panic("Cannot find bootmem map of size %ldn",bootmap_size);
  185. bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
  186. e820_bootmem_free(&contig_page_data, 0, end_pfn << PAGE_SHIFT); 
  187. reserve_bootmem(bootmap, bootmap_size);
  188. }
  189. #endif
  191. void __init setup_arch(char **cmdline_p)
  192. {
  193. int i;
  194. unsigned long kernel_end; 
  196.   ROOT_DEV = to_kdev_t(ORIG_ROOT_DEV);
  197.   drive_info = DRIVE_INFO;
  198.   screen_info = SCREEN_INFO;
  199. aux_device_present = AUX_DEVICE_INFO;
  201. #ifdef CONFIG_BLK_DEV_RAM
  202. rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
  203. rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
  204. rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
  205. #endif
  206. setup_memory_region();
  208. if (!MOUNT_ROOT_RDONLY)
  209. root_mountflags &= ~MS_RDONLY;
  210. init_mm.start_code = (unsigned long) &_text;
  211. init_mm.end_code = (unsigned long) &_etext;
  212. init_mm.end_data = (unsigned long) &_edata;
  213. init_mm.brk = (unsigned long) &_end;
  215. code_resource.start = virt_to_bus(&_text);
  216. code_resource.end = virt_to_bus(&_etext)-1;
  217. data_resource.start = virt_to_bus(&_etext);
  218. data_resource.end = virt_to_bus(&_edata)-1;
  220. parse_mem_cmdline(cmdline_p);
  222. e820_end_of_ram();
  224. init_memory_mapping(); 
  226. #ifdef CONFIG_BLK_DEV_INITRD
  227. if (LOADER_TYPE && INITRD_START) {
  228. if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
  229. initrd_start =
  230. INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
  231. initrd_end = initrd_start+INITRD_SIZE;
  232. }
  233. else {
  234. printk(KERN_ERR "initrd extends beyond end of memory "
  235.     "(0x%08lx > 0x%08lx)ndisabling initrdn",
  236.     (unsigned long)INITRD_START + INITRD_SIZE,
  237.     (unsigned long)(end_pfn << PAGE_SHIFT));
  238. initrd_start = 0;
  239. }
  240. }
  241. #endif
  243. #ifdef CONFIG_DISCONTIGMEM
  244. numa_initmem_init(0, end_pfn); 
  245. #else
  246. contig_initmem_init(); 
  247. #endif
  249. /* Reserve direct mapping */
  250. reserve_bootmem_generic(table_start << PAGE_SHIFT, 
  251. (table_end - table_start) << PAGE_SHIFT);
  253. #ifdef CONFIG_BLK_DEV_INITRD
  254. if (initrd_start) 
  255. reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
  256. #endif
  258. /* Reserve BIOS data page. Some things still need it */
  259. reserve_bootmem_generic(0, PAGE_SIZE);
  261. #ifdef CONFIG_SMP
  262. /*
  263.  * But first pinch a few for the stack/trampoline stuff
  264.  * FIXME: Don't need the extra page at 4K, but need to fix
  265.  * trampoline before removing it. (see the GDT stuff)
  266.  */
  267. reserve_bootmem_generic(PAGE_SIZE, PAGE_SIZE); 
  269. /* Reserve SMP trampoline */
  270. reserve_bootmem_generic(0x6000, PAGE_SIZE);
  271. #endif
  272. /* Reserve Kernel */
  273. kernel_end = round_up(__pa_symbol(&_end), PAGE_SIZE);
  274. reserve_bootmem_generic(HIGH_MEMORY, kernel_end - HIGH_MEMORY);
  276. #ifdef CONFIG_X86_LOCAL_APIC
  277. /*
  278.  * Find and reserve possible boot-time SMP configuration:
  279.  */
  280. find_smp_config();
  281. #endif
  283. #ifdef CONFIG_SMP
  284. /* AP processor realmode stacks in low memory*/
  285. smp_alloc_memory();
  286. #endif
  288. paging_init();
  289. #ifdef CONFIG_X86_LOCAL_APIC
  290. /*
  291.  * get boot-time SMP configuration:
  292.  */
  293. if (smp_found_config)
  294. get_smp_config();
  295. init_apic_mappings();
  296. #endif
  298. /*
  299.  * Request address space for all standard RAM and ROM resources
  300.  * and also for regions reported as reserved by the e820.
  301.  */
  302. probe_roms();
  303. e820_reserve_resources(); 
  304. request_resource(&iomem_resource, &vram_resource);
  306. /* request I/O space for devices used on all i[345]86 PCs */
  307. for (i = 0; i < STANDARD_IO_RESOURCES; i++)
  308. request_resource(&ioport_resource, standard_io_resources+i);
  310. /* We put PCI memory up to make sure VALID_PAGE with DISCONTIGMEM
  311.    never returns true for it */ 
  313. /* Tell the PCI layer not to allocate too close to the RAM area.. */
  314. pci_mem_start = IOMAP_START;
  316. #ifdef CONFIG_GART_IOMMU
  317. iommu_hole_init();
  318. #endif
  320. #ifdef CONFIG_VT
  321. #if defined(CONFIG_VGA_CONSOLE)
  322. conswitchp = &vga_con;
  323. #elif defined(CONFIG_DUMMY_CONSOLE)
  324. conswitchp = &dummy_con;
  325. #endif
  326. #endif
  328. num_mappedpages = end_pfn;
  329. }
  331. #ifndef CONFIG_X86_TSC
  332. static int tsc_disable __initdata = 0;
  334. static int __init tsc_setup(char *str)
  335. {
  336. tsc_disable = 1;
  337. return 1;
  338. }
  340. __setup("notsc", tsc_setup);
  341. #endif
  343. static int __init get_model_name(struct cpuinfo_x86 *c)
  344. {
  345. unsigned int *v;
  347. if (cpuid_eax(0x80000000) < 0x80000004)
  348. return 0;
  350. v = (unsigned int *) c->x86_model_id;
  351. cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
  352. cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
  353. cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
  354. c->x86_model_id[48] = 0;
  355. return 1;
  356. }
  359. static void __init display_cacheinfo(struct cpuinfo_x86 *c)
  360. {
  361. unsigned int n, dummy, ecx, edx, eax, ebx, eax_2, ebx_2, ecx_2;
  363. n = cpuid_eax(0x80000000);
  366. if (n >= 0x80000005) {
  367. if (n >= 0x80000006) 
  368. cpuid(0x80000006, &eax_2, &ebx_2, &ecx_2, &dummy); 
  370. cpuid(0x80000005, &eax, &ebx, &ecx, &edx);
  371. printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line/%d way), D cache %dK (%d bytes/line/%d way)n",
  372.        edx>>24, edx&0xFF, (edx>>16)&0xff, 
  373.        ecx>>24, ecx&0xFF, (ecx>>16)&0xff);
  374. c->x86_cache_size=(ecx>>24)+(edx>>24);
  375. if (n >= 0x80000006) {
  376. printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line/%d way)n",
  377.        ecx_2>>16, ecx_2&0xFF, (ecx_2>>12)&0xf);
  378. c->x86_cache_size = ecx_2 >> 16;
  379. }
  380. printk(KERN_INFO "CPU: DTLB L1 %d 4K %d 2MB L2: %d 4K %d 2MBn",
  381.        (ebx>>16)&0xff, (eax>>16)&0xff, 
  382.        (ebx_2>>16)&0xfff, (eax_2>>16)&0xfff);
  383. printk(KERN_INFO "CPU: ITLB L1 %d 4K %d 2MB L2: %d 4K %d 2MBn",
  384.        ebx&0xff, (eax)&0xff, 
  385.        (ebx_2)&0xfff, (eax_2)&0xfff);
  386. c->x86_tlbsize = ((ebx>>16)&0xff) + ((ebx_2>>16)&0xfff) + 
  387. (ebx&0xff) + ((ebx_2)&0xfff);
  388. }
  389. }
  391. static int __init init_amd(struct cpuinfo_x86 *c)
  392. {
  393. int r;
  395. /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
  396.    3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
  397. clear_bit(0*32+31, &c->x86_capability);
  399. r = get_model_name(c);
  400. if (!r) { 
  401. switch (c->x86) { 
  402. case 15:
  403. /* Should distingush Models here, but this is only
  404.    a fallback anyways. */
  405. strcpy(c->x86_model_id, "Hammer");
  406. break; 
  407. } 
  408. } 
  409. display_cacheinfo(c);
  410. return r;
  411. }
  414. void __init get_cpu_vendor(struct cpuinfo_x86 *c)
  415. {
  416. char *v = c->x86_vendor_id;
  418. if (!strcmp(v, "AuthenticAMD"))
  419. c->x86_vendor = X86_VENDOR_AMD;
  420. else
  421. c->x86_vendor = X86_VENDOR_UNKNOWN;
  422. }
  424. struct cpu_model_info {
  425. int vendor;
  426. int family;
  427. char *model_names[16];
  428. };
  430. int __init x86_fxsr_setup(char * s)
  431. {
  432. disable_x86_fxsr = 1;
  433. return 1;
  434. }
  435. __setup("nofxsr", x86_fxsr_setup);
  439. /*
  440.  * This does the hard work of actually picking apart the CPU stuff...
  441.  */
  442. void __init identify_cpu(struct cpuinfo_x86 *c)
  443. {
  444. int junk, i;
  445. u32 xlvl, tfms;
  447. c->loops_per_jiffy = loops_per_jiffy;
  448. c->x86_cache_size = -1;
  449. c->x86_vendor = X86_VENDOR_UNKNOWN;
  450. c->x86_model = c->x86_mask = 0; /* So far unknown... */
  451. c->x86_vendor_id[0] = ''; /* Unset */
  452. c->x86_model_id[0] = '';  /* Unset */
  453. memset(&c->x86_capability, 0, sizeof c->x86_capability);
  455. /* Get vendor name */
  456. cpuid(0x00000000, &c->cpuid_level,
  457.       (int *)&c->x86_vendor_id[0],
  458.       (int *)&c->x86_vendor_id[8],
  459.       (int *)&c->x86_vendor_id[4]);
  461. get_cpu_vendor(c);
  462. /* Initialize the standard set of capabilities */
  463. /* Note that the vendor-specific code below might override */
  465. /* Intel-defined flags: level 0x00000001 */
  466. if ( c->cpuid_level >= 0x00000001 ) {
  467. __u32 misc;
  468. cpuid(0x00000001, &tfms, &misc, &junk,
  469.       &c->x86_capability[0]);
  470. c->x86 = (tfms >> 8) & 15;
  471. if (c->x86 == 0xf)
  472. c->x86 += (tfms >> 20) & 0xff;
  473. c->x86_model = (tfms >> 4) & 15;
  474. if (c->x86_model == 0xf)
  475. c->x86_model += ((tfms >> 16) & 0xF) << 4; 
  476. c->x86_mask = tfms & 15;
  477. if (c->x86_capability[0] & (1<<19)) 
  478. c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
  479. } else {
  480. /* Have CPUID level 0 only - unheard of */
  481. c->x86 = 4;
  482. }
  484. /* AMD-defined flags: level 0x80000001 */
  485. xlvl = cpuid_eax(0x80000000);
  486. if ( (xlvl & 0xffff0000) == 0x80000000 ) {
  487. if ( xlvl >= 0x80000001 )
  488. c->x86_capability[1] = cpuid_edx(0x80000001);
  489. if ( xlvl >= 0x80000004 )
  490. get_model_name(c); /* Default name */
  491. }
  493. /* Transmeta-defined flags: level 0x80860001 */
  494. xlvl = cpuid_eax(0x80860000);
  495. if ( (xlvl & 0xffff0000) == 0x80860000 ) {
  496. if (  xlvl >= 0x80860001 )
  497. c->x86_capability[2] = cpuid_edx(0x80860001);
  498. }
  501. /*
  502.  * Vendor-specific initialization.  In this section we
  503.  * canonicalize the feature flags, meaning if there are
  504.  * features a certain CPU supports which CPUID doesn't
  505.  * tell us, CPUID claiming incorrect flags, or other bugs,
  506.  * we handle them here.
  507.  *
  508.  * At the end of this section, c->x86_capability better
  509.  * indicate the features this CPU genuinely supports!
  510.  */
  511. switch ( c->x86_vendor ) {
  513. case X86_VENDOR_AMD:
  514. init_amd(c);
  515. break;
  517. case X86_VENDOR_UNKNOWN:
  518. default:
  519. /* Not much we can do here... */
  520. break;
  521. }
  523. /*
  524.  * The vendor-specific functions might have changed features.  Now
  525.  * we do "generic changes."
  526.  */
  528. /* TSC disabled? */
  529. #ifndef CONFIG_X86_TSC
  530. if ( tsc_disable )
  531. clear_bit(X86_FEATURE_TSC, &c->x86_capability);
  532. #endif
  534. /* FXSR disabled? */
  535. if (disable_x86_fxsr) {
  536. clear_bit(X86_FEATURE_FXSR, &c->x86_capability);
  537. clear_bit(X86_FEATURE_XMM, &c->x86_capability);
  538. }
  540. /*
  541.  * On SMP, boot_cpu_data holds the common feature set between
  542.  * all CPUs; so make sure that we indicate which features are
  543.  * common between the CPUs.  The first time this routine gets
  544.  * executed, c == &boot_cpu_data.
  545.  */
  546. if ( c != &boot_cpu_data ) {
  547. /* AND the already accumulated flags with these */
  548. for ( i = 0 ; i < NCAPINTS ; i++ )
  549. boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
  550. }
  552. #ifdef CONFIG_MCE
  553. mcheck_init(c);
  554. #endif
  555. }
  556.  
  557. void __init print_cpu_info(struct cpuinfo_x86 *c)
  558. {
  559. if (c->x86_model_id[0])
  560. printk("%s", c->x86_model_id);
  562. if (c->x86_mask || c->cpuid_level >= 0) 
  563. printk(" stepping %02xn", c->x86_mask);
  564. else
  565. printk("n");
  566. }
  568. /*
  569.  * Get CPU information for use by the procfs.
  570.  */
  572. static int show_cpuinfo(struct seq_file *m, void *v)
  573. {
  574. struct cpuinfo_x86 *c = v;
  576. /* 
  577.  * These flag bits must match the definitions in <asm/cpufeature.h>.
  578.  * NULL means this bit is undefined or reserved; either way it doesn't
  579.  * have meaning as far as Linux is concerned.  Note that it's important
  580.  * to realize there is a difference between this table and CPUID -- if
  581.  * applications want to get the raw CPUID data, they should access
  582.  * /dev/cpu/<cpu_nr>/cpuid instead.
  583.  */
  584. static char *x86_cap_flags[] = {
  585. /* Intel-defined */
  586.         "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
  587.         "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
  588.         "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
  589.         "fxsr", "sse", "sse2", "ss", NULL, "tm", "ia64", NULL,
  591. /* AMD-defined */
  592. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  593. NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
  594. NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
  595. NULL, NULL, NULL, NULL, NULL, "lm", "3dnowext", "3dnow",
  597. /* Transmeta-defined */
  598. "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
  599. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  600. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  601. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  603. /* Other (Linux-defined) */
  604. "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr", NULL, NULL, NULL, NULL,
  605. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  606. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  607. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  608. };
  610. #ifdef CONFIG_SMP
  611. if (!(cpu_online_map & (1<<(c-cpu_data))))
  612. return 0;
  613. #endif
  615. seq_printf(m,"processort: %un"
  616.      "vendor_idt: %sn"
  617.      "cpu familyt: %dn"
  618.      "modeltt: %dn"
  619.      "model namet: %sn",
  620.      (unsigned)(c-cpu_data),
  621.      c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
  622.      c->x86,
  623.      (int)c->x86_model,
  624.      c->x86_model_id[0] ? c->x86_model_id : "unknown");
  626. if (c->x86_mask || c->cpuid_level >= 0)
  627. seq_printf(m, "steppingt: %dn", c->x86_mask);
  628. else
  629. seq_printf(m, "steppingt: unknownn");
  631. if ( test_bit(X86_FEATURE_TSC, &c->x86_capability) ) {
  632. seq_printf(m, "cpu MHztt: %u.%03un",
  633.      cpu_khz / 1000, (cpu_khz % 1000));
  634. }
  636. seq_printf(m, "cache sizet: %d KBn", c->x86_cache_size);
  638. seq_printf(m,
  639.         "fputt: yesn"
  640.         "fpu_exceptiont: yesn"
  641.         "cpuid levelt: %dn"
  642.         "wptt: yesn"
  643.         "flagstt:",
  644.    c->cpuid_level);
  646. { 
  647. int i; 
  648. for ( i = 0 ; i < 32*NCAPINTS ; i++ )
  649. if ( test_bit(i, &c->x86_capability) &&
  650.      x86_cap_flags[i] != NULL )
  651. seq_printf(m, " %s", x86_cap_flags[i]);
  652. }
  654. seq_printf(m, "nbogomipst: %lu.%02lun",
  655.    c->loops_per_jiffy/(500000/HZ),
  656.    (c->loops_per_jiffy/(5000/HZ)) % 100);
  658. if (c->x86_tlbsize > 0) 
  659. seq_printf(m, "TLB sizet: %d 4K pagesn", c->x86_tlbsize);
  660. seq_printf(m, "clflush sizet: %dn", c->x86_clflush_size);
  662. seq_printf(m, "n"); 
  663. return 0;
  664. }
  666. static void *c_start(struct seq_file *m, loff_t *pos)
  667. {
  668. return *pos < NR_CPUS ? cpu_data + *pos : NULL;
  669. }
  671. static void *c_next(struct seq_file *m, void *v, loff_t *pos)
  672. {
  673. ++*pos;
  674. return c_start(m, pos);
  675. }
  677. static void c_stop(struct seq_file *m, void *v)
  678. {
  679. }
  681. struct seq_operations cpuinfo_op = {
  682. start: c_start,
  683. next: c_next,
  684. stop: c_stop,
  685. show: show_cpuinfo,
  686. };