setup.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096
  1. /*
  2. * Copyright (C) 1995 Linus Torvalds
  3. *
  4. * Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
  5. *
  6. * Memory region support
  7. * David Parsons <orc@pell.chi.il.us>, July-August 1999
  8. *
  9. * Added E820 sanitization routine (removes overlapping memory regions);
  10. * Brian Moyle <bmoyle@mvista.com>, February 2001
  11. *
  12. * Moved CPU detection code to cpu/${cpu}.c
  13. * Patrick Mochel <mochel@osdl.org>, March 2002
  14. *
  15. * Provisions for empty E820 memory regions (reported by certain BIOSes).
  16. * Alex Achenbach <xela@slit.de>, December 2002.
  17. *
  18. */
  19. /*
  20. * This file handles the architecture-dependent parts of initialization
  21. */
  22. #include <linux/sched.h>
  23. #include <linux/mm.h>
  24. #include <linux/mmzone.h>
  25. #include <linux/screen_info.h>
  26. #include <linux/ioport.h>
  27. #include <linux/acpi.h>
  28. #include <linux/sfi.h>
  29. #include <linux/apm_bios.h>
  30. #include <linux/initrd.h>
  31. #include <linux/bootmem.h>
  32. #include <linux/memblock.h>
  33. #include <linux/seq_file.h>
  34. #include <linux/console.h>
  35. #include <linux/mca.h>
  36. #include <linux/root_dev.h>
  37. #include <linux/highmem.h>
  38. #include <linux/module.h>
  39. #include <linux/efi.h>
  40. #include <linux/init.h>
  41. #include <linux/edd.h>
  42. #include <linux/iscsi_ibft.h>
  43. #include <linux/nodemask.h>
  44. #include <linux/kexec.h>
  45. #include <linux/dmi.h>
  46. #include <linux/pfn.h>
  47. #include <linux/pci.h>
  48. #include <asm/pci-direct.h>
  49. #include <linux/init_ohci1394_dma.h>
  50. #include <linux/kvm_para.h>
  51. #include <linux/errno.h>
  52. #include <linux/kernel.h>
  53. #include <linux/stddef.h>
  54. #include <linux/unistd.h>
  55. #include <linux/ptrace.h>
  56. #include <linux/user.h>
  57. #include <linux/delay.h>
  58. #include <linux/kallsyms.h>
  59. #include <linux/cpufreq.h>
  60. #include <linux/dma-mapping.h>
  61. #include <linux/ctype.h>
  62. #include <linux/uaccess.h>
  63. #include <linux/percpu.h>
  64. #include <linux/crash_dump.h>
  65. #include <linux/tboot.h>
  66. #include <video/edid.h>
  67. #include <asm/mtrr.h>
  68. #include <asm/apic.h>
  69. #include <asm/trampoline.h>
  70. #include <asm/e820.h>
  71. #include <asm/mpspec.h>
  72. #include <asm/setup.h>
  73. #include <asm/efi.h>
  74. #include <asm/timer.h>
  75. #include <asm/i8259.h>
  76. #include <asm/sections.h>
  77. #include <asm/dmi.h>
  78. #include <asm/io_apic.h>
  79. #include <asm/ist.h>
  80. #include <asm/setup_arch.h>
  81. #include <asm/bios_ebda.h>
  82. #include <asm/cacheflush.h>
  83. #include <asm/processor.h>
  84. #include <asm/bugs.h>
  85. #include <asm/system.h>
  86. #include <asm/vsyscall.h>
  87. #include <asm/cpu.h>
  88. #include <asm/desc.h>
  89. #include <asm/dma.h>
  90. #include <asm/iommu.h>
  91. #include <asm/gart.h>
  92. #include <asm/mmu_context.h>
  93. #include <asm/proto.h>
  94. #include <asm/paravirt.h>
  95. #include <asm/hypervisor.h>
  96. #include <asm/olpc_ofw.h>
  97. #include <asm/percpu.h>
  98. #include <asm/topology.h>
  99. #include <asm/apicdef.h>
  100. #include <asm/amd_nb.h>
  101. #ifdef CONFIG_X86_64
  102. #include <asm/numa_64.h>
  103. #endif
  104. #include <asm/mce.h>
  105. #include <asm/alternative.h>
  106. /*
  107. * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries.
  108. * The direct mapping extends to max_pfn_mapped, so that we can directly access
  109. * apertures, ACPI and other tables without having to play with fixmaps.
  110. */
  111. unsigned long max_low_pfn_mapped;
  112. unsigned long max_pfn_mapped;
  113. #ifdef CONFIG_DMI
  114. RESERVE_BRK(dmi_alloc, 65536);
  115. #endif
  116. static __initdata unsigned long _brk_start = (unsigned long)__brk_base;
  117. unsigned long _brk_end = (unsigned long)__brk_base;
  118. #ifdef CONFIG_X86_64
  119. int default_cpu_present_to_apicid(int mps_cpu)
  120. {
  121. return __default_cpu_present_to_apicid(mps_cpu);
  122. }
  123. int default_check_phys_apicid_present(int phys_apicid)
  124. {
  125. return __default_check_phys_apicid_present(phys_apicid);
  126. }
  127. #endif
  128. #ifndef CONFIG_DEBUG_BOOT_PARAMS
  129. struct boot_params __initdata boot_params;
  130. #else
  131. struct boot_params boot_params;
  132. #endif
  133. /*
  134. * Machine setup..
  135. */
  136. static struct resource data_resource = {
  137. .name = "Kernel data",
  138. .start = 0,
  139. .end = 0,
  140. .flags = IORESOURCE_BUSY | IORESOURCE_MEM
  141. };
  142. static struct resource code_resource = {
  143. .name = "Kernel code",
  144. .start = 0,
  145. .end = 0,
  146. .flags = IORESOURCE_BUSY | IORESOURCE_MEM
  147. };
  148. static struct resource bss_resource = {
  149. .name = "Kernel bss",
  150. .start = 0,
  151. .end = 0,
  152. .flags = IORESOURCE_BUSY | IORESOURCE_MEM
  153. };
  154. #ifdef CONFIG_X86_32
  155. /* cpu data as detected by the assembly code in head.S */
  156. struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
  157. /* common cpu data for all cpus */
  158. struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
  159. EXPORT_SYMBOL(boot_cpu_data);
  160. static void set_mca_bus(int x)
  161. {
  162. #ifdef CONFIG_MCA
  163. MCA_bus = x;
  164. #endif
  165. }
  166. unsigned int def_to_bigsmp;
  167. /* for MCA, but anyone else can use it if they want */
  168. unsigned int machine_id;
  169. unsigned int machine_submodel_id;
  170. unsigned int BIOS_revision;
  171. struct apm_info apm_info;
  172. EXPORT_SYMBOL(apm_info);
  173. #if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
  174. defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
  175. struct ist_info ist_info;
  176. EXPORT_SYMBOL(ist_info);
  177. #else
  178. struct ist_info ist_info;
  179. #endif
  180. #else
  181. struct cpuinfo_x86 boot_cpu_data __read_mostly = {
  182. .x86_phys_bits = MAX_PHYSMEM_BITS,
  183. };
  184. EXPORT_SYMBOL(boot_cpu_data);
  185. #endif
  186. #if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
  187. unsigned long mmu_cr4_features;
  188. #else
  189. unsigned long mmu_cr4_features = X86_CR4_PAE;
  190. #endif
  191. /* Boot loader ID and version as integers, for the benefit of proc_dointvec */
  192. int bootloader_type, bootloader_version;
  193. /*
  194. * Setup options
  195. */
  196. struct screen_info screen_info;
  197. EXPORT_SYMBOL(screen_info);
  198. struct edid_info edid_info;
  199. EXPORT_SYMBOL_GPL(edid_info);
  200. extern int root_mountflags;
  201. unsigned long saved_video_mode;
  202. #define RAMDISK_IMAGE_START_MASK 0x07FF
  203. #define RAMDISK_PROMPT_FLAG 0x8000
  204. #define RAMDISK_LOAD_FLAG 0x4000
  205. static char __initdata command_line[COMMAND_LINE_SIZE];
  206. #ifdef CONFIG_CMDLINE_BOOL
  207. static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
  208. #endif
  209. #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
  210. struct edd edd;
  211. #ifdef CONFIG_EDD_MODULE
  212. EXPORT_SYMBOL(edd);
  213. #endif
  214. /**
  215. * copy_edd() - Copy the BIOS EDD information
  216. * from boot_params into a safe place.
  217. *
  218. */
  219. static inline void __init copy_edd(void)
  220. {
  221. memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
  222. sizeof(edd.mbr_signature));
  223. memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
  224. edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
  225. edd.edd_info_nr = boot_params.eddbuf_entries;
  226. }
  227. #else
  228. static inline void __init copy_edd(void)
  229. {
  230. }
  231. #endif
  232. void * __init extend_brk(size_t size, size_t align)
  233. {
  234. size_t mask = align - 1;
  235. void *ret;
  236. BUG_ON(_brk_start == 0);
  237. BUG_ON(align & mask);
  238. _brk_end = (_brk_end + mask) & ~mask;
  239. BUG_ON((char *)(_brk_end + size) > __brk_limit);
  240. ret = (void *)_brk_end;
  241. _brk_end += size;
  242. memset(ret, 0, size);
  243. return ret;
  244. }
  245. #ifdef CONFIG_X86_64
  246. static void __init init_gbpages(void)
  247. {
  248. if (direct_gbpages && cpu_has_gbpages)
  249. printk(KERN_INFO "Using GB pages for direct mapping\n");
  250. else
  251. direct_gbpages = 0;
  252. }
  253. static void __init cleanup_highmap_brk_end(void)
  254. {
  255. pud_t *pud;
  256. pmd_t *pmd;
  257. mmu_cr4_features = read_cr4();
  258. /*
  259. * _brk_end cannot change anymore, but it and _end may be
  260. * located on different 2M pages. cleanup_highmap(), however,
  261. * can only consider _end when it runs, so destroy any
  262. * mappings beyond _brk_end here.
  263. */
  264. pud = pud_offset(pgd_offset_k(_brk_end), _brk_end);
  265. pmd = pmd_offset(pud, _brk_end - 1);
  266. while (++pmd <= pmd_offset(pud, (unsigned long)_end - 1))
  267. pmd_clear(pmd);
  268. }
  269. #else
  270. static inline void init_gbpages(void)
  271. {
  272. }
  273. static inline void cleanup_highmap_brk_end(void)
  274. {
  275. }
  276. #endif
  277. static void __init reserve_brk(void)
  278. {
  279. if (_brk_end > _brk_start)
  280. memblock_x86_reserve_range(__pa(_brk_start), __pa(_brk_end), "BRK");
  281. /* Mark brk area as locked down and no longer taking any
  282. new allocations */
  283. _brk_start = 0;
  284. cleanup_highmap_brk_end();
  285. }
  286. #ifdef CONFIG_BLK_DEV_INITRD
  287. #define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT)
  288. static void __init relocate_initrd(void)
  289. {
  290. /* Assume only end is not page aligned */
  291. u64 ramdisk_image = boot_params.hdr.ramdisk_image;
  292. u64 ramdisk_size = boot_params.hdr.ramdisk_size;
  293. u64 area_size = PAGE_ALIGN(ramdisk_size);
  294. u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
  295. u64 ramdisk_here;
  296. unsigned long slop, clen, mapaddr;
  297. char *p, *q;
  298. /* We need to move the initrd down into lowmem */
  299. ramdisk_here = memblock_find_in_range(0, end_of_lowmem, area_size,
  300. PAGE_SIZE);
  301. if (ramdisk_here == MEMBLOCK_ERROR)
  302. panic("Cannot find place for new RAMDISK of size %lld\n",
  303. ramdisk_size);
  304. /* Note: this includes all the lowmem currently occupied by
  305. the initrd, we rely on that fact to keep the data intact. */
  306. memblock_x86_reserve_range(ramdisk_here, ramdisk_here + area_size, "NEW RAMDISK");
  307. initrd_start = ramdisk_here + PAGE_OFFSET;
  308. initrd_end = initrd_start + ramdisk_size;
  309. printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
  310. ramdisk_here, ramdisk_here + ramdisk_size);
  311. q = (char *)initrd_start;
  312. /* Copy any lowmem portion of the initrd */
  313. if (ramdisk_image < end_of_lowmem) {
  314. clen = end_of_lowmem - ramdisk_image;
  315. p = (char *)__va(ramdisk_image);
  316. memcpy(q, p, clen);
  317. q += clen;
  318. ramdisk_image += clen;
  319. ramdisk_size -= clen;
  320. }
  321. /* Copy the highmem portion of the initrd */
  322. while (ramdisk_size) {
  323. slop = ramdisk_image & ~PAGE_MASK;
  324. clen = ramdisk_size;
  325. if (clen > MAX_MAP_CHUNK-slop)
  326. clen = MAX_MAP_CHUNK-slop;
  327. mapaddr = ramdisk_image & PAGE_MASK;
  328. p = early_memremap(mapaddr, clen+slop);
  329. memcpy(q, p+slop, clen);
  330. early_iounmap(p, clen+slop);
  331. q += clen;
  332. ramdisk_image += clen;
  333. ramdisk_size -= clen;
  334. }
  335. /* high pages is not converted by early_res_to_bootmem */
  336. ramdisk_image = boot_params.hdr.ramdisk_image;
  337. ramdisk_size = boot_params.hdr.ramdisk_size;
  338. printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
  339. " %08llx - %08llx\n",
  340. ramdisk_image, ramdisk_image + ramdisk_size - 1,
  341. ramdisk_here, ramdisk_here + ramdisk_size - 1);
  342. }
  343. static void __init reserve_initrd(void)
  344. {
  345. /* Assume only end is not page aligned */
  346. u64 ramdisk_image = boot_params.hdr.ramdisk_image;
  347. u64 ramdisk_size = boot_params.hdr.ramdisk_size;
  348. u64 ramdisk_end = PAGE_ALIGN(ramdisk_image + ramdisk_size);
  349. u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
  350. if (!boot_params.hdr.type_of_loader ||
  351. !ramdisk_image || !ramdisk_size)
  352. return; /* No initrd provided by bootloader */
  353. initrd_start = 0;
  354. if (ramdisk_size >= (end_of_lowmem>>1)) {
  355. memblock_x86_free_range(ramdisk_image, ramdisk_end);
  356. printk(KERN_ERR "initrd too large to handle, "
  357. "disabling initrd\n");
  358. return;
  359. }
  360. printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image,
  361. ramdisk_end);
  362. if (ramdisk_end <= end_of_lowmem) {
  363. /* All in lowmem, easy case */
  364. /*
  365. * don't need to reserve again, already reserved early
  366. * in i386_start_kernel
  367. */
  368. initrd_start = ramdisk_image + PAGE_OFFSET;
  369. initrd_end = initrd_start + ramdisk_size;
  370. return;
  371. }
  372. relocate_initrd();
  373. memblock_x86_free_range(ramdisk_image, ramdisk_end);
  374. }
  375. #else
  376. static void __init reserve_initrd(void)
  377. {
  378. }
  379. #endif /* CONFIG_BLK_DEV_INITRD */
  380. static void __init parse_setup_data(void)
  381. {
  382. struct setup_data *data;
  383. u64 pa_data;
  384. if (boot_params.hdr.version < 0x0209)
  385. return;
  386. pa_data = boot_params.hdr.setup_data;
  387. while (pa_data) {
  388. data = early_memremap(pa_data, PAGE_SIZE);
  389. switch (data->type) {
  390. case SETUP_E820_EXT:
  391. parse_e820_ext(data, pa_data);
  392. break;
  393. default:
  394. break;
  395. }
  396. pa_data = data->next;
  397. early_iounmap(data, PAGE_SIZE);
  398. }
  399. }
  400. static void __init e820_reserve_setup_data(void)
  401. {
  402. struct setup_data *data;
  403. u64 pa_data;
  404. int found = 0;
  405. if (boot_params.hdr.version < 0x0209)
  406. return;
  407. pa_data = boot_params.hdr.setup_data;
  408. while (pa_data) {
  409. data = early_memremap(pa_data, sizeof(*data));
  410. e820_update_range(pa_data, sizeof(*data)+data->len,
  411. E820_RAM, E820_RESERVED_KERN);
  412. found = 1;
  413. pa_data = data->next;
  414. early_iounmap(data, sizeof(*data));
  415. }
  416. if (!found)
  417. return;
  418. sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
  419. memcpy(&e820_saved, &e820, sizeof(struct e820map));
  420. printk(KERN_INFO "extended physical RAM map:\n");
  421. e820_print_map("reserve setup_data");
  422. }
  423. static void __init memblock_x86_reserve_range_setup_data(void)
  424. {
  425. struct setup_data *data;
  426. u64 pa_data;
  427. char buf[32];
  428. if (boot_params.hdr.version < 0x0209)
  429. return;
  430. pa_data = boot_params.hdr.setup_data;
  431. while (pa_data) {
  432. data = early_memremap(pa_data, sizeof(*data));
  433. sprintf(buf, "setup data %x", data->type);
  434. memblock_x86_reserve_range(pa_data, pa_data+sizeof(*data)+data->len, buf);
  435. pa_data = data->next;
  436. early_iounmap(data, sizeof(*data));
  437. }
  438. }
  439. /*
  440. * --------- Crashkernel reservation ------------------------------
  441. */
  442. #ifdef CONFIG_KEXEC
  443. static inline unsigned long long get_total_mem(void)
  444. {
  445. unsigned long long total;
  446. total = max_pfn - min_low_pfn;
  447. return total << PAGE_SHIFT;
  448. }
  449. /*
  450. * Keep the crash kernel below this limit. On 32 bits earlier kernels
  451. * would limit the kernel to the low 512 MiB due to mapping restrictions.
  452. * On 64 bits, kexec-tools currently limits us to 896 MiB; increase this
  453. * limit once kexec-tools are fixed.
  454. */
  455. #ifdef CONFIG_X86_32
  456. # define CRASH_KERNEL_ADDR_MAX (512 << 20)
  457. #else
  458. # define CRASH_KERNEL_ADDR_MAX (896 << 20)
  459. #endif
  460. static void __init reserve_crashkernel(void)
  461. {
  462. unsigned long long total_mem;
  463. unsigned long long crash_size, crash_base;
  464. int ret;
  465. total_mem = get_total_mem();
  466. ret = parse_crashkernel(boot_command_line, total_mem,
  467. &crash_size, &crash_base);
  468. if (ret != 0 || crash_size <= 0)
  469. return;
  470. /* 0 means: find the address automatically */
  471. if (crash_base <= 0) {
  472. const unsigned long long alignment = 16<<20; /* 16M */
  473. /*
  474. * kexec want bzImage is below CRASH_KERNEL_ADDR_MAX
  475. */
  476. crash_base = memblock_find_in_range(alignment,
  477. CRASH_KERNEL_ADDR_MAX, crash_size, alignment);
  478. if (crash_base == MEMBLOCK_ERROR) {
  479. pr_info("crashkernel reservation failed - No suitable area found.\n");
  480. return;
  481. }
  482. } else {
  483. unsigned long long start;
  484. start = memblock_find_in_range(crash_base,
  485. crash_base + crash_size, crash_size, 1<<20);
  486. if (start != crash_base) {
  487. pr_info("crashkernel reservation failed - memory is in use.\n");
  488. return;
  489. }
  490. }
  491. memblock_x86_reserve_range(crash_base, crash_base + crash_size, "CRASH KERNEL");
  492. printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
  493. "for crashkernel (System RAM: %ldMB)\n",
  494. (unsigned long)(crash_size >> 20),
  495. (unsigned long)(crash_base >> 20),
  496. (unsigned long)(total_mem >> 20));
  497. crashk_res.start = crash_base;
  498. crashk_res.end = crash_base + crash_size - 1;
  499. insert_resource(&iomem_resource, &crashk_res);
  500. }
  501. #else
  502. static void __init reserve_crashkernel(void)
  503. {
  504. }
  505. #endif
  506. static struct resource standard_io_resources[] = {
  507. { .name = "dma1", .start = 0x00, .end = 0x1f,
  508. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  509. { .name = "pic1", .start = 0x20, .end = 0x21,
  510. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  511. { .name = "timer0", .start = 0x40, .end = 0x43,
  512. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  513. { .name = "timer1", .start = 0x50, .end = 0x53,
  514. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  515. { .name = "keyboard", .start = 0x60, .end = 0x60,
  516. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  517. { .name = "keyboard", .start = 0x64, .end = 0x64,
  518. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  519. { .name = "dma page reg", .start = 0x80, .end = 0x8f,
  520. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  521. { .name = "pic2", .start = 0xa0, .end = 0xa1,
  522. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  523. { .name = "dma2", .start = 0xc0, .end = 0xdf,
  524. .flags = IORESOURCE_BUSY | IORESOURCE_IO },
  525. { .name = "fpu", .start = 0xf0, .end = 0xff,
  526. .flags = IORESOURCE_BUSY | IORESOURCE_IO }
  527. };
  528. void __init reserve_standard_io_resources(void)
  529. {
  530. int i;
  531. /* request I/O space for devices used on all i[345]86 PCs */
  532. for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
  533. request_resource(&ioport_resource, &standard_io_resources[i]);
  534. }
  535. /*
  536. * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
  537. * is_kdump_kernel() to determine if we are booting after a panic. Hence
  538. * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
  539. */
  540. #ifdef CONFIG_CRASH_DUMP
  541. /* elfcorehdr= specifies the location of elf core header
  542. * stored by the crashed kernel. This option will be passed
  543. * by kexec loader to the capture kernel.
  544. */
  545. static int __init setup_elfcorehdr(char *arg)
  546. {
  547. char *end;
  548. if (!arg)
  549. return -EINVAL;
  550. elfcorehdr_addr = memparse(arg, &end);
  551. return end > arg ? 0 : -EINVAL;
  552. }
  553. early_param("elfcorehdr", setup_elfcorehdr);
  554. #endif
  555. static __init void reserve_ibft_region(void)
  556. {
  557. unsigned long addr, size = 0;
  558. addr = find_ibft_region(&size);
  559. if (size)
  560. memblock_x86_reserve_range(addr, addr + size, "* ibft");
  561. }
  562. static unsigned reserve_low = CONFIG_X86_RESERVE_LOW << 10;
  563. static void __init trim_bios_range(void)
  564. {
  565. /*
  566. * A special case is the first 4Kb of memory;
  567. * This is a BIOS owned area, not kernel ram, but generally
  568. * not listed as such in the E820 table.
  569. *
  570. * This typically reserves additional memory (64KiB by default)
  571. * since some BIOSes are known to corrupt low memory. See the
  572. * Kconfig help text for X86_RESERVE_LOW.
  573. */
  574. e820_update_range(0, ALIGN(reserve_low, PAGE_SIZE),
  575. E820_RAM, E820_RESERVED);
  576. /*
  577. * special case: Some BIOSen report the PC BIOS
  578. * area (640->1Mb) as ram even though it is not.
  579. * take them out.
  580. */
  581. e820_remove_range(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_RAM, 1);
  582. sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
  583. }
  584. static int __init parse_reservelow(char *p)
  585. {
  586. unsigned long long size;
  587. if (!p)
  588. return -EINVAL;
  589. size = memparse(p, &p);
  590. if (size < 4096)
  591. size = 4096;
  592. if (size > 640*1024)
  593. size = 640*1024;
  594. reserve_low = size;
  595. return 0;
  596. }
  597. early_param("reservelow", parse_reservelow);
  598. /*
  599. * Determine if we were loaded by an EFI loader. If so, then we have also been
  600. * passed the efi memmap, systab, etc., so we should use these data structures
  601. * for initialization. Note, the efi init code path is determined by the
  602. * global efi_enabled. This allows the same kernel image to be used on existing
  603. * systems (with a traditional BIOS) as well as on EFI systems.
  604. */
  605. /*
  606. * setup_arch - architecture-specific boot-time initializations
  607. *
  608. * Note: On x86_64, fixmaps are ready for use even before this is called.
  609. */
  610. void __init setup_arch(char **cmdline_p)
  611. {
  612. int acpi = 0;
  613. int amd = 0;
  614. unsigned long flags;
  615. #ifdef CONFIG_X86_32
  616. memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
  617. visws_early_detect();
  618. /*
  619. * copy kernel address range established so far and switch
  620. * to the proper swapper page table
  621. */
  622. clone_pgd_range(swapper_pg_dir + KERNEL_PGD_BOUNDARY,
  623. initial_page_table + KERNEL_PGD_BOUNDARY,
  624. KERNEL_PGD_PTRS);
  625. load_cr3(swapper_pg_dir);
  626. __flush_tlb_all();
  627. #else
  628. printk(KERN_INFO "Command line: %s\n", boot_command_line);
  629. #endif
  630. /*
  631. * If we have OLPC OFW, we might end up relocating the fixmap due to
  632. * reserve_top(), so do this before touching the ioremap area.
  633. */
  634. olpc_ofw_detect();
  635. early_trap_init();
  636. early_cpu_init();
  637. early_ioremap_init();
  638. setup_olpc_ofw_pgd();
  639. ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
  640. screen_info = boot_params.screen_info;
  641. edid_info = boot_params.edid_info;
  642. #ifdef CONFIG_X86_32
  643. apm_info.bios = boot_params.apm_bios_info;
  644. ist_info = boot_params.ist_info;
  645. if (boot_params.sys_desc_table.length != 0) {
  646. set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2);
  647. machine_id = boot_params.sys_desc_table.table[0];
  648. machine_submodel_id = boot_params.sys_desc_table.table[1];
  649. BIOS_revision = boot_params.sys_desc_table.table[2];
  650. }
  651. #endif
  652. saved_video_mode = boot_params.hdr.vid_mode;
  653. bootloader_type = boot_params.hdr.type_of_loader;
  654. if ((bootloader_type >> 4) == 0xe) {
  655. bootloader_type &= 0xf;
  656. bootloader_type |= (boot_params.hdr.ext_loader_type+0x10) << 4;
  657. }
  658. bootloader_version = bootloader_type & 0xf;
  659. bootloader_version |= boot_params.hdr.ext_loader_ver << 4;
  660. #ifdef CONFIG_BLK_DEV_RAM
  661. rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
  662. rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
  663. rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
  664. #endif
  665. #ifdef CONFIG_EFI
  666. if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
  667. #ifdef CONFIG_X86_32
  668. "EL32",
  669. #else
  670. "EL64",
  671. #endif
  672. 4)) {
  673. efi_enabled = 1;
  674. efi_memblock_x86_reserve_range();
  675. }
  676. #endif
  677. x86_init.oem.arch_setup();
  678. iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
  679. setup_memory_map();
  680. parse_setup_data();
  681. /* update the e820_saved too */
  682. e820_reserve_setup_data();
  683. copy_edd();
  684. if (!boot_params.hdr.root_flags)
  685. root_mountflags &= ~MS_RDONLY;
  686. init_mm.start_code = (unsigned long) _text;
  687. init_mm.end_code = (unsigned long) _etext;
  688. init_mm.end_data = (unsigned long) _edata;
  689. init_mm.brk = _brk_end;
  690. code_resource.start = virt_to_phys(_text);
  691. code_resource.end = virt_to_phys(_etext)-1;
  692. data_resource.start = virt_to_phys(_etext);
  693. data_resource.end = virt_to_phys(_edata)-1;
  694. bss_resource.start = virt_to_phys(&__bss_start);
  695. bss_resource.end = virt_to_phys(&__bss_stop)-1;
  696. #ifdef CONFIG_CMDLINE_BOOL
  697. #ifdef CONFIG_CMDLINE_OVERRIDE
  698. strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
  699. #else
  700. if (builtin_cmdline[0]) {
  701. /* append boot loader cmdline to builtin */
  702. strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE);
  703. strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE);
  704. strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
  705. }
  706. #endif
  707. #endif
  708. strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
  709. *cmdline_p = command_line;
  710. /*
  711. * x86_configure_nx() is called before parse_early_param() to detect
  712. * whether hardware doesn't support NX (so that the early EHCI debug
  713. * console setup can safely call set_fixmap()). It may then be called
  714. * again from within noexec_setup() during parsing early parameters
  715. * to honor the respective command line option.
  716. */
  717. x86_configure_nx();
  718. parse_early_param();
  719. x86_report_nx();
  720. /* after early param, so could get panic from serial */
  721. memblock_x86_reserve_range_setup_data();
  722. if (acpi_mps_check()) {
  723. #ifdef CONFIG_X86_LOCAL_APIC
  724. disable_apic = 1;
  725. #endif
  726. setup_clear_cpu_cap(X86_FEATURE_APIC);
  727. }
  728. #ifdef CONFIG_PCI
  729. if (pci_early_dump_regs)
  730. early_dump_pci_devices();
  731. #endif
  732. finish_e820_parsing();
  733. if (efi_enabled)
  734. efi_init();
  735. dmi_scan_machine();
  736. /*
  737. * VMware detection requires dmi to be available, so this
  738. * needs to be done after dmi_scan_machine, for the BP.
  739. */
  740. init_hypervisor_platform();
  741. x86_init.resources.probe_roms();
  742. /* after parse_early_param, so could debug it */
  743. insert_resource(&iomem_resource, &code_resource);
  744. insert_resource(&iomem_resource, &data_resource);
  745. insert_resource(&iomem_resource, &bss_resource);
  746. trim_bios_range();
  747. #ifdef CONFIG_X86_32
  748. if (ppro_with_ram_bug()) {
  749. e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
  750. E820_RESERVED);
  751. sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
  752. printk(KERN_INFO "fixed physical RAM map:\n");
  753. e820_print_map("bad_ppro");
  754. }
  755. #else
  756. early_gart_iommu_check();
  757. #endif
  758. /*
  759. * partially used pages are not usable - thus
  760. * we are rounding upwards:
  761. */
  762. max_pfn = e820_end_of_ram_pfn();
  763. /* update e820 for memory not covered by WB MTRRs */
  764. mtrr_bp_init();
  765. if (mtrr_trim_uncached_memory(max_pfn))
  766. max_pfn = e820_end_of_ram_pfn();
  767. #ifdef CONFIG_X86_32
  768. /* max_low_pfn get updated here */
  769. find_low_pfn_range();
  770. #else
  771. num_physpages = max_pfn;
  772. check_x2apic();
  773. /* How many end-of-memory variables you have, grandma! */
  774. /* need this before calling reserve_initrd */
  775. if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
  776. max_low_pfn = e820_end_of_low_ram_pfn();
  777. else
  778. max_low_pfn = max_pfn;
  779. high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
  780. #endif
  781. /*
  782. * Find and reserve possible boot-time SMP configuration:
  783. */
  784. find_smp_config();
  785. reserve_ibft_region();
  786. /*
  787. * Need to conclude brk, before memblock_x86_fill()
  788. * it could use memblock_find_in_range, could overlap with
  789. * brk area.
  790. */
  791. reserve_brk();
  792. memblock.current_limit = get_max_mapped();
  793. memblock_x86_fill();
  794. /* preallocate 4k for mptable mpc */
  795. early_reserve_e820_mpc_new();
  796. #ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
  797. setup_bios_corruption_check();
  798. #endif
  799. printk(KERN_DEBUG "initial memory mapped : 0 - %08lx\n",
  800. max_pfn_mapped<<PAGE_SHIFT);
  801. reserve_trampoline_memory();
  802. #ifdef CONFIG_ACPI_SLEEP
  803. /*
  804. * Reserve low memory region for sleep support.
  805. * even before init_memory_mapping
  806. */
  807. acpi_reserve_wakeup_memory();
  808. #endif
  809. init_gbpages();
  810. /* max_pfn_mapped is updated here */
  811. max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
  812. max_pfn_mapped = max_low_pfn_mapped;
  813. memblock.current_limit = get_max_mapped();
  814. /*
  815. * NOTE: On x86-32, only from this point on, fixmaps are ready for use.
  816. */
  817. #ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
  818. if (init_ohci1394_dma_early)
  819. init_ohci1394_dma_on_all_controllers();
  820. #endif
  821. reserve_initrd();
  822. reserve_crashkernel();
  823. vsmp_init();
  824. io_delay_init();
  825. /*
  826. * Parse the ACPI tables for possible boot-time SMP configuration.
  827. */
  828. acpi_boot_table_init();
  829. early_acpi_boot_init();
  830. #ifdef CONFIG_ACPI_NUMA
  831. /*
  832. * Parse SRAT to discover nodes.
  833. */
  834. acpi = !acpi_numa_init();
  835. #endif
  836. #ifdef CONFIG_AMD_NUMA
  837. if (!acpi)
  838. amd = !amd_numa_init();
  839. #endif
  840. initmem_init(acpi, amd);
  841. memblock_find_dma_reserve();
  842. dma32_reserve_bootmem();
  843. #ifdef CONFIG_KVM_CLOCK
  844. kvmclock_init();
  845. #endif
  846. x86_init.paging.pagetable_setup_start(swapper_pg_dir);
  847. paging_init();
  848. x86_init.paging.pagetable_setup_done(swapper_pg_dir);
  849. #ifdef CONFIG_X86_32
  850. /* sync back kernel address range */
  851. clone_pgd_range(initial_page_table + KERNEL_PGD_BOUNDARY,
  852. swapper_pg_dir + KERNEL_PGD_BOUNDARY,
  853. KERNEL_PGD_PTRS);
  854. #endif
  855. tboot_probe();
  856. #ifdef CONFIG_X86_64
  857. map_vsyscall();
  858. #endif
  859. generic_apic_probe();
  860. early_quirks();
  861. /*
  862. * Read APIC and some other early information from ACPI tables.
  863. */
  864. acpi_boot_init();
  865. sfi_init();
  866. /*
  867. * get boot-time SMP configuration:
  868. */
  869. if (smp_found_config)
  870. get_smp_config();
  871. prefill_possible_map();
  872. init_cpu_to_node();
  873. init_apic_mappings();
  874. ioapic_and_gsi_init();
  875. kvm_guest_init();
  876. e820_reserve_resources();
  877. e820_mark_nosave_regions(max_low_pfn);
  878. x86_init.resources.reserve_resources();
  879. e820_setup_gap();
  880. #ifdef CONFIG_VT
  881. #if defined(CONFIG_VGA_CONSOLE)
  882. if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
  883. conswitchp = &vga_con;
  884. #elif defined(CONFIG_DUMMY_CONSOLE)
  885. conswitchp = &dummy_con;
  886. #endif
  887. #endif
  888. x86_init.oem.banner();
  889. mcheck_init();
  890. local_irq_save(flags);
  891. arch_init_ideal_nop5();
  892. local_irq_restore(flags);
  893. }
  894. #ifdef CONFIG_X86_32
  895. static struct resource video_ram_resource = {
  896. .name = "Video RAM area",
  897. .start = 0xa0000,
  898. .end = 0xbffff,
  899. .flags = IORESOURCE_BUSY | IORESOURCE_MEM
  900. };
  901. void __init i386_reserve_resources(void)
  902. {
  903. request_resource(&iomem_resource, &video_ram_resource);
  904. reserve_standard_io_resources();
  905. }
  906. #endif /* CONFIG_X86_32 */