]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - arch/i386/kernel/setup.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] fixup bogus e820 entry with mem=
[mirror_ubuntu-artful-kernel.git] / arch / i386 / kernel / setup.c
1 /*
2 * linux/arch/i386/kernel/setup.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 *
6 * Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
7 *
8 * Memory region support
9 * David Parsons <orc@pell.chi.il.us>, July-August 1999
10 *
11 * Added E820 sanitization routine (removes overlapping memory regions);
12 * Brian Moyle <bmoyle@mvista.com>, February 2001
13 *
14 * Moved CPU detection code to cpu/${cpu}.c
15 * Patrick Mochel <mochel@osdl.org>, March 2002
16 *
17 * Provisions for empty E820 memory regions (reported by certain BIOSes).
18 * Alex Achenbach <xela@slit.de>, December 2002.
19 *
20 */
21
22 /*
23 * This file handles the architecture-dependent parts of initialization
24 */
25
26 #include <linux/config.h>
27 #include <linux/sched.h>
28 #include <linux/mm.h>
29 #include <linux/mmzone.h>
30 #include <linux/tty.h>
31 #include <linux/ioport.h>
32 #include <linux/acpi.h>
33 #include <linux/apm_bios.h>
34 #include <linux/initrd.h>
35 #include <linux/bootmem.h>
36 #include <linux/seq_file.h>
37 #include <linux/console.h>
38 #include <linux/mca.h>
39 #include <linux/root_dev.h>
40 #include <linux/highmem.h>
41 #include <linux/module.h>
42 #include <linux/efi.h>
43 #include <linux/init.h>
44 #include <linux/edd.h>
45 #include <linux/nodemask.h>
46 #include <linux/kexec.h>
47 #include <linux/crash_dump.h>
48
49 #include <video/edid.h>
50
51 #include <asm/apic.h>
52 #include <asm/e820.h>
53 #include <asm/mpspec.h>
54 #include <asm/setup.h>
55 #include <asm/arch_hooks.h>
56 #include <asm/sections.h>
57 #include <asm/io_apic.h>
58 #include <asm/ist.h>
59 #include <asm/io.h>
60 #include "setup_arch_pre.h"
61 #include <bios_ebda.h>
62
63 /* Forward Declaration. */
64 void __init find_max_pfn(void);
65
66 /* This value is set up by the early boot code to point to the value
67 immediately after the boot time page tables. It contains a *physical*
68 address, and must not be in the .bss segment! */
69 unsigned long init_pg_tables_end __initdata = ~0UL;
70
71 int disable_pse __devinitdata = 0;
72
73 /*
74 * Machine setup..
75 */
76
77 #ifdef CONFIG_EFI
78 int efi_enabled = 0;
79 EXPORT_SYMBOL(efi_enabled);
80 #endif
81
82 /* cpu data as detected by the assembly code in head.S */
83 struct cpuinfo_x86 new_cpu_data __initdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
84 /* common cpu data for all cpus */
85 struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
86 EXPORT_SYMBOL(boot_cpu_data);
87
88 unsigned long mmu_cr4_features;
89
90 #ifdef CONFIG_ACPI
91 int acpi_disabled = 0;
92 #else
93 int acpi_disabled = 1;
94 #endif
95 EXPORT_SYMBOL(acpi_disabled);
96
97 #ifdef CONFIG_ACPI
98 int __initdata acpi_force = 0;
99 extern acpi_interrupt_flags acpi_sci_flags;
100 #endif
101
102 /* for MCA, but anyone else can use it if they want */
103 unsigned int machine_id;
104 #ifdef CONFIG_MCA
105 EXPORT_SYMBOL(machine_id);
106 #endif
107 unsigned int machine_submodel_id;
108 unsigned int BIOS_revision;
109 unsigned int mca_pentium_flag;
110
111 /* For PCI or other memory-mapped resources */
112 unsigned long pci_mem_start = 0x10000000;
113 #ifdef CONFIG_PCI
114 EXPORT_SYMBOL(pci_mem_start);
115 #endif
116
117 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
118 int bootloader_type;
119
120 /* user-defined highmem size */
121 static unsigned int highmem_pages = -1;
122
123 /*
124 * Setup options
125 */
126 struct drive_info_struct { char dummy[32]; } drive_info;
127 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || \
128 defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
129 EXPORT_SYMBOL(drive_info);
130 #endif
131 struct screen_info screen_info;
132 #ifdef CONFIG_VT
133 EXPORT_SYMBOL(screen_info);
134 #endif
135 struct apm_info apm_info;
136 EXPORT_SYMBOL(apm_info);
137 struct sys_desc_table_struct {
138 unsigned short length;
139 unsigned char table[0];
140 };
141 struct edid_info edid_info;
142 EXPORT_SYMBOL_GPL(edid_info);
143 struct ist_info ist_info;
144 #if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
145 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
146 EXPORT_SYMBOL(ist_info);
147 #endif
148 struct e820map e820;
149
150 extern void early_cpu_init(void);
151 extern void dmi_scan_machine(void);
152 extern void generic_apic_probe(char *);
153 extern int root_mountflags;
154
155 unsigned long saved_videomode;
156
157 #define RAMDISK_IMAGE_START_MASK 0x07FF
158 #define RAMDISK_PROMPT_FLAG 0x8000
159 #define RAMDISK_LOAD_FLAG 0x4000
160
161 static char command_line[COMMAND_LINE_SIZE];
162
163 unsigned char __initdata boot_params[PARAM_SIZE];
164
165 static struct resource data_resource = {
166 .name = "Kernel data",
167 .start = 0,
168 .end = 0,
169 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
170 };
171
172 static struct resource code_resource = {
173 .name = "Kernel code",
174 .start = 0,
175 .end = 0,
176 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
177 };
178
179 static struct resource system_rom_resource = {
180 .name = "System ROM",
181 .start = 0xf0000,
182 .end = 0xfffff,
183 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
184 };
185
186 static struct resource extension_rom_resource = {
187 .name = "Extension ROM",
188 .start = 0xe0000,
189 .end = 0xeffff,
190 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
191 };
192
193 static struct resource adapter_rom_resources[] = { {
194 .name = "Adapter ROM",
195 .start = 0xc8000,
196 .end = 0,
197 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
198 }, {
199 .name = "Adapter ROM",
200 .start = 0,
201 .end = 0,
202 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
203 }, {
204 .name = "Adapter ROM",
205 .start = 0,
206 .end = 0,
207 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
208 }, {
209 .name = "Adapter ROM",
210 .start = 0,
211 .end = 0,
212 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
213 }, {
214 .name = "Adapter ROM",
215 .start = 0,
216 .end = 0,
217 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
218 }, {
219 .name = "Adapter ROM",
220 .start = 0,
221 .end = 0,
222 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
223 } };
224
225 #define ADAPTER_ROM_RESOURCES \
226 (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
227
228 static struct resource video_rom_resource = {
229 .name = "Video ROM",
230 .start = 0xc0000,
231 .end = 0xc7fff,
232 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
233 };
234
235 static struct resource video_ram_resource = {
236 .name = "Video RAM area",
237 .start = 0xa0000,
238 .end = 0xbffff,
239 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
240 };
241
242 static struct resource standard_io_resources[] = { {
243 .name = "dma1",
244 .start = 0x0000,
245 .end = 0x001f,
246 .flags = IORESOURCE_BUSY | IORESOURCE_IO
247 }, {
248 .name = "pic1",
249 .start = 0x0020,
250 .end = 0x0021,
251 .flags = IORESOURCE_BUSY | IORESOURCE_IO
252 }, {
253 .name = "timer0",
254 .start = 0x0040,
255 .end = 0x0043,
256 .flags = IORESOURCE_BUSY | IORESOURCE_IO
257 }, {
258 .name = "timer1",
259 .start = 0x0050,
260 .end = 0x0053,
261 .flags = IORESOURCE_BUSY | IORESOURCE_IO
262 }, {
263 .name = "keyboard",
264 .start = 0x0060,
265 .end = 0x006f,
266 .flags = IORESOURCE_BUSY | IORESOURCE_IO
267 }, {
268 .name = "dma page reg",
269 .start = 0x0080,
270 .end = 0x008f,
271 .flags = IORESOURCE_BUSY | IORESOURCE_IO
272 }, {
273 .name = "pic2",
274 .start = 0x00a0,
275 .end = 0x00a1,
276 .flags = IORESOURCE_BUSY | IORESOURCE_IO
277 }, {
278 .name = "dma2",
279 .start = 0x00c0,
280 .end = 0x00df,
281 .flags = IORESOURCE_BUSY | IORESOURCE_IO
282 }, {
283 .name = "fpu",
284 .start = 0x00f0,
285 .end = 0x00ff,
286 .flags = IORESOURCE_BUSY | IORESOURCE_IO
287 } };
288
289 #define STANDARD_IO_RESOURCES \
290 (sizeof standard_io_resources / sizeof standard_io_resources[0])
291
292 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
293
294 static int __init romchecksum(unsigned char *rom, unsigned long length)
295 {
296 unsigned char *p, sum = 0;
297
298 for (p = rom; p < rom + length; p++)
299 sum += *p;
300 return sum == 0;
301 }
302
303 static void __init probe_roms(void)
304 {
305 unsigned long start, length, upper;
306 unsigned char *rom;
307 int i;
308
309 /* video rom */
310 upper = adapter_rom_resources[0].start;
311 for (start = video_rom_resource.start; start < upper; start += 2048) {
312 rom = isa_bus_to_virt(start);
313 if (!romsignature(rom))
314 continue;
315
316 video_rom_resource.start = start;
317
318 /* 0 < length <= 0x7f * 512, historically */
319 length = rom[2] * 512;
320
321 /* if checksum okay, trust length byte */
322 if (length && romchecksum(rom, length))
323 video_rom_resource.end = start + length - 1;
324
325 request_resource(&iomem_resource, &video_rom_resource);
326 break;
327 }
328
329 start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
330 if (start < upper)
331 start = upper;
332
333 /* system rom */
334 request_resource(&iomem_resource, &system_rom_resource);
335 upper = system_rom_resource.start;
336
337 /* check for extension rom (ignore length byte!) */
338 rom = isa_bus_to_virt(extension_rom_resource.start);
339 if (romsignature(rom)) {
340 length = extension_rom_resource.end - extension_rom_resource.start + 1;
341 if (romchecksum(rom, length)) {
342 request_resource(&iomem_resource, &extension_rom_resource);
343 upper = extension_rom_resource.start;
344 }
345 }
346
347 /* check for adapter roms on 2k boundaries */
348 for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
349 rom = isa_bus_to_virt(start);
350 if (!romsignature(rom))
351 continue;
352
353 /* 0 < length <= 0x7f * 512, historically */
354 length = rom[2] * 512;
355
356 /* but accept any length that fits if checksum okay */
357 if (!length || start + length > upper || !romchecksum(rom, length))
358 continue;
359
360 adapter_rom_resources[i].start = start;
361 adapter_rom_resources[i].end = start + length - 1;
362 request_resource(&iomem_resource, &adapter_rom_resources[i]);
363
364 start = adapter_rom_resources[i++].end & ~2047UL;
365 }
366 }
367
368 static void __init limit_regions(unsigned long long size)
369 {
370 unsigned long long current_addr = 0;
371 int i;
372
373 if (efi_enabled) {
374 efi_memory_desc_t *md;
375 void *p;
376
377 for (p = memmap.map, i = 0; p < memmap.map_end;
378 p += memmap.desc_size, i++) {
379 md = p;
380 current_addr = md->phys_addr + (md->num_pages << 12);
381 if (md->type == EFI_CONVENTIONAL_MEMORY) {
382 if (current_addr >= size) {
383 md->num_pages -=
384 (((current_addr-size) + PAGE_SIZE-1) >> PAGE_SHIFT);
385 memmap.nr_map = i + 1;
386 return;
387 }
388 }
389 }
390 }
391 for (i = 0; i < e820.nr_map; i++) {
392 current_addr = e820.map[i].addr + e820.map[i].size;
393 if (current_addr < size)
394 continue;
395
396 if (e820.map[i].type != E820_RAM)
397 continue;
398
399 if (e820.map[i].addr >= size) {
400 /*
401 * This region starts past the end of the
402 * requested size, skip it completely.
403 */
404 e820.nr_map = i;
405 } else {
406 e820.nr_map = i + 1;
407 e820.map[i].size -= current_addr - size;
408 }
409 return;
410 }
411 }
412
413 static void __init add_memory_region(unsigned long long start,
414 unsigned long long size, int type)
415 {
416 int x;
417
418 if (!efi_enabled) {
419 x = e820.nr_map;
420
421 if (x == E820MAX) {
422 printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
423 return;
424 }
425
426 e820.map[x].addr = start;
427 e820.map[x].size = size;
428 e820.map[x].type = type;
429 e820.nr_map++;
430 }
431 } /* add_memory_region */
432
433 #define E820_DEBUG 1
434
435 static void __init print_memory_map(char *who)
436 {
437 int i;
438
439 for (i = 0; i < e820.nr_map; i++) {
440 printk(" %s: %016Lx - %016Lx ", who,
441 e820.map[i].addr,
442 e820.map[i].addr + e820.map[i].size);
443 switch (e820.map[i].type) {
444 case E820_RAM: printk("(usable)\n");
445 break;
446 case E820_RESERVED:
447 printk("(reserved)\n");
448 break;
449 case E820_ACPI:
450 printk("(ACPI data)\n");
451 break;
452 case E820_NVS:
453 printk("(ACPI NVS)\n");
454 break;
455 default: printk("type %lu\n", e820.map[i].type);
456 break;
457 }
458 }
459 }
460
461 /*
462 * Sanitize the BIOS e820 map.
463 *
464 * Some e820 responses include overlapping entries. The following
465 * replaces the original e820 map with a new one, removing overlaps.
466 *
467 */
468 struct change_member {
469 struct e820entry *pbios; /* pointer to original bios entry */
470 unsigned long long addr; /* address for this change point */
471 };
472 static struct change_member change_point_list[2*E820MAX] __initdata;
473 static struct change_member *change_point[2*E820MAX] __initdata;
474 static struct e820entry *overlap_list[E820MAX] __initdata;
475 static struct e820entry new_bios[E820MAX] __initdata;
476
477 static int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
478 {
479 struct change_member *change_tmp;
480 unsigned long current_type, last_type;
481 unsigned long long last_addr;
482 int chgidx, still_changing;
483 int overlap_entries;
484 int new_bios_entry;
485 int old_nr, new_nr, chg_nr;
486 int i;
487
488 /*
489 Visually we're performing the following (1,2,3,4 = memory types)...
490
491 Sample memory map (w/overlaps):
492 ____22__________________
493 ______________________4_
494 ____1111________________
495 _44_____________________
496 11111111________________
497 ____________________33__
498 ___________44___________
499 __________33333_________
500 ______________22________
501 ___________________2222_
502 _________111111111______
503 _____________________11_
504 _________________4______
505
506 Sanitized equivalent (no overlap):
507 1_______________________
508 _44_____________________
509 ___1____________________
510 ____22__________________
511 ______11________________
512 _________1______________
513 __________3_____________
514 ___________44___________
515 _____________33_________
516 _______________2________
517 ________________1_______
518 _________________4______
519 ___________________2____
520 ____________________33__
521 ______________________4_
522 */
523
524 /* if there's only one memory region, don't bother */
525 if (*pnr_map < 2)
526 return -1;
527
528 old_nr = *pnr_map;
529
530 /* bail out if we find any unreasonable addresses in bios map */
531 for (i=0; i<old_nr; i++)
532 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
533 return -1;
534
535 /* create pointers for initial change-point information (for sorting) */
536 for (i=0; i < 2*old_nr; i++)
537 change_point[i] = &change_point_list[i];
538
539 /* record all known change-points (starting and ending addresses),
540 omitting those that are for empty memory regions */
541 chgidx = 0;
542 for (i=0; i < old_nr; i++) {
543 if (biosmap[i].size != 0) {
544 change_point[chgidx]->addr = biosmap[i].addr;
545 change_point[chgidx++]->pbios = &biosmap[i];
546 change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
547 change_point[chgidx++]->pbios = &biosmap[i];
548 }
549 }
550 chg_nr = chgidx; /* true number of change-points */
551
552 /* sort change-point list by memory addresses (low -> high) */
553 still_changing = 1;
554 while (still_changing) {
555 still_changing = 0;
556 for (i=1; i < chg_nr; i++) {
557 /* if <current_addr> > <last_addr>, swap */
558 /* or, if current=<start_addr> & last=<end_addr>, swap */
559 if ((change_point[i]->addr < change_point[i-1]->addr) ||
560 ((change_point[i]->addr == change_point[i-1]->addr) &&
561 (change_point[i]->addr == change_point[i]->pbios->addr) &&
562 (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
563 )
564 {
565 change_tmp = change_point[i];
566 change_point[i] = change_point[i-1];
567 change_point[i-1] = change_tmp;
568 still_changing=1;
569 }
570 }
571 }
572
573 /* create a new bios memory map, removing overlaps */
574 overlap_entries=0; /* number of entries in the overlap table */
575 new_bios_entry=0; /* index for creating new bios map entries */
576 last_type = 0; /* start with undefined memory type */
577 last_addr = 0; /* start with 0 as last starting address */
578 /* loop through change-points, determining affect on the new bios map */
579 for (chgidx=0; chgidx < chg_nr; chgidx++)
580 {
581 /* keep track of all overlapping bios entries */
582 if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
583 {
584 /* add map entry to overlap list (> 1 entry implies an overlap) */
585 overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
586 }
587 else
588 {
589 /* remove entry from list (order independent, so swap with last) */
590 for (i=0; i<overlap_entries; i++)
591 {
592 if (overlap_list[i] == change_point[chgidx]->pbios)
593 overlap_list[i] = overlap_list[overlap_entries-1];
594 }
595 overlap_entries--;
596 }
597 /* if there are overlapping entries, decide which "type" to use */
598 /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
599 current_type = 0;
600 for (i=0; i<overlap_entries; i++)
601 if (overlap_list[i]->type > current_type)
602 current_type = overlap_list[i]->type;
603 /* continue building up new bios map based on this information */
604 if (current_type != last_type) {
605 if (last_type != 0) {
606 new_bios[new_bios_entry].size =
607 change_point[chgidx]->addr - last_addr;
608 /* move forward only if the new size was non-zero */
609 if (new_bios[new_bios_entry].size != 0)
610 if (++new_bios_entry >= E820MAX)
611 break; /* no more space left for new bios entries */
612 }
613 if (current_type != 0) {
614 new_bios[new_bios_entry].addr = change_point[chgidx]->addr;
615 new_bios[new_bios_entry].type = current_type;
616 last_addr=change_point[chgidx]->addr;
617 }
618 last_type = current_type;
619 }
620 }
621 new_nr = new_bios_entry; /* retain count for new bios entries */
622
623 /* copy new bios mapping into original location */
624 memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
625 *pnr_map = new_nr;
626
627 return 0;
628 }
629
630 /*
631 * Copy the BIOS e820 map into a safe place.
632 *
633 * Sanity-check it while we're at it..
634 *
635 * If we're lucky and live on a modern system, the setup code
636 * will have given us a memory map that we can use to properly
637 * set up memory. If we aren't, we'll fake a memory map.
638 *
639 * We check to see that the memory map contains at least 2 elements
640 * before we'll use it, because the detection code in setup.S may
641 * not be perfect and most every PC known to man has two memory
642 * regions: one from 0 to 640k, and one from 1mb up. (The IBM
643 * thinkpad 560x, for example, does not cooperate with the memory
644 * detection code.)
645 */
646 static int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
647 {
648 /* Only one memory region (or negative)? Ignore it */
649 if (nr_map < 2)
650 return -1;
651
652 do {
653 unsigned long long start = biosmap->addr;
654 unsigned long long size = biosmap->size;
655 unsigned long long end = start + size;
656 unsigned long type = biosmap->type;
657
658 /* Overflow in 64 bits? Ignore the memory map. */
659 if (start > end)
660 return -1;
661
662 /*
663 * Some BIOSes claim RAM in the 640k - 1M region.
664 * Not right. Fix it up.
665 */
666 if (type == E820_RAM) {
667 if (start < 0x100000ULL && end > 0xA0000ULL) {
668 if (start < 0xA0000ULL)
669 add_memory_region(start, 0xA0000ULL-start, type);
670 if (end <= 0x100000ULL)
671 continue;
672 start = 0x100000ULL;
673 size = end - start;
674 }
675 }
676 add_memory_region(start, size, type);
677 } while (biosmap++,--nr_map);
678 return 0;
679 }
680
681 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
682 struct edd edd;
683 #ifdef CONFIG_EDD_MODULE
684 EXPORT_SYMBOL(edd);
685 #endif
686 /**
687 * copy_edd() - Copy the BIOS EDD information
688 * from boot_params into a safe place.
689 *
690 */
691 static inline void copy_edd(void)
692 {
693 memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
694 memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
695 edd.mbr_signature_nr = EDD_MBR_SIG_NR;
696 edd.edd_info_nr = EDD_NR;
697 }
698 #else
699 static inline void copy_edd(void)
700 {
701 }
702 #endif
703
704 /*
705 * Do NOT EVER look at the BIOS memory size location.
706 * It does not work on many machines.
707 */
708 #define LOWMEMSIZE() (0x9f000)
709
710 static void __init parse_cmdline_early (char ** cmdline_p)
711 {
712 char c = ' ', *to = command_line, *from = saved_command_line;
713 int len = 0;
714 int userdef = 0;
715
716 /* Save unparsed command line copy for /proc/cmdline */
717 saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
718
719 for (;;) {
720 if (c != ' ')
721 goto next_char;
722 /*
723 * "mem=nopentium" disables the 4MB page tables.
724 * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
725 * to <mem>, overriding the bios size.
726 * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
727 * <start> to <start>+<mem>, overriding the bios size.
728 *
729 * HPA tells me bootloaders need to parse mem=, so no new
730 * option should be mem= [also see Documentation/i386/boot.txt]
731 */
732 if (!memcmp(from, "mem=", 4)) {
733 if (to != command_line)
734 to--;
735 if (!memcmp(from+4, "nopentium", 9)) {
736 from += 9+4;
737 clear_bit(X86_FEATURE_PSE, boot_cpu_data.x86_capability);
738 disable_pse = 1;
739 } else {
740 /* If the user specifies memory size, we
741 * limit the BIOS-provided memory map to
742 * that size. exactmap can be used to specify
743 * the exact map. mem=number can be used to
744 * trim the existing memory map.
745 */
746 unsigned long long mem_size;
747
748 mem_size = memparse(from+4, &from);
749 limit_regions(mem_size);
750 userdef=1;
751 }
752 }
753
754 else if (!memcmp(from, "memmap=", 7)) {
755 if (to != command_line)
756 to--;
757 if (!memcmp(from+7, "exactmap", 8)) {
758 #ifdef CONFIG_CRASH_DUMP
759 /* If we are doing a crash dump, we
760 * still need to know the real mem
761 * size before original memory map is
762 * reset.
763 */
764 find_max_pfn();
765 saved_max_pfn = max_pfn;
766 #endif
767 from += 8+7;
768 e820.nr_map = 0;
769 userdef = 1;
770 } else {
771 /* If the user specifies memory size, we
772 * limit the BIOS-provided memory map to
773 * that size. exactmap can be used to specify
774 * the exact map. mem=number can be used to
775 * trim the existing memory map.
776 */
777 unsigned long long start_at, mem_size;
778
779 mem_size = memparse(from+7, &from);
780 if (*from == '@') {
781 start_at = memparse(from+1, &from);
782 add_memory_region(start_at, mem_size, E820_RAM);
783 } else if (*from == '#') {
784 start_at = memparse(from+1, &from);
785 add_memory_region(start_at, mem_size, E820_ACPI);
786 } else if (*from == '$') {
787 start_at = memparse(from+1, &from);
788 add_memory_region(start_at, mem_size, E820_RESERVED);
789 } else {
790 limit_regions(mem_size);
791 userdef=1;
792 }
793 }
794 }
795
796 else if (!memcmp(from, "noexec=", 7))
797 noexec_setup(from + 7);
798
799
800 #ifdef CONFIG_X86_SMP
801 /*
802 * If the BIOS enumerates physical processors before logical,
803 * maxcpus=N at enumeration-time can be used to disable HT.
804 */
805 else if (!memcmp(from, "maxcpus=", 8)) {
806 extern unsigned int maxcpus;
807
808 maxcpus = simple_strtoul(from + 8, NULL, 0);
809 }
810 #endif
811
812 #ifdef CONFIG_ACPI
813 /* "acpi=off" disables both ACPI table parsing and interpreter */
814 else if (!memcmp(from, "acpi=off", 8)) {
815 disable_acpi();
816 }
817
818 /* acpi=force to over-ride black-list */
819 else if (!memcmp(from, "acpi=force", 10)) {
820 acpi_force = 1;
821 acpi_ht = 1;
822 acpi_disabled = 0;
823 }
824
825 /* acpi=strict disables out-of-spec workarounds */
826 else if (!memcmp(from, "acpi=strict", 11)) {
827 acpi_strict = 1;
828 }
829
830 /* Limit ACPI just to boot-time to enable HT */
831 else if (!memcmp(from, "acpi=ht", 7)) {
832 if (!acpi_force)
833 disable_acpi();
834 acpi_ht = 1;
835 }
836
837 /* "pci=noacpi" disable ACPI IRQ routing and PCI scan */
838 else if (!memcmp(from, "pci=noacpi", 10)) {
839 acpi_disable_pci();
840 }
841 /* "acpi=noirq" disables ACPI interrupt routing */
842 else if (!memcmp(from, "acpi=noirq", 10)) {
843 acpi_noirq_set();
844 }
845
846 else if (!memcmp(from, "acpi_sci=edge", 13))
847 acpi_sci_flags.trigger = 1;
848
849 else if (!memcmp(from, "acpi_sci=level", 14))
850 acpi_sci_flags.trigger = 3;
851
852 else if (!memcmp(from, "acpi_sci=high", 13))
853 acpi_sci_flags.polarity = 1;
854
855 else if (!memcmp(from, "acpi_sci=low", 12))
856 acpi_sci_flags.polarity = 3;
857
858 #ifdef CONFIG_X86_IO_APIC
859 else if (!memcmp(from, "acpi_skip_timer_override", 24))
860 acpi_skip_timer_override = 1;
861
862 if (!memcmp(from, "disable_timer_pin_1", 19))
863 disable_timer_pin_1 = 1;
864 if (!memcmp(from, "enable_timer_pin_1", 18))
865 disable_timer_pin_1 = -1;
866
867 /* disable IO-APIC */
868 else if (!memcmp(from, "noapic", 6))
869 disable_ioapic_setup();
870 #endif /* CONFIG_X86_IO_APIC */
871 #endif /* CONFIG_ACPI */
872
873 #ifdef CONFIG_X86_LOCAL_APIC
874 /* enable local APIC */
875 else if (!memcmp(from, "lapic", 5))
876 lapic_enable();
877
878 /* disable local APIC */
879 else if (!memcmp(from, "nolapic", 6))
880 lapic_disable();
881 #endif /* CONFIG_X86_LOCAL_APIC */
882
883 #ifdef CONFIG_KEXEC
884 /* crashkernel=size@addr specifies the location to reserve for
885 * a crash kernel. By reserving this memory we guarantee
886 * that linux never set's it up as a DMA target.
887 * Useful for holding code to do something appropriate
888 * after a kernel panic.
889 */
890 else if (!memcmp(from, "crashkernel=", 12)) {
891 unsigned long size, base;
892 size = memparse(from+12, &from);
893 if (*from == '@') {
894 base = memparse(from+1, &from);
895 /* FIXME: Do I want a sanity check
896 * to validate the memory range?
897 */
898 crashk_res.start = base;
899 crashk_res.end = base + size - 1;
900 }
901 }
902 #endif
903 #ifdef CONFIG_CRASH_DUMP
904 /* elfcorehdr= specifies the location of elf core header
905 * stored by the crashed kernel.
906 */
907 else if (!memcmp(from, "elfcorehdr=", 11))
908 elfcorehdr_addr = memparse(from+11, &from);
909 #endif
910
911 /*
912 * highmem=size forces highmem to be exactly 'size' bytes.
913 * This works even on boxes that have no highmem otherwise.
914 * This also works to reduce highmem size on bigger boxes.
915 */
916 else if (!memcmp(from, "highmem=", 8))
917 highmem_pages = memparse(from+8, &from) >> PAGE_SHIFT;
918
919 /*
920 * vmalloc=size forces the vmalloc area to be exactly 'size'
921 * bytes. This can be used to increase (or decrease) the
922 * vmalloc area - the default is 128m.
923 */
924 else if (!memcmp(from, "vmalloc=", 8))
925 __VMALLOC_RESERVE = memparse(from+8, &from);
926
927 next_char:
928 c = *(from++);
929 if (!c)
930 break;
931 if (COMMAND_LINE_SIZE <= ++len)
932 break;
933 *(to++) = c;
934 }
935 *to = '\0';
936 *cmdline_p = command_line;
937 if (userdef) {
938 printk(KERN_INFO "user-defined physical RAM map:\n");
939 print_memory_map("user");
940 }
941 }
942
943 /*
944 * Callback for efi_memory_walk.
945 */
946 static int __init
947 efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
948 {
949 unsigned long *max_pfn = arg, pfn;
950
951 if (start < end) {
952 pfn = PFN_UP(end -1);
953 if (pfn > *max_pfn)
954 *max_pfn = pfn;
955 }
956 return 0;
957 }
958
959
960 /*
961 * Find the highest page frame number we have available
962 */
963 void __init find_max_pfn(void)
964 {
965 int i;
966
967 max_pfn = 0;
968 if (efi_enabled) {
969 efi_memmap_walk(efi_find_max_pfn, &max_pfn);
970 return;
971 }
972
973 for (i = 0; i < e820.nr_map; i++) {
974 unsigned long start, end;
975 /* RAM? */
976 if (e820.map[i].type != E820_RAM)
977 continue;
978 start = PFN_UP(e820.map[i].addr);
979 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
980 if (start >= end)
981 continue;
982 if (end > max_pfn)
983 max_pfn = end;
984 }
985 }
986
987 /*
988 * Determine low and high memory ranges:
989 */
990 unsigned long __init find_max_low_pfn(void)
991 {
992 unsigned long max_low_pfn;
993
994 max_low_pfn = max_pfn;
995 if (max_low_pfn > MAXMEM_PFN) {
996 if (highmem_pages == -1)
997 highmem_pages = max_pfn - MAXMEM_PFN;
998 if (highmem_pages + MAXMEM_PFN < max_pfn)
999 max_pfn = MAXMEM_PFN + highmem_pages;
1000 if (highmem_pages + MAXMEM_PFN > max_pfn) {
1001 printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
1002 highmem_pages = 0;
1003 }
1004 max_low_pfn = MAXMEM_PFN;
1005 #ifndef CONFIG_HIGHMEM
1006 /* Maximum memory usable is what is directly addressable */
1007 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
1008 MAXMEM>>20);
1009 if (max_pfn > MAX_NONPAE_PFN)
1010 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
1011 else
1012 printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
1013 max_pfn = MAXMEM_PFN;
1014 #else /* !CONFIG_HIGHMEM */
1015 #ifndef CONFIG_X86_PAE
1016 if (max_pfn > MAX_NONPAE_PFN) {
1017 max_pfn = MAX_NONPAE_PFN;
1018 printk(KERN_WARNING "Warning only 4GB will be used.\n");
1019 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
1020 }
1021 #endif /* !CONFIG_X86_PAE */
1022 #endif /* !CONFIG_HIGHMEM */
1023 } else {
1024 if (highmem_pages == -1)
1025 highmem_pages = 0;
1026 #ifdef CONFIG_HIGHMEM
1027 if (highmem_pages >= max_pfn) {
1028 printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
1029 highmem_pages = 0;
1030 }
1031 if (highmem_pages) {
1032 if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
1033 printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
1034 highmem_pages = 0;
1035 }
1036 max_low_pfn -= highmem_pages;
1037 }
1038 #else
1039 if (highmem_pages)
1040 printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
1041 #endif
1042 }
1043 return max_low_pfn;
1044 }
1045
1046 /*
1047 * Free all available memory for boot time allocation. Used
1048 * as a callback function by efi_memory_walk()
1049 */
1050
1051 static int __init
1052 free_available_memory(unsigned long start, unsigned long end, void *arg)
1053 {
1054 /* check max_low_pfn */
1055 if (start >= ((max_low_pfn + 1) << PAGE_SHIFT))
1056 return 0;
1057 if (end >= ((max_low_pfn + 1) << PAGE_SHIFT))
1058 end = (max_low_pfn + 1) << PAGE_SHIFT;
1059 if (start < end)
1060 free_bootmem(start, end - start);
1061
1062 return 0;
1063 }
1064 /*
1065 * Register fully available low RAM pages with the bootmem allocator.
1066 */
1067 static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
1068 {
1069 int i;
1070
1071 if (efi_enabled) {
1072 efi_memmap_walk(free_available_memory, NULL);
1073 return;
1074 }
1075 for (i = 0; i < e820.nr_map; i++) {
1076 unsigned long curr_pfn, last_pfn, size;
1077 /*
1078 * Reserve usable low memory
1079 */
1080 if (e820.map[i].type != E820_RAM)
1081 continue;
1082 /*
1083 * We are rounding up the start address of usable memory:
1084 */
1085 curr_pfn = PFN_UP(e820.map[i].addr);
1086 if (curr_pfn >= max_low_pfn)
1087 continue;
1088 /*
1089 * ... and at the end of the usable range downwards:
1090 */
1091 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1092
1093 if (last_pfn > max_low_pfn)
1094 last_pfn = max_low_pfn;
1095
1096 /*
1097 * .. finally, did all the rounding and playing
1098 * around just make the area go away?
1099 */
1100 if (last_pfn <= curr_pfn)
1101 continue;
1102
1103 size = last_pfn - curr_pfn;
1104 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1105 }
1106 }
1107
1108 /*
1109 * workaround for Dell systems that neglect to reserve EBDA
1110 */
1111 static void __init reserve_ebda_region(void)
1112 {
1113 unsigned int addr;
1114 addr = get_bios_ebda();
1115 if (addr)
1116 reserve_bootmem(addr, PAGE_SIZE);
1117 }
1118
1119 #ifndef CONFIG_NEED_MULTIPLE_NODES
1120 void __init setup_bootmem_allocator(void);
1121 static unsigned long __init setup_memory(void)
1122 {
1123 /*
1124 * partially used pages are not usable - thus
1125 * we are rounding upwards:
1126 */
1127 min_low_pfn = PFN_UP(init_pg_tables_end);
1128
1129 find_max_pfn();
1130
1131 max_low_pfn = find_max_low_pfn();
1132
1133 #ifdef CONFIG_HIGHMEM
1134 highstart_pfn = highend_pfn = max_pfn;
1135 if (max_pfn > max_low_pfn) {
1136 highstart_pfn = max_low_pfn;
1137 }
1138 printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1139 pages_to_mb(highend_pfn - highstart_pfn));
1140 #endif
1141 printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
1142 pages_to_mb(max_low_pfn));
1143
1144 setup_bootmem_allocator();
1145
1146 return max_low_pfn;
1147 }
1148
1149 void __init zone_sizes_init(void)
1150 {
1151 unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
1152 unsigned int max_dma, low;
1153
1154 max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
1155 low = max_low_pfn;
1156
1157 if (low < max_dma)
1158 zones_size[ZONE_DMA] = low;
1159 else {
1160 zones_size[ZONE_DMA] = max_dma;
1161 zones_size[ZONE_NORMAL] = low - max_dma;
1162 #ifdef CONFIG_HIGHMEM
1163 zones_size[ZONE_HIGHMEM] = highend_pfn - low;
1164 #endif
1165 }
1166 free_area_init(zones_size);
1167 }
1168 #else
1169 extern unsigned long __init setup_memory(void);
1170 extern void zone_sizes_init(void);
1171 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
1172
1173 void __init setup_bootmem_allocator(void)
1174 {
1175 unsigned long bootmap_size;
1176 /*
1177 * Initialize the boot-time allocator (with low memory only):
1178 */
1179 bootmap_size = init_bootmem(min_low_pfn, max_low_pfn);
1180
1181 register_bootmem_low_pages(max_low_pfn);
1182
1183 /*
1184 * Reserve the bootmem bitmap itself as well. We do this in two
1185 * steps (first step was init_bootmem()) because this catches
1186 * the (very unlikely) case of us accidentally initializing the
1187 * bootmem allocator with an invalid RAM area.
1188 */
1189 reserve_bootmem(__PHYSICAL_START, (PFN_PHYS(min_low_pfn) +
1190 bootmap_size + PAGE_SIZE-1) - (__PHYSICAL_START));
1191
1192 /*
1193 * reserve physical page 0 - it's a special BIOS page on many boxes,
1194 * enabling clean reboots, SMP operation, laptop functions.
1195 */
1196 reserve_bootmem(0, PAGE_SIZE);
1197
1198 /* reserve EBDA region, it's a 4K region */
1199 reserve_ebda_region();
1200
1201 /* could be an AMD 768MPX chipset. Reserve a page before VGA to prevent
1202 PCI prefetch into it (errata #56). Usually the page is reserved anyways,
1203 unless you have no PS/2 mouse plugged in. */
1204 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
1205 boot_cpu_data.x86 == 6)
1206 reserve_bootmem(0xa0000 - 4096, 4096);
1207
1208 #ifdef CONFIG_SMP
1209 /*
1210 * But first pinch a few for the stack/trampoline stuff
1211 * FIXME: Don't need the extra page at 4K, but need to fix
1212 * trampoline before removing it. (see the GDT stuff)
1213 */
1214 reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
1215 #endif
1216 #ifdef CONFIG_ACPI_SLEEP
1217 /*
1218 * Reserve low memory region for sleep support.
1219 */
1220 acpi_reserve_bootmem();
1221 #endif
1222 #ifdef CONFIG_X86_FIND_SMP_CONFIG
1223 /*
1224 * Find and reserve possible boot-time SMP configuration:
1225 */
1226 find_smp_config();
1227 #endif
1228
1229 #ifdef CONFIG_BLK_DEV_INITRD
1230 if (LOADER_TYPE && INITRD_START) {
1231 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
1232 reserve_bootmem(INITRD_START, INITRD_SIZE);
1233 initrd_start =
1234 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
1235 initrd_end = initrd_start+INITRD_SIZE;
1236 }
1237 else {
1238 printk(KERN_ERR "initrd extends beyond end of memory "
1239 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
1240 INITRD_START + INITRD_SIZE,
1241 max_low_pfn << PAGE_SHIFT);
1242 initrd_start = 0;
1243 }
1244 }
1245 #endif
1246 #ifdef CONFIG_KEXEC
1247 if (crashk_res.start != crashk_res.end)
1248 reserve_bootmem(crashk_res.start,
1249 crashk_res.end - crashk_res.start + 1);
1250 #endif
1251 }
1252
1253 /*
1254 * The node 0 pgdat is initialized before all of these because
1255 * it's needed for bootmem. node>0 pgdats have their virtual
1256 * space allocated before the pagetables are in place to access
1257 * them, so they can't be cleared then.
1258 *
1259 * This should all compile down to nothing when NUMA is off.
1260 */
1261 void __init remapped_pgdat_init(void)
1262 {
1263 int nid;
1264
1265 for_each_online_node(nid) {
1266 if (nid != 0)
1267 memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
1268 }
1269 }
1270
1271 /*
1272 * Request address space for all standard RAM and ROM resources
1273 * and also for regions reported as reserved by the e820.
1274 */
1275 static void __init
1276 legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
1277 {
1278 int i;
1279
1280 probe_roms();
1281 for (i = 0; i < e820.nr_map; i++) {
1282 struct resource *res;
1283 if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
1284 continue;
1285 res = alloc_bootmem_low(sizeof(struct resource));
1286 switch (e820.map[i].type) {
1287 case E820_RAM: res->name = "System RAM"; break;
1288 case E820_ACPI: res->name = "ACPI Tables"; break;
1289 case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
1290 default: res->name = "reserved";
1291 }
1292 res->start = e820.map[i].addr;
1293 res->end = res->start + e820.map[i].size - 1;
1294 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
1295 request_resource(&iomem_resource, res);
1296 if (e820.map[i].type == E820_RAM) {
1297 /*
1298 * We don't know which RAM region contains kernel data,
1299 * so we try it repeatedly and let the resource manager
1300 * test it.
1301 */
1302 request_resource(res, code_resource);
1303 request_resource(res, data_resource);
1304 #ifdef CONFIG_KEXEC
1305 request_resource(res, &crashk_res);
1306 #endif
1307 }
1308 }
1309 }
1310
1311 /*
1312 * Request address space for all standard resources
1313 */
1314 static void __init register_memory(void)
1315 {
1316 unsigned long gapstart, gapsize, round;
1317 unsigned long long last;
1318 int i;
1319
1320 if (efi_enabled)
1321 efi_initialize_iomem_resources(&code_resource, &data_resource);
1322 else
1323 legacy_init_iomem_resources(&code_resource, &data_resource);
1324
1325 /* EFI systems may still have VGA */
1326 request_resource(&iomem_resource, &video_ram_resource);
1327
1328 /* request I/O space for devices used on all i[345]86 PCs */
1329 for (i = 0; i < STANDARD_IO_RESOURCES; i++)
1330 request_resource(&ioport_resource, &standard_io_resources[i]);
1331
1332 /*
1333 * Search for the bigest gap in the low 32 bits of the e820
1334 * memory space.
1335 */
1336 last = 0x100000000ull;
1337 gapstart = 0x10000000;
1338 gapsize = 0x400000;
1339 i = e820.nr_map;
1340 while (--i >= 0) {
1341 unsigned long long start = e820.map[i].addr;
1342 unsigned long long end = start + e820.map[i].size;
1343
1344 /*
1345 * Since "last" is at most 4GB, we know we'll
1346 * fit in 32 bits if this condition is true
1347 */
1348 if (last > end) {
1349 unsigned long gap = last - end;
1350
1351 if (gap > gapsize) {
1352 gapsize = gap;
1353 gapstart = end;
1354 }
1355 }
1356 if (start < last)
1357 last = start;
1358 }
1359
1360 /*
1361 * See how much we want to round up: start off with
1362 * rounding to the next 1MB area.
1363 */
1364 round = 0x100000;
1365 while ((gapsize >> 4) > round)
1366 round += round;
1367 /* Fun with two's complement */
1368 pci_mem_start = (gapstart + round) & -round;
1369
1370 printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
1371 pci_mem_start, gapstart, gapsize);
1372 }
1373
1374 /* Use inline assembly to define this because the nops are defined
1375 as inline assembly strings in the include files and we cannot
1376 get them easily into strings. */
1377 asm("\t.data\nintelnops: "
1378 GENERIC_NOP1 GENERIC_NOP2 GENERIC_NOP3 GENERIC_NOP4 GENERIC_NOP5 GENERIC_NOP6
1379 GENERIC_NOP7 GENERIC_NOP8);
1380 asm("\t.data\nk8nops: "
1381 K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
1382 K8_NOP7 K8_NOP8);
1383 asm("\t.data\nk7nops: "
1384 K7_NOP1 K7_NOP2 K7_NOP3 K7_NOP4 K7_NOP5 K7_NOP6
1385 K7_NOP7 K7_NOP8);
1386
1387 extern unsigned char intelnops[], k8nops[], k7nops[];
1388 static unsigned char *intel_nops[ASM_NOP_MAX+1] = {
1389 NULL,
1390 intelnops,
1391 intelnops + 1,
1392 intelnops + 1 + 2,
1393 intelnops + 1 + 2 + 3,
1394 intelnops + 1 + 2 + 3 + 4,
1395 intelnops + 1 + 2 + 3 + 4 + 5,
1396 intelnops + 1 + 2 + 3 + 4 + 5 + 6,
1397 intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1398 };
1399 static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
1400 NULL,
1401 k8nops,
1402 k8nops + 1,
1403 k8nops + 1 + 2,
1404 k8nops + 1 + 2 + 3,
1405 k8nops + 1 + 2 + 3 + 4,
1406 k8nops + 1 + 2 + 3 + 4 + 5,
1407 k8nops + 1 + 2 + 3 + 4 + 5 + 6,
1408 k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1409 };
1410 static unsigned char *k7_nops[ASM_NOP_MAX+1] = {
1411 NULL,
1412 k7nops,
1413 k7nops + 1,
1414 k7nops + 1 + 2,
1415 k7nops + 1 + 2 + 3,
1416 k7nops + 1 + 2 + 3 + 4,
1417 k7nops + 1 + 2 + 3 + 4 + 5,
1418 k7nops + 1 + 2 + 3 + 4 + 5 + 6,
1419 k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1420 };
1421 static struct nop {
1422 int cpuid;
1423 unsigned char **noptable;
1424 } noptypes[] = {
1425 { X86_FEATURE_K8, k8_nops },
1426 { X86_FEATURE_K7, k7_nops },
1427 { -1, NULL }
1428 };
1429
1430 /* Replace instructions with better alternatives for this CPU type.
1431
1432 This runs before SMP is initialized to avoid SMP problems with
1433 self modifying code. This implies that assymetric systems where
1434 APs have less capabilities than the boot processor are not handled.
1435 Tough. Make sure you disable such features by hand. */
1436 void apply_alternatives(void *start, void *end)
1437 {
1438 struct alt_instr *a;
1439 int diff, i, k;
1440 unsigned char **noptable = intel_nops;
1441 for (i = 0; noptypes[i].cpuid >= 0; i++) {
1442 if (boot_cpu_has(noptypes[i].cpuid)) {
1443 noptable = noptypes[i].noptable;
1444 break;
1445 }
1446 }
1447 for (a = start; (void *)a < end; a++) {
1448 if (!boot_cpu_has(a->cpuid))
1449 continue;
1450 BUG_ON(a->replacementlen > a->instrlen);
1451 memcpy(a->instr, a->replacement, a->replacementlen);
1452 diff = a->instrlen - a->replacementlen;
1453 /* Pad the rest with nops */
1454 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
1455 k = diff;
1456 if (k > ASM_NOP_MAX)
1457 k = ASM_NOP_MAX;
1458 memcpy(a->instr + i, noptable[k], k);
1459 }
1460 }
1461 }
1462
1463 void __init alternative_instructions(void)
1464 {
1465 extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
1466 apply_alternatives(__alt_instructions, __alt_instructions_end);
1467 }
1468
1469 static char * __init machine_specific_memory_setup(void);
1470
1471 #ifdef CONFIG_MCA
1472 static void set_mca_bus(int x)
1473 {
1474 MCA_bus = x;
1475 }
1476 #else
1477 static void set_mca_bus(int x) { }
1478 #endif
1479
1480 /*
1481 * Determine if we were loaded by an EFI loader. If so, then we have also been
1482 * passed the efi memmap, systab, etc., so we should use these data structures
1483 * for initialization. Note, the efi init code path is determined by the
1484 * global efi_enabled. This allows the same kernel image to be used on existing
1485 * systems (with a traditional BIOS) as well as on EFI systems.
1486 */
1487 void __init setup_arch(char **cmdline_p)
1488 {
1489 unsigned long max_low_pfn;
1490
1491 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
1492 pre_setup_arch_hook();
1493 early_cpu_init();
1494
1495 /*
1496 * FIXME: This isn't an official loader_type right
1497 * now but does currently work with elilo.
1498 * If we were configured as an EFI kernel, check to make
1499 * sure that we were loaded correctly from elilo and that
1500 * the system table is valid. If not, then initialize normally.
1501 */
1502 #ifdef CONFIG_EFI
1503 if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
1504 efi_enabled = 1;
1505 #endif
1506
1507 ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
1508 drive_info = DRIVE_INFO;
1509 screen_info = SCREEN_INFO;
1510 edid_info = EDID_INFO;
1511 apm_info.bios = APM_BIOS_INFO;
1512 ist_info = IST_INFO;
1513 saved_videomode = VIDEO_MODE;
1514 if( SYS_DESC_TABLE.length != 0 ) {
1515 set_mca_bus(SYS_DESC_TABLE.table[3] & 0x2);
1516 machine_id = SYS_DESC_TABLE.table[0];
1517 machine_submodel_id = SYS_DESC_TABLE.table[1];
1518 BIOS_revision = SYS_DESC_TABLE.table[2];
1519 }
1520 bootloader_type = LOADER_TYPE;
1521
1522 #ifdef CONFIG_BLK_DEV_RAM
1523 rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
1524 rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
1525 rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
1526 #endif
1527 ARCH_SETUP
1528 if (efi_enabled)
1529 efi_init();
1530 else {
1531 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
1532 print_memory_map(machine_specific_memory_setup());
1533 }
1534
1535 copy_edd();
1536
1537 if (!MOUNT_ROOT_RDONLY)
1538 root_mountflags &= ~MS_RDONLY;
1539 init_mm.start_code = (unsigned long) _text;
1540 init_mm.end_code = (unsigned long) _etext;
1541 init_mm.end_data = (unsigned long) _edata;
1542 init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
1543
1544 code_resource.start = virt_to_phys(_text);
1545 code_resource.end = virt_to_phys(_etext)-1;
1546 data_resource.start = virt_to_phys(_etext);
1547 data_resource.end = virt_to_phys(_edata)-1;
1548
1549 parse_cmdline_early(cmdline_p);
1550
1551 max_low_pfn = setup_memory();
1552
1553 /*
1554 * NOTE: before this point _nobody_ is allowed to allocate
1555 * any memory using the bootmem allocator. Although the
1556 * alloctor is now initialised only the first 8Mb of the kernel
1557 * virtual address space has been mapped. All allocations before
1558 * paging_init() has completed must use the alloc_bootmem_low_pages()
1559 * variant (which allocates DMA'able memory) and care must be taken
1560 * not to exceed the 8Mb limit.
1561 */
1562
1563 #ifdef CONFIG_SMP
1564 smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
1565 #endif
1566 paging_init();
1567 remapped_pgdat_init();
1568 sparse_init();
1569 zone_sizes_init();
1570
1571 /*
1572 * NOTE: at this point the bootmem allocator is fully available.
1573 */
1574
1575 #ifdef CONFIG_EARLY_PRINTK
1576 {
1577 char *s = strstr(*cmdline_p, "earlyprintk=");
1578 if (s) {
1579 extern void setup_early_printk(char *);
1580
1581 setup_early_printk(s);
1582 printk("early console enabled\n");
1583 }
1584 }
1585 #endif
1586
1587
1588 dmi_scan_machine();
1589
1590 #ifdef CONFIG_X86_GENERICARCH
1591 generic_apic_probe(*cmdline_p);
1592 #endif
1593 if (efi_enabled)
1594 efi_map_memmap();
1595
1596 #ifdef CONFIG_ACPI
1597 /*
1598 * Parse the ACPI tables for possible boot-time SMP configuration.
1599 */
1600 acpi_boot_table_init();
1601 acpi_boot_init();
1602
1603 #if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
1604 if (def_to_bigsmp)
1605 printk(KERN_WARNING "More than 8 CPUs detected and "
1606 "CONFIG_X86_PC cannot handle it.\nUse "
1607 "CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
1608 #endif
1609 #endif
1610 #ifdef CONFIG_X86_LOCAL_APIC
1611 if (smp_found_config)
1612 get_smp_config();
1613 #endif
1614
1615 register_memory();
1616
1617 #ifdef CONFIG_VT
1618 #if defined(CONFIG_VGA_CONSOLE)
1619 if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1620 conswitchp = &vga_con;
1621 #elif defined(CONFIG_DUMMY_CONSOLE)
1622 conswitchp = &dummy_con;
1623 #endif
1624 #endif
1625 }
1626
1627 #include "setup_arch_post.h"
1628 /*
1629 * Local Variables:
1630 * mode:c
1631 * c-file-style:"k&r"
1632 * c-basic-offset:8
1633 * End:
1634 */
Ubuntu Artful kernel mirror