setup_64.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850
  1. /*
  2. * Copyright (C) 1995 Linus Torvalds
  3. */
  4. /*
  5. * This file handles the architecture-dependent parts of initialization
  6. */
  7. #include <linux/errno.h>
  8. #include <linux/sched.h>
  9. #include <linux/kernel.h>
  10. #include <linux/mm.h>
  11. #include <linux/stddef.h>
  12. #include <linux/unistd.h>
  13. #include <linux/ptrace.h>
  14. #include <linux/slab.h>
  15. #include <linux/user.h>
  16. #include <linux/screen_info.h>
  17. #include <linux/ioport.h>
  18. #include <linux/delay.h>
  19. #include <linux/init.h>
  20. #include <linux/initrd.h>
  21. #include <linux/highmem.h>
  22. #include <linux/bootmem.h>
  23. #include <linux/module.h>
  24. #include <asm/processor.h>
  25. #include <linux/console.h>
  26. #include <linux/seq_file.h>
  27. #include <linux/crash_dump.h>
  28. #include <linux/root_dev.h>
  29. #include <linux/pci.h>
  30. #include <asm/pci-direct.h>
  31. #include <linux/efi.h>
  32. #include <linux/acpi.h>
  33. #include <linux/kallsyms.h>
  34. #include <linux/edd.h>
  35. #include <linux/iscsi_ibft.h>
  36. #include <linux/mmzone.h>
  37. #include <linux/kexec.h>
  38. #include <linux/cpufreq.h>
  39. #include <linux/dmi.h>
  40. #include <linux/dma-mapping.h>
  41. #include <linux/ctype.h>
  42. #include <linux/sort.h>
  43. #include <linux/uaccess.h>
  44. #include <linux/init_ohci1394_dma.h>
  45. #include <linux/kvm_para.h>
  46. #include <asm/mtrr.h>
  47. #include <asm/uaccess.h>
  48. #include <asm/system.h>
  49. #include <asm/vsyscall.h>
  50. #include <asm/io.h>
  51. #include <asm/smp.h>
  52. #include <asm/msr.h>
  53. #include <asm/desc.h>
  54. #include <video/edid.h>
  55. #include <asm/e820.h>
  56. #include <asm/dma.h>
  57. #include <asm/gart.h>
  58. #include <asm/mpspec.h>
  59. #include <asm/mmu_context.h>
  60. #include <asm/proto.h>
  61. #include <asm/setup.h>
  62. #include <asm/numa.h>
  63. #include <asm/sections.h>
  64. #include <asm/dmi.h>
  65. #include <asm/cacheflush.h>
  66. #include <asm/mce.h>
  67. #include <asm/ds.h>
  68. #include <asm/topology.h>
  69. #include <asm/trampoline.h>
  70. #include <asm/pat.h>
  71. #include <asm/mmconfig.h>
  72. #include <mach_apic.h>
  73. #ifdef CONFIG_PARAVIRT
  74. #include <asm/paravirt.h>
  75. #else
  76. #define ARCH_SETUP
  77. #endif
  78. /*
  79. * Machine setup..
  80. */
  81. struct cpuinfo_x86 boot_cpu_data __read_mostly;
  82. EXPORT_SYMBOL(boot_cpu_data);
  83. __u32 cleared_cpu_caps[NCAPINTS] __cpuinitdata;
  84. unsigned long mmu_cr4_features;
  85. /* Boot loader ID as an integer, for the benefit of proc_dointvec */
  86. int bootloader_type;
  87. unsigned long saved_video_mode;
  88. /*
  89. * Early DMI memory
  90. */
  91. int dmi_alloc_index;
  92. char dmi_alloc_data[DMI_MAX_DATA];
  93. /*
  94. * Setup options
  95. */
  96. struct screen_info screen_info;
  97. EXPORT_SYMBOL(screen_info);
  98. struct sys_desc_table_struct {
  99. unsigned short length;
  100. unsigned char table[0];
  101. };
  102. struct edid_info edid_info;
  103. EXPORT_SYMBOL_GPL(edid_info);
  104. extern int root_mountflags;
  105. char __initdata command_line[COMMAND_LINE_SIZE];
  106. static struct resource standard_io_resources[] = {
  107. { .name = "dma1", .start = 0x00, .end = 0x1f,
  108. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  109. { .name = "pic1", .start = 0x20, .end = 0x21,
  110. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  111. { .name = "timer0", .start = 0x40, .end = 0x43,
  112. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  113. { .name = "timer1", .start = 0x50, .end = 0x53,
  114. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  115. { .name = "keyboard", .start = 0x60, .end = 0x60,
  116. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  117. { .name = "keyboard", .start = 0x64, .end = 0x64,
  118. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  119. { .name = "dma page reg", .start = 0x80, .end = 0x8f,
  120. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  121. { .name = "pic2", .start = 0xa0, .end = 0xa1,
  122. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  123. { .name = "dma2", .start = 0xc0, .end = 0xdf,
  124. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  125. { .name = "fpu", .start = 0xf0, .end = 0xff,
  126. .flags = IORESOURCE_BUSY | IORESOURCE_IO }
  127. };
  128. #define IORESOURCE_RAM (IORESOURCE_BUSY | IORESOURCE_MEM)
  129. static struct resource data_resource = {
  130. .name = "Kernel data",
  131. .start = 0,
  132. .end = 0,
  133. .flags = IORESOURCE_RAM,
  134. };
  135. static struct resource code_resource = {
  136. .name = "Kernel code",
  137. .start = 0,
  138. .end = 0,
  139. .flags = IORESOURCE_RAM,
  140. };
  141. static struct resource bss_resource = {
  142. .name = "Kernel bss",
  143. .start = 0,
  144. .end = 0,
  145. .flags = IORESOURCE_RAM,
  146. };
  147. static void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c);
  148. #ifdef CONFIG_PROC_VMCORE
  149. /* elfcorehdr= specifies the location of elf core header
  150. * stored by the crashed kernel. This option will be passed
  151. * by kexec loader to the capture kernel.
  152. */
  153. static int __init setup_elfcorehdr(char *arg)
  154. {
  155. char *end;
  156. if (!arg)
  157. return -EINVAL;
  158. elfcorehdr_addr = memparse(arg, &end);
  159. return end > arg ? 0 : -EINVAL;
  160. }
  161. early_param("elfcorehdr", setup_elfcorehdr);
  162. #endif
  163. #ifndef CONFIG_NUMA
  164. static void __init
  165. contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
  166. {
  167. unsigned long bootmap_size, bootmap;
  168. bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
  169. bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size,
  170. PAGE_SIZE);
  171. if (bootmap == -1L)
  172. panic("Cannot find bootmem map of size %ld\n", bootmap_size);
  173. bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
  174. e820_register_active_regions(0, start_pfn, end_pfn);
  175. free_bootmem_with_active_regions(0, end_pfn);
  176. early_res_to_bootmem(0, end_pfn<<PAGE_SHIFT);
  177. reserve_bootmem(bootmap, bootmap_size, BOOTMEM_DEFAULT);
  178. }
  179. #endif
  180. #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
  181. struct edd edd;
  182. #ifdef CONFIG_EDD_MODULE
  183. EXPORT_SYMBOL(edd);
  184. #endif
  185. /**
  186. * copy_edd() - Copy the BIOS EDD information
  187. * from boot_params into a safe place.
  188. *
  189. */
  190. static inline void copy_edd(void)
  191. {
  192. memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
  193. sizeof(edd.mbr_signature));
  194. memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
  195. edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
  196. edd.edd_info_nr = boot_params.eddbuf_entries;
  197. }
  198. #else
  199. static inline void copy_edd(void)
  200. {
  201. }
  202. #endif
  203. #ifdef CONFIG_KEXEC
  204. static void __init reserve_crashkernel(void)
  205. {
  206. unsigned long long total_mem;
  207. unsigned long long crash_size, crash_base;
  208. int ret;
  209. total_mem = ((unsigned long long)max_low_pfn - min_low_pfn) << PAGE_SHIFT;
  210. ret = parse_crashkernel(boot_command_line, total_mem,
  211. &crash_size, &crash_base);
  212. if (ret == 0 && crash_size) {
  213. if (crash_base <= 0) {
  214. printk(KERN_INFO "crashkernel reservation failed - "
  215. "you have to specify a base address\n");
  216. return;
  217. }
  218. if (reserve_bootmem(crash_base, crash_size,
  219. BOOTMEM_EXCLUSIVE) < 0) {
  220. printk(KERN_INFO "crashkernel reservation failed - "
  221. "memory is in use\n");
  222. return;
  223. }
  224. printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
  225. "for crashkernel (System RAM: %ldMB)\n",
  226. (unsigned long)(crash_size >> 20),
  227. (unsigned long)(crash_base >> 20),
  228. (unsigned long)(total_mem >> 20));
  229. crashk_res.start = crash_base;
  230. crashk_res.end = crash_base + crash_size - 1;
  231. insert_resource(&iomem_resource, &crashk_res);
  232. }
  233. }
  234. #else
  235. static inline void __init reserve_crashkernel(void)
  236. {}
  237. #endif
  238. /* Overridden in paravirt.c if CONFIG_PARAVIRT */
  239. void __attribute__((weak)) __init memory_setup(void)
  240. {
  241. machine_specific_memory_setup();
  242. }
  243. static void __init parse_setup_data(void)
  244. {
  245. struct setup_data *data;
  246. unsigned long pa_data;
  247. if (boot_params.hdr.version < 0x0209)
  248. return;
  249. pa_data = boot_params.hdr.setup_data;
  250. while (pa_data) {
  251. data = early_ioremap(pa_data, PAGE_SIZE);
  252. switch (data->type) {
  253. default:
  254. break;
  255. }
  256. #ifndef CONFIG_DEBUG_BOOT_PARAMS
  257. free_early(pa_data, pa_data+sizeof(*data)+data->len);
  258. #endif
  259. pa_data = data->next;
  260. early_iounmap(data, PAGE_SIZE);
  261. }
  262. }
  263. /*
  264. * setup_arch - architecture-specific boot-time initializations
  265. *
  266. * Note: On x86_64, fixmaps are ready for use even before this is called.
  267. */
  268. void __init setup_arch(char **cmdline_p)
  269. {
  270. unsigned i;
  271. printk(KERN_INFO "Command line: %s\n", boot_command_line);
  272. ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
  273. screen_info = boot_params.screen_info;
  274. edid_info = boot_params.edid_info;
  275. saved_video_mode = boot_params.hdr.vid_mode;
  276. bootloader_type = boot_params.hdr.type_of_loader;
  277. #ifdef CONFIG_BLK_DEV_RAM
  278. rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
  279. rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
  280. rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
  281. #endif
  282. #ifdef CONFIG_EFI
  283. if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
  284. "EL64", 4))
  285. efi_enabled = 1;
  286. #endif
  287. ARCH_SETUP
  288. memory_setup();
  289. copy_edd();
  290. if (!boot_params.hdr.root_flags)
  291. root_mountflags &= ~MS_RDONLY;
  292. init_mm.start_code = (unsigned long) &_text;
  293. init_mm.end_code = (unsigned long) &_etext;
  294. init_mm.end_data = (unsigned long) &_edata;
  295. init_mm.brk = (unsigned long) &_end;
  296. code_resource.start = virt_to_phys(&_text);
  297. code_resource.end = virt_to_phys(&_etext)-1;
  298. data_resource.start = virt_to_phys(&_etext);
  299. data_resource.end = virt_to_phys(&_edata)-1;
  300. bss_resource.start = virt_to_phys(&__bss_start);
  301. bss_resource.end = virt_to_phys(&__bss_stop)-1;
  302. early_identify_cpu(&boot_cpu_data);
  303. strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
  304. *cmdline_p = command_line;
  305. parse_setup_data();
  306. parse_early_param();
  307. #ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
  308. if (init_ohci1394_dma_early)
  309. init_ohci1394_dma_on_all_controllers();
  310. #endif
  311. finish_e820_parsing();
  312. /* after parse_early_param, so could debug it */
  313. insert_resource(&iomem_resource, &code_resource);
  314. insert_resource(&iomem_resource, &data_resource);
  315. insert_resource(&iomem_resource, &bss_resource);
  316. early_gart_iommu_check();
  317. e820_register_active_regions(0, 0, -1UL);
  318. /*
  319. * partially used pages are not usable - thus
  320. * we are rounding upwards:
  321. */
  322. end_pfn = e820_end_of_ram();
  323. /* update e820 for memory not covered by WB MTRRs */
  324. mtrr_bp_init();
  325. if (mtrr_trim_uncached_memory(end_pfn)) {
  326. e820_register_active_regions(0, 0, -1UL);
  327. end_pfn = e820_end_of_ram();
  328. }
  329. num_physpages = end_pfn;
  330. check_efer();
  331. max_pfn_mapped = init_memory_mapping(0, (max_pfn_mapped << PAGE_SHIFT));
  332. if (efi_enabled)
  333. efi_init();
  334. vsmp_init();
  335. dmi_scan_machine();
  336. io_delay_init();
  337. #ifdef CONFIG_KVM_CLOCK
  338. kvmclock_init();
  339. #endif
  340. #ifdef CONFIG_SMP
  341. /* setup to use the early static init tables during kernel startup */
  342. x86_cpu_to_apicid_early_ptr = (void *)x86_cpu_to_apicid_init;
  343. x86_bios_cpu_apicid_early_ptr = (void *)x86_bios_cpu_apicid_init;
  344. #ifdef CONFIG_NUMA
  345. x86_cpu_to_node_map_early_ptr = (void *)x86_cpu_to_node_map_init;
  346. #endif
  347. #endif
  348. #ifdef CONFIG_ACPI
  349. /*
  350. * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
  351. * Call this early for SRAT node setup.
  352. */
  353. acpi_boot_table_init();
  354. #endif
  355. /* How many end-of-memory variables you have, grandma! */
  356. max_low_pfn = end_pfn;
  357. max_pfn = end_pfn;
  358. high_memory = (void *)__va(end_pfn * PAGE_SIZE - 1) + 1;
  359. /* Remove active ranges so rediscovery with NUMA-awareness happens */
  360. remove_all_active_ranges();
  361. #ifdef CONFIG_ACPI_NUMA
  362. /*
  363. * Parse SRAT to discover nodes.
  364. */
  365. acpi_numa_init();
  366. #endif
  367. #ifdef CONFIG_NUMA
  368. numa_initmem_init(0, end_pfn);
  369. #else
  370. contig_initmem_init(0, end_pfn);
  371. #endif
  372. dma32_reserve_bootmem();
  373. #ifdef CONFIG_ACPI_SLEEP
  374. /*
  375. * Reserve low memory region for sleep support.
  376. */
  377. acpi_reserve_bootmem();
  378. #endif
  379. if (efi_enabled)
  380. efi_reserve_bootmem();
  381. /*
  382. * Find and reserve possible boot-time SMP configuration:
  383. */
  384. find_smp_config();
  385. #ifdef CONFIG_BLK_DEV_INITRD
  386. if (boot_params.hdr.type_of_loader && boot_params.hdr.ramdisk_image) {
  387. unsigned long ramdisk_image = boot_params.hdr.ramdisk_image;
  388. unsigned long ramdisk_size = boot_params.hdr.ramdisk_size;
  389. unsigned long ramdisk_end = ramdisk_image + ramdisk_size;
  390. unsigned long end_of_mem = end_pfn << PAGE_SHIFT;
  391. if (ramdisk_end <= end_of_mem) {
  392. /*
  393. * don't need to reserve again, already reserved early
  394. * in x86_64_start_kernel, and early_res_to_bootmem
  395. * convert that to reserved in bootmem
  396. */
  397. initrd_start = ramdisk_image + PAGE_OFFSET;
  398. initrd_end = initrd_start+ramdisk_size;
  399. } else {
  400. free_bootmem(ramdisk_image, ramdisk_size);
  401. printk(KERN_ERR "initrd extends beyond end of memory "
  402. "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
  403. ramdisk_end, end_of_mem);
  404. initrd_start = 0;
  405. }
  406. }
  407. #endif
  408. reserve_crashkernel();
  409. reserve_ibft_region();
  410. paging_init();
  411. map_vsyscall();
  412. early_quirks();
  413. #ifdef CONFIG_ACPI
  414. /*
  415. * Read APIC and some other early information from ACPI tables.
  416. */
  417. acpi_boot_init();
  418. #endif
  419. init_cpu_to_node();
  420. /*
  421. * get boot-time SMP configuration:
  422. */
  423. if (smp_found_config)
  424. get_smp_config();
  425. init_apic_mappings();
  426. ioapic_init_mappings();
  427. kvm_guest_init();
  428. /*
  429. * We trust e820 completely. No explicit ROM probing in memory.
  430. */
  431. e820_reserve_resources();
  432. e820_mark_nosave_regions();
  433. /* request I/O space for devices used on all i[345]86 PCs */
  434. for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
  435. request_resource(&ioport_resource, &standard_io_resources[i]);
  436. e820_setup_gap();
  437. #ifdef CONFIG_VT
  438. #if defined(CONFIG_VGA_CONSOLE)
  439. if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
  440. conswitchp = &vga_con;
  441. #elif defined(CONFIG_DUMMY_CONSOLE)
  442. conswitchp = &dummy_con;
  443. #endif
  444. #endif
  445. /* do this before identify_cpu for boot cpu */
  446. check_enable_amd_mmconf_dmi();
  447. }
  448. int __cpuinit get_model_name(struct cpuinfo_x86 *c)
  449. {
  450. unsigned int *v;
  451. if (c->extended_cpuid_level < 0x80000004)
  452. return 0;
  453. v = (unsigned int *) c->x86_model_id;
  454. cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
  455. cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
  456. cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
  457. c->x86_model_id[48] = 0;
  458. return 1;
  459. }
  460. void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
  461. {
  462. unsigned int n, dummy, eax, ebx, ecx, edx;
  463. n = c->extended_cpuid_level;
  464. if (n >= 0x80000005) {
  465. cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
  466. printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), "
  467. "D cache %dK (%d bytes/line)\n",
  468. edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
  469. c->x86_cache_size = (ecx>>24) + (edx>>24);
  470. /* On K8 L1 TLB is inclusive, so don't count it */
  471. c->x86_tlbsize = 0;
  472. }
  473. if (n >= 0x80000006) {
  474. cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
  475. ecx = cpuid_ecx(0x80000006);
  476. c->x86_cache_size = ecx >> 16;
  477. c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
  478. printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
  479. c->x86_cache_size, ecx & 0xFF);
  480. }
  481. if (n >= 0x80000008) {
  482. cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
  483. c->x86_virt_bits = (eax >> 8) & 0xff;
  484. c->x86_phys_bits = eax & 0xff;
  485. }
  486. }
  487. void __cpuinit detect_ht(struct cpuinfo_x86 *c)
  488. {
  489. #ifdef CONFIG_SMP
  490. u32 eax, ebx, ecx, edx;
  491. int index_msb, core_bits;
  492. cpuid(1, &eax, &ebx, &ecx, &edx);
  493. if (!cpu_has(c, X86_FEATURE_HT))
  494. return;
  495. if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
  496. goto out;
  497. smp_num_siblings = (ebx & 0xff0000) >> 16;
  498. if (smp_num_siblings == 1) {
  499. printk(KERN_INFO "CPU: Hyper-Threading is disabled\n");
  500. } else if (smp_num_siblings > 1) {
  501. if (smp_num_siblings > NR_CPUS) {
  502. printk(KERN_WARNING "CPU: Unsupported number of "
  503. "siblings %d", smp_num_siblings);
  504. smp_num_siblings = 1;
  505. return;
  506. }
  507. index_msb = get_count_order(smp_num_siblings);
  508. c->phys_proc_id = phys_pkg_id(index_msb);
  509. smp_num_siblings = smp_num_siblings / c->x86_max_cores;
  510. index_msb = get_count_order(smp_num_siblings);
  511. core_bits = get_count_order(c->x86_max_cores);
  512. c->cpu_core_id = phys_pkg_id(index_msb) &
  513. ((1 << core_bits) - 1);
  514. }
  515. out:
  516. if ((c->x86_max_cores * smp_num_siblings) > 1) {
  517. printk(KERN_INFO "CPU: Physical Processor ID: %d\n",
  518. c->phys_proc_id);
  519. printk(KERN_INFO "CPU: Processor Core ID: %d\n",
  520. c->cpu_core_id);
  521. }
  522. #endif
  523. }
  524. static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
  525. {
  526. char *v = c->x86_vendor_id;
  527. if (!strcmp(v, "AuthenticAMD"))
  528. c->x86_vendor = X86_VENDOR_AMD;
  529. else if (!strcmp(v, "GenuineIntel"))
  530. c->x86_vendor = X86_VENDOR_INTEL;
  531. else if (!strcmp(v, "CentaurHauls"))
  532. c->x86_vendor = X86_VENDOR_CENTAUR;
  533. else
  534. c->x86_vendor = X86_VENDOR_UNKNOWN;
  535. }
  536. // FIXME: Needs to use cpu_vendor_dev_register
  537. extern void __cpuinit early_init_amd(struct cpuinfo_x86 *c);
  538. extern void __cpuinit init_amd(struct cpuinfo_x86 *c);
  539. extern void __cpuinit early_init_intel(struct cpuinfo_x86 *c);
  540. extern void __cpuinit init_intel(struct cpuinfo_x86 *c);
  541. extern void __cpuinit early_init_centaur(struct cpuinfo_x86 *c);
  542. extern void __cpuinit init_centaur(struct cpuinfo_x86 *c);
  543. /* Do some early cpuid on the boot CPU to get some parameter that are
  544. needed before check_bugs. Everything advanced is in identify_cpu
  545. below. */
  546. static void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
  547. {
  548. u32 tfms, xlvl;
  549. c->loops_per_jiffy = loops_per_jiffy;
  550. c->x86_cache_size = -1;
  551. c->x86_vendor = X86_VENDOR_UNKNOWN;
  552. c->x86_model = c->x86_mask = 0; /* So far unknown... */
  553. c->x86_vendor_id[0] = '\0'; /* Unset */
  554. c->x86_model_id[0] = '\0'; /* Unset */
  555. c->x86_clflush_size = 64;
  556. c->x86_cache_alignment = c->x86_clflush_size;
  557. c->x86_max_cores = 1;
  558. c->x86_coreid_bits = 0;
  559. c->extended_cpuid_level = 0;
  560. memset(&c->x86_capability, 0, sizeof c->x86_capability);
  561. /* Get vendor name */
  562. cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
  563. (unsigned int *)&c->x86_vendor_id[0],
  564. (unsigned int *)&c->x86_vendor_id[8],
  565. (unsigned int *)&c->x86_vendor_id[4]);
  566. get_cpu_vendor(c);
  567. /* Initialize the standard set of capabilities */
  568. /* Note that the vendor-specific code below might override */
  569. /* Intel-defined flags: level 0x00000001 */
  570. if (c->cpuid_level >= 0x00000001) {
  571. __u32 misc;
  572. cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
  573. &c->x86_capability[0]);
  574. c->x86 = (tfms >> 8) & 0xf;
  575. c->x86_model = (tfms >> 4) & 0xf;
  576. c->x86_mask = tfms & 0xf;
  577. if (c->x86 == 0xf)
  578. c->x86 += (tfms >> 20) & 0xff;
  579. if (c->x86 >= 0x6)
  580. c->x86_model += ((tfms >> 16) & 0xF) << 4;
  581. if (test_cpu_cap(c, X86_FEATURE_CLFLSH))
  582. c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
  583. } else {
  584. /* Have CPUID level 0 only - unheard of */
  585. c->x86 = 4;
  586. }
  587. c->initial_apicid = (cpuid_ebx(1) >> 24) & 0xff;
  588. #ifdef CONFIG_SMP
  589. c->phys_proc_id = c->initial_apicid;
  590. #endif
  591. /* AMD-defined flags: level 0x80000001 */
  592. xlvl = cpuid_eax(0x80000000);
  593. c->extended_cpuid_level = xlvl;
  594. if ((xlvl & 0xffff0000) == 0x80000000) {
  595. if (xlvl >= 0x80000001) {
  596. c->x86_capability[1] = cpuid_edx(0x80000001);
  597. c->x86_capability[6] = cpuid_ecx(0x80000001);
  598. }
  599. if (xlvl >= 0x80000004)
  600. get_model_name(c); /* Default name */
  601. }
  602. /* Transmeta-defined flags: level 0x80860001 */
  603. xlvl = cpuid_eax(0x80860000);
  604. if ((xlvl & 0xffff0000) == 0x80860000) {
  605. /* Don't set x86_cpuid_level here for now to not confuse. */
  606. if (xlvl >= 0x80860001)
  607. c->x86_capability[2] = cpuid_edx(0x80860001);
  608. }
  609. c->extended_cpuid_level = cpuid_eax(0x80000000);
  610. if (c->extended_cpuid_level >= 0x80000007)
  611. c->x86_power = cpuid_edx(0x80000007);
  612. switch (c->x86_vendor) {
  613. case X86_VENDOR_AMD:
  614. early_init_amd(c);
  615. break;
  616. case X86_VENDOR_INTEL:
  617. early_init_intel(c);
  618. break;
  619. case X86_VENDOR_CENTAUR:
  620. early_init_centaur(c);
  621. break;
  622. }
  623. validate_pat_support(c);
  624. }
  625. /*
  626. * This does the hard work of actually picking apart the CPU stuff...
  627. */
  628. void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
  629. {
  630. int i;
  631. early_identify_cpu(c);
  632. init_scattered_cpuid_features(c);
  633. c->apicid = phys_pkg_id(0);
  634. /*
  635. * Vendor-specific initialization. In this section we
  636. * canonicalize the feature flags, meaning if there are
  637. * features a certain CPU supports which CPUID doesn't
  638. * tell us, CPUID claiming incorrect flags, or other bugs,
  639. * we handle them here.
  640. *
  641. * At the end of this section, c->x86_capability better
  642. * indicate the features this CPU genuinely supports!
  643. */
  644. switch (c->x86_vendor) {
  645. case X86_VENDOR_AMD:
  646. init_amd(c);
  647. break;
  648. case X86_VENDOR_INTEL:
  649. init_intel(c);
  650. break;
  651. case X86_VENDOR_CENTAUR:
  652. init_centaur(c);
  653. break;
  654. case X86_VENDOR_UNKNOWN:
  655. default:
  656. display_cacheinfo(c);
  657. break;
  658. }
  659. detect_ht(c);
  660. /*
  661. * On SMP, boot_cpu_data holds the common feature set between
  662. * all CPUs; so make sure that we indicate which features are
  663. * common between the CPUs. The first time this routine gets
  664. * executed, c == &boot_cpu_data.
  665. */
  666. if (c != &boot_cpu_data) {
  667. /* AND the already accumulated flags with these */
  668. for (i = 0; i < NCAPINTS; i++)
  669. boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
  670. }
  671. /* Clear all flags overriden by options */
  672. for (i = 0; i < NCAPINTS; i++)
  673. c->x86_capability[i] &= ~cleared_cpu_caps[i];
  674. #ifdef CONFIG_X86_MCE
  675. mcheck_init(c);
  676. #endif
  677. select_idle_routine(c);
  678. #ifdef CONFIG_NUMA
  679. numa_add_cpu(smp_processor_id());
  680. #endif
  681. }
  682. void __cpuinit identify_boot_cpu(void)
  683. {
  684. identify_cpu(&boot_cpu_data);
  685. }
  686. void __cpuinit identify_secondary_cpu(struct cpuinfo_x86 *c)
  687. {
  688. BUG_ON(c == &boot_cpu_data);
  689. identify_cpu(c);
  690. mtrr_ap_init();
  691. }
  692. static __init int setup_noclflush(char *arg)
  693. {
  694. setup_clear_cpu_cap(X86_FEATURE_CLFLSH);
  695. return 1;
  696. }
  697. __setup("noclflush", setup_noclflush);
  698. void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
  699. {
  700. if (c->x86_model_id[0])
  701. printk(KERN_CONT "%s", c->x86_model_id);
  702. if (c->x86_mask || c->cpuid_level >= 0)
  703. printk(KERN_CONT " stepping %02x\n", c->x86_mask);
  704. else
  705. printk(KERN_CONT "\n");
  706. }
  707. static __init int setup_disablecpuid(char *arg)
  708. {
  709. int bit;
  710. if (get_option(&arg, &bit) && bit < NCAPINTS*32)
  711. setup_clear_cpu_cap(bit);
  712. else
  713. return 0;
  714. return 1;
  715. }
  716. __setup("clearcpuid=", setup_disablecpuid);