projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] convert i386 NUMA KVA space to bootmem
[deliverable/linux.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/sched.h>
27 #include <linux/mm.h>
28 #include <linux/mmzone.h>
29 #include <linux/screen_info.h>
30 #include <linux/ioport.h>
31 #include <linux/acpi.h>
32 #include <linux/apm_bios.h>
33 #include <linux/initrd.h>
34 #include <linux/bootmem.h>
35 #include <linux/seq_file.h>
36 #include <linux/platform_device.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 #include <linux/dmi.h>
49 #include <linux/pfn.h>
50
51 #include <video/edid.h>
52
53 #include <asm/apic.h>
54 #include <asm/e820.h>
55 #include <asm/mpspec.h>
56 #include <asm/mmzone.h>
57 #include <asm/setup.h>
58 #include <asm/arch_hooks.h>
59 #include <asm/sections.h>
60 #include <asm/io_apic.h>
61 #include <asm/ist.h>
62 #include <asm/io.h>
63 #include <setup_arch.h>
64 #include <bios_ebda.h>
65
66 /* Forward Declaration. */
67 void __init find_max_pfn(void);
68
69 /* This value is set up by the early boot code to point to the value
70 immediately after the boot time page tables. It contains a *physical*
71 address, and must not be in the .bss segment! */
72 unsigned long init_pg_tables_end __initdata = ~0UL;
73
74 int disable_pse __devinitdata = 0;
75
76 /*
77 * Machine setup..
78 */
79
80 #ifdef CONFIG_EFI
81 int efi_enabled = 0;
82 EXPORT_SYMBOL(efi_enabled);
83 #endif
84
85 /* cpu data as detected by the assembly code in head.S */
86 struct cpuinfo_x86 new_cpu_data __initdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
87 /* common cpu data for all cpus */
88 struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
89 EXPORT_SYMBOL(boot_cpu_data);
90
91 unsigned long mmu_cr4_features;
92
93 #ifdef CONFIG_ACPI
94 int acpi_disabled = 0;
95 #else
96 int acpi_disabled = 1;
97 #endif
98 EXPORT_SYMBOL(acpi_disabled);
99
100 #ifdef CONFIG_ACPI
101 int __initdata acpi_force = 0;
102 extern acpi_interrupt_flags acpi_sci_flags;
103 #endif
104
105 /* for MCA, but anyone else can use it if they want */
106 unsigned int machine_id;
107 #ifdef CONFIG_MCA
108 EXPORT_SYMBOL(machine_id);
109 #endif
110 unsigned int machine_submodel_id;
111 unsigned int BIOS_revision;
112 unsigned int mca_pentium_flag;
113
114 /* For PCI or other memory-mapped resources */
115 unsigned long pci_mem_start = 0x10000000;
116 #ifdef CONFIG_PCI
117 EXPORT_SYMBOL(pci_mem_start);
118 #endif
119
120 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
121 int bootloader_type;
122
123 /* user-defined highmem size */
124 static unsigned int highmem_pages = -1;
125
126 /*
127 * Setup options
128 */
129 struct drive_info_struct { char dummy[32]; } drive_info;
130 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || \
131 defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
132 EXPORT_SYMBOL(drive_info);
133 #endif
134 struct screen_info screen_info;
135 EXPORT_SYMBOL(screen_info);
136 struct apm_info apm_info;
137 EXPORT_SYMBOL(apm_info);
138 struct sys_desc_table_struct {
139 unsigned short length;
140 unsigned char table[0];
141 };
142 struct edid_info edid_info;
143 EXPORT_SYMBOL_GPL(edid_info);
144 struct ist_info ist_info;
145 #if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
146 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
147 EXPORT_SYMBOL(ist_info);
148 #endif
149 struct e820map e820;
150
151 extern void early_cpu_init(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 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 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 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 static void __init parse_cmdline_early (char ** cmdline_p)
705 {
706 char c = ' ', *to = command_line, *from = saved_command_line;
707 int len = 0;
708 int userdef = 0;
709
710 /* Save unparsed command line copy for /proc/cmdline */
711 saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
712
713 for (;;) {
714 if (c != ' ')
715 goto next_char;
716 /*
717 * "mem=nopentium" disables the 4MB page tables.
718 * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
719 * to <mem>, overriding the bios size.
720 * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
721 * <start> to <start>+<mem>, overriding the bios size.
722 *
723 * HPA tells me bootloaders need to parse mem=, so no new
724 * option should be mem= [also see Documentation/i386/boot.txt]
725 */
726 if (!memcmp(from, "mem=", 4)) {
727 if (to != command_line)
728 to--;
729 if (!memcmp(from+4, "nopentium", 9)) {
730 from += 9+4;
731 clear_bit(X86_FEATURE_PSE, boot_cpu_data.x86_capability);
732 disable_pse = 1;
733 } else {
734 /* If the user specifies memory size, we
735 * limit the BIOS-provided memory map to
736 * that size. exactmap can be used to specify
737 * the exact map. mem=number can be used to
738 * trim the existing memory map.
739 */
740 unsigned long long mem_size;
741
742 mem_size = memparse(from+4, &from);
743 limit_regions(mem_size);
744 userdef=1;
745 }
746 }
747
748 else if (!memcmp(from, "memmap=", 7)) {
749 if (to != command_line)
750 to--;
751 if (!memcmp(from+7, "exactmap", 8)) {
752 #ifdef CONFIG_CRASH_DUMP
753 /* If we are doing a crash dump, we
754 * still need to know the real mem
755 * size before original memory map is
756 * reset.
757 */
758 find_max_pfn();
759 saved_max_pfn = max_pfn;
760 #endif
761 from += 8+7;
762 e820.nr_map = 0;
763 userdef = 1;
764 } else {
765 /* If the user specifies memory size, we
766 * limit the BIOS-provided memory map to
767 * that size. exactmap can be used to specify
768 * the exact map. mem=number can be used to
769 * trim the existing memory map.
770 */
771 unsigned long long start_at, mem_size;
772
773 mem_size = memparse(from+7, &from);
774 if (*from == '@') {
775 start_at = memparse(from+1, &from);
776 add_memory_region(start_at, mem_size, E820_RAM);
777 } else if (*from == '#') {
778 start_at = memparse(from+1, &from);
779 add_memory_region(start_at, mem_size, E820_ACPI);
780 } else if (*from == '$') {
781 start_at = memparse(from+1, &from);
782 add_memory_region(start_at, mem_size, E820_RESERVED);
783 } else {
784 limit_regions(mem_size);
785 userdef=1;
786 }
787 }
788 }
789
790 else if (!memcmp(from, "noexec=", 7))
791 noexec_setup(from + 7);
792
793
794 #ifdef CONFIG_X86_SMP
795 /*
796 * If the BIOS enumerates physical processors before logical,
797 * maxcpus=N at enumeration-time can be used to disable HT.
798 */
799 else if (!memcmp(from, "maxcpus=", 8)) {
800 extern unsigned int maxcpus;
801
802 maxcpus = simple_strtoul(from + 8, NULL, 0);
803 }
804 #endif
805
806 #ifdef CONFIG_ACPI
807 /* "acpi=off" disables both ACPI table parsing and interpreter */
808 else if (!memcmp(from, "acpi=off", 8)) {
809 disable_acpi();
810 }
811
812 /* acpi=force to over-ride black-list */
813 else if (!memcmp(from, "acpi=force", 10)) {
814 acpi_force = 1;
815 acpi_ht = 1;
816 acpi_disabled = 0;
817 }
818
819 /* acpi=strict disables out-of-spec workarounds */
820 else if (!memcmp(from, "acpi=strict", 11)) {
821 acpi_strict = 1;
822 }
823
824 /* Limit ACPI just to boot-time to enable HT */
825 else if (!memcmp(from, "acpi=ht", 7)) {
826 if (!acpi_force)
827 disable_acpi();
828 acpi_ht = 1;
829 }
830
831 /* "pci=noacpi" disable ACPI IRQ routing and PCI scan */
832 else if (!memcmp(from, "pci=noacpi", 10)) {
833 acpi_disable_pci();
834 }
835 /* "acpi=noirq" disables ACPI interrupt routing */
836 else if (!memcmp(from, "acpi=noirq", 10)) {
837 acpi_noirq_set();
838 }
839
840 else if (!memcmp(from, "acpi_sci=edge", 13))
841 acpi_sci_flags.trigger = 1;
842
843 else if (!memcmp(from, "acpi_sci=level", 14))
844 acpi_sci_flags.trigger = 3;
845
846 else if (!memcmp(from, "acpi_sci=high", 13))
847 acpi_sci_flags.polarity = 1;
848
849 else if (!memcmp(from, "acpi_sci=low", 12))
850 acpi_sci_flags.polarity = 3;
851
852 #ifdef CONFIG_X86_IO_APIC
853 else if (!memcmp(from, "acpi_skip_timer_override", 24))
854 acpi_skip_timer_override = 1;
855
856 if (!memcmp(from, "disable_timer_pin_1", 19))
857 disable_timer_pin_1 = 1;
858 if (!memcmp(from, "enable_timer_pin_1", 18))
859 disable_timer_pin_1 = -1;
860
861 /* disable IO-APIC */
862 else if (!memcmp(from, "noapic", 6))
863 disable_ioapic_setup();
864 #endif /* CONFIG_X86_IO_APIC */
865 #endif /* CONFIG_ACPI */
866
867 #ifdef CONFIG_X86_LOCAL_APIC
868 /* enable local APIC */
869 else if (!memcmp(from, "lapic", 5))
870 lapic_enable();
871
872 /* disable local APIC */
873 else if (!memcmp(from, "nolapic", 6))
874 lapic_disable();
875 #endif /* CONFIG_X86_LOCAL_APIC */
876
877 #ifdef CONFIG_KEXEC
878 /* crashkernel=size@addr specifies the location to reserve for
879 * a crash kernel. By reserving this memory we guarantee
880 * that linux never set's it up as a DMA target.
881 * Useful for holding code to do something appropriate
882 * after a kernel panic.
883 */
884 else if (!memcmp(from, "crashkernel=", 12)) {
885 unsigned long size, base;
886 size = memparse(from+12, &from);
887 if (*from == '@') {
888 base = memparse(from+1, &from);
889 /* FIXME: Do I want a sanity check
890 * to validate the memory range?
891 */
892 crashk_res.start = base;
893 crashk_res.end = base + size - 1;
894 }
895 }
896 #endif
897 #ifdef CONFIG_PROC_VMCORE
898 /* elfcorehdr= specifies the location of elf core header
899 * stored by the crashed kernel.
900 */
901 else if (!memcmp(from, "elfcorehdr=", 11))
902 elfcorehdr_addr = memparse(from+11, &from);
903 #endif
904
905 /*
906 * highmem=size forces highmem to be exactly 'size' bytes.
907 * This works even on boxes that have no highmem otherwise.
908 * This also works to reduce highmem size on bigger boxes.
909 */
910 else if (!memcmp(from, "highmem=", 8))
911 highmem_pages = memparse(from+8, &from) >> PAGE_SHIFT;
912
913 /*
914 * vmalloc=size forces the vmalloc area to be exactly 'size'
915 * bytes. This can be used to increase (or decrease) the
916 * vmalloc area - the default is 128m.
917 */
918 else if (!memcmp(from, "vmalloc=", 8))
919 __VMALLOC_RESERVE = memparse(from+8, &from);
920
921 next_char:
922 c = *(from++);
923 if (!c)
924 break;
925 if (COMMAND_LINE_SIZE <= ++len)
926 break;
927 *(to++) = c;
928 }
929 *to = '\0';
930 *cmdline_p = command_line;
931 if (userdef) {
932 printk(KERN_INFO "user-defined physical RAM map:\n");
933 print_memory_map("user");
934 }
935 }
936
937 /*
938 * Callback for efi_memory_walk.
939 */
940 static int __init
941 efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
942 {
943 unsigned long *max_pfn = arg, pfn;
944
945 if (start < end) {
946 pfn = PFN_UP(end -1);
947 if (pfn > *max_pfn)
948 *max_pfn = pfn;
949 }
950 return 0;
951 }
952
953 static int __init
954 efi_memory_present_wrapper(unsigned long start, unsigned long end, void *arg)
955 {
956 memory_present(0, start, end);
957 return 0;
958 }
959
960 /*
961 * This function checks if the entire range <start,end> is mapped with type.
962 *
963 * Note: this function only works correct if the e820 table is sorted and
964 * not-overlapping, which is the case
965 */
966 int __init
967 e820_all_mapped(unsigned long s, unsigned long e, unsigned type)
968 {
969 u64 start = s;
970 u64 end = e;
971 int i;
972 for (i = 0; i < e820.nr_map; i++) {
973 struct e820entry *ei = &e820.map[i];
974 if (type && ei->type != type)
975 continue;
976 /* is the region (part) in overlap with the current region ?*/
977 if (ei->addr >= end || ei->addr + ei->size <= start)
978 continue;
979 /* if the region is at the beginning of <start,end> we move
980 * start to the end of the region since it's ok until there
981 */
982 if (ei->addr <= start)
983 start = ei->addr + ei->size;
984 /* if start is now at or beyond end, we're done, full
985 * coverage */
986 if (start >= end)
987 return 1; /* we're done */
988 }
989 return 0;
990 }
991
992 /*
993 * Find the highest page frame number we have available
994 */
995 void __init find_max_pfn(void)
996 {
997 int i;
998
999 max_pfn = 0;
1000 if (efi_enabled) {
1001 efi_memmap_walk(efi_find_max_pfn, &max_pfn);
1002 efi_memmap_walk(efi_memory_present_wrapper, NULL);
1003 return;
1004 }
1005
1006 for (i = 0; i < e820.nr_map; i++) {
1007 unsigned long start, end;
1008 /* RAM? */
1009 if (e820.map[i].type != E820_RAM)
1010 continue;
1011 start = PFN_UP(e820.map[i].addr);
1012 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1013 if (start >= end)
1014 continue;
1015 if (end > max_pfn)
1016 max_pfn = end;
1017 memory_present(0, start, end);
1018 }
1019 }
1020
1021 /*
1022 * Determine low and high memory ranges:
1023 */
1024 unsigned long __init find_max_low_pfn(void)
1025 {
1026 unsigned long max_low_pfn;
1027
1028 max_low_pfn = max_pfn;
1029 if (max_low_pfn > MAXMEM_PFN) {
1030 if (highmem_pages == -1)
1031 highmem_pages = max_pfn - MAXMEM_PFN;
1032 if (highmem_pages + MAXMEM_PFN < max_pfn)
1033 max_pfn = MAXMEM_PFN + highmem_pages;
1034 if (highmem_pages + MAXMEM_PFN > max_pfn) {
1035 printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
1036 highmem_pages = 0;
1037 }
1038 max_low_pfn = MAXMEM_PFN;
1039 #ifndef CONFIG_HIGHMEM
1040 /* Maximum memory usable is what is directly addressable */
1041 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
1042 MAXMEM>>20);
1043 if (max_pfn > MAX_NONPAE_PFN)
1044 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
1045 else
1046 printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
1047 max_pfn = MAXMEM_PFN;
1048 #else /* !CONFIG_HIGHMEM */
1049 #ifndef CONFIG_X86_PAE
1050 if (max_pfn > MAX_NONPAE_PFN) {
1051 max_pfn = MAX_NONPAE_PFN;
1052 printk(KERN_WARNING "Warning only 4GB will be used.\n");
1053 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
1054 }
1055 #endif /* !CONFIG_X86_PAE */
1056 #endif /* !CONFIG_HIGHMEM */
1057 } else {
1058 if (highmem_pages == -1)
1059 highmem_pages = 0;
1060 #ifdef CONFIG_HIGHMEM
1061 if (highmem_pages >= max_pfn) {
1062 printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
1063 highmem_pages = 0;
1064 }
1065 if (highmem_pages) {
1066 if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
1067 printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
1068 highmem_pages = 0;
1069 }
1070 max_low_pfn -= highmem_pages;
1071 }
1072 #else
1073 if (highmem_pages)
1074 printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
1075 #endif
1076 }
1077 return max_low_pfn;
1078 }
1079
1080 /*
1081 * Free all available memory for boot time allocation. Used
1082 * as a callback function by efi_memory_walk()
1083 */
1084
1085 static int __init
1086 free_available_memory(unsigned long start, unsigned long end, void *arg)
1087 {
1088 /* check max_low_pfn */
1089 if (start >= (max_low_pfn << PAGE_SHIFT))
1090 return 0;
1091 if (end >= (max_low_pfn << PAGE_SHIFT))
1092 end = max_low_pfn << PAGE_SHIFT;
1093 if (start < end)
1094 free_bootmem(start, end - start);
1095
1096 return 0;
1097 }
1098 /*
1099 * Register fully available low RAM pages with the bootmem allocator.
1100 */
1101 static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
1102 {
1103 int i;
1104
1105 if (efi_enabled) {
1106 efi_memmap_walk(free_available_memory, NULL);
1107 return;
1108 }
1109 for (i = 0; i < e820.nr_map; i++) {
1110 unsigned long curr_pfn, last_pfn, size;
1111 /*
1112 * Reserve usable low memory
1113 */
1114 if (e820.map[i].type != E820_RAM)
1115 continue;
1116 /*
1117 * We are rounding up the start address of usable memory:
1118 */
1119 curr_pfn = PFN_UP(e820.map[i].addr);
1120 if (curr_pfn >= max_low_pfn)
1121 continue;
1122 /*
1123 * ... and at the end of the usable range downwards:
1124 */
1125 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1126
1127 if (last_pfn > max_low_pfn)
1128 last_pfn = max_low_pfn;
1129
1130 /*
1131 * .. finally, did all the rounding and playing
1132 * around just make the area go away?
1133 */
1134 if (last_pfn <= curr_pfn)
1135 continue;
1136
1137 size = last_pfn - curr_pfn;
1138 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1139 }
1140 }
1141
1142 /*
1143 * workaround for Dell systems that neglect to reserve EBDA
1144 */
1145 static void __init reserve_ebda_region(void)
1146 {
1147 unsigned int addr;
1148 addr = get_bios_ebda();
1149 if (addr)
1150 reserve_bootmem(addr, PAGE_SIZE);
1151 }
1152
1153 #ifndef CONFIG_NEED_MULTIPLE_NODES
1154 void __init setup_bootmem_allocator(void);
1155 static unsigned long __init setup_memory(void)
1156 {
1157 /*
1158 * partially used pages are not usable - thus
1159 * we are rounding upwards:
1160 */
1161 min_low_pfn = PFN_UP(init_pg_tables_end);
1162
1163 find_max_pfn();
1164
1165 max_low_pfn = find_max_low_pfn();
1166
1167 #ifdef CONFIG_HIGHMEM
1168 highstart_pfn = highend_pfn = max_pfn;
1169 if (max_pfn > max_low_pfn) {
1170 highstart_pfn = max_low_pfn;
1171 }
1172 printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1173 pages_to_mb(highend_pfn - highstart_pfn));
1174 #endif
1175 printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
1176 pages_to_mb(max_low_pfn));
1177
1178 setup_bootmem_allocator();
1179
1180 return max_low_pfn;
1181 }
1182
1183 void __init zone_sizes_init(void)
1184 {
1185 unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
1186 unsigned int max_dma, low;
1187
1188 max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
1189 low = max_low_pfn;
1190
1191 if (low < max_dma)
1192 zones_size[ZONE_DMA] = low;
1193 else {
1194 zones_size[ZONE_DMA] = max_dma;
1195 zones_size[ZONE_NORMAL] = low - max_dma;
1196 #ifdef CONFIG_HIGHMEM
1197 zones_size[ZONE_HIGHMEM] = highend_pfn - low;
1198 #endif
1199 }
1200 free_area_init(zones_size);
1201 }
1202 #else
1203 extern unsigned long __init setup_memory(void);
1204 extern void zone_sizes_init(void);
1205 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
1206
1207 void __init setup_bootmem_allocator(void)
1208 {
1209 unsigned long bootmap_size;
1210 /*
1211 * Initialize the boot-time allocator (with low memory only):
1212 */
1213 bootmap_size = init_bootmem(min_low_pfn, max_low_pfn);
1214
1215 register_bootmem_low_pages(max_low_pfn);
1216
1217 /*
1218 * Reserve the bootmem bitmap itself as well. We do this in two
1219 * steps (first step was init_bootmem()) because this catches
1220 * the (very unlikely) case of us accidentally initializing the
1221 * bootmem allocator with an invalid RAM area.
1222 */
1223 reserve_bootmem(__PHYSICAL_START, (PFN_PHYS(min_low_pfn) +
1224 bootmap_size + PAGE_SIZE-1) - (__PHYSICAL_START));
1225
1226 /*
1227 * reserve physical page 0 - it's a special BIOS page on many boxes,
1228 * enabling clean reboots, SMP operation, laptop functions.
1229 */
1230 reserve_bootmem(0, PAGE_SIZE);
1231
1232 /* reserve EBDA region, it's a 4K region */
1233 reserve_ebda_region();
1234
1235 /* could be an AMD 768MPX chipset. Reserve a page before VGA to prevent
1236 PCI prefetch into it (errata #56). Usually the page is reserved anyways,
1237 unless you have no PS/2 mouse plugged in. */
1238 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
1239 boot_cpu_data.x86 == 6)
1240 reserve_bootmem(0xa0000 - 4096, 4096);
1241
1242 #ifdef CONFIG_SMP
1243 /*
1244 * But first pinch a few for the stack/trampoline stuff
1245 * FIXME: Don't need the extra page at 4K, but need to fix
1246 * trampoline before removing it. (see the GDT stuff)
1247 */
1248 reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
1249 #endif
1250 #ifdef CONFIG_ACPI_SLEEP
1251 /*
1252 * Reserve low memory region for sleep support.
1253 */
1254 acpi_reserve_bootmem();
1255 #endif
1256 #ifdef CONFIG_X86_FIND_SMP_CONFIG
1257 /*
1258 * Find and reserve possible boot-time SMP configuration:
1259 */
1260 find_smp_config();
1261 #endif
1262 numa_kva_reserve();
1263 #ifdef CONFIG_BLK_DEV_INITRD
1264 if (LOADER_TYPE && INITRD_START) {
1265 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
1266 reserve_bootmem(INITRD_START, INITRD_SIZE);
1267 initrd_start =
1268 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
1269 initrd_end = initrd_start+INITRD_SIZE;
1270 }
1271 else {
1272 printk(KERN_ERR "initrd extends beyond end of memory "
1273 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
1274 INITRD_START + INITRD_SIZE,
1275 max_low_pfn << PAGE_SHIFT);
1276 initrd_start = 0;
1277 }
1278 }
1279 #endif
1280 #ifdef CONFIG_KEXEC
1281 if (crashk_res.start != crashk_res.end)
1282 reserve_bootmem(crashk_res.start,
1283 crashk_res.end - crashk_res.start + 1);
1284 #endif
1285 }
1286
1287 /*
1288 * The node 0 pgdat is initialized before all of these because
1289 * it's needed for bootmem. node>0 pgdats have their virtual
1290 * space allocated before the pagetables are in place to access
1291 * them, so they can't be cleared then.
1292 *
1293 * This should all compile down to nothing when NUMA is off.
1294 */
1295 void __init remapped_pgdat_init(void)
1296 {
1297 int nid;
1298
1299 for_each_online_node(nid) {
1300 if (nid != 0)
1301 memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
1302 }
1303 }
1304
1305 /*
1306 * Request address space for all standard RAM and ROM resources
1307 * and also for regions reported as reserved by the e820.
1308 */
1309 static void __init
1310 legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
1311 {
1312 int i;
1313
1314 probe_roms();
1315 for (i = 0; i < e820.nr_map; i++) {
1316 struct resource *res;
1317 #ifndef CONFIG_RESOURCES_64BIT
1318 if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
1319 continue;
1320 #endif
1321 res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
1322 switch (e820.map[i].type) {
1323 case E820_RAM: res->name = "System RAM"; break;
1324 case E820_ACPI: res->name = "ACPI Tables"; break;
1325 case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
1326 default: res->name = "reserved";
1327 }
1328 res->start = e820.map[i].addr;
1329 res->end = res->start + e820.map[i].size - 1;
1330 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
1331 if (request_resource(&iomem_resource, res)) {
1332 kfree(res);
1333 continue;
1334 }
1335 if (e820.map[i].type == E820_RAM) {
1336 /*
1337 * We don't know which RAM region contains kernel data,
1338 * so we try it repeatedly and let the resource manager
1339 * test it.
1340 */
1341 request_resource(res, code_resource);
1342 request_resource(res, data_resource);
1343 #ifdef CONFIG_KEXEC
1344 request_resource(res, &crashk_res);
1345 #endif
1346 }
1347 }
1348 }
1349
1350 /*
1351 * Request address space for all standard resources
1352 *
1353 * This is called just before pcibios_init(), which is also a
1354 * subsys_initcall, but is linked in later (in arch/i386/pci/common.c).
1355 */
1356 static int __init request_standard_resources(void)
1357 {
1358 int i;
1359
1360 printk("Setting up standard PCI resources\n");
1361 if (efi_enabled)
1362 efi_initialize_iomem_resources(&code_resource, &data_resource);
1363 else
1364 legacy_init_iomem_resources(&code_resource, &data_resource);
1365
1366 /* EFI systems may still have VGA */
1367 request_resource(&iomem_resource, &video_ram_resource);
1368
1369 /* request I/O space for devices used on all i[345]86 PCs */
1370 for (i = 0; i < STANDARD_IO_RESOURCES; i++)
1371 request_resource(&ioport_resource, &standard_io_resources[i]);
1372 return 0;
1373 }
1374
1375 subsys_initcall(request_standard_resources);
1376
1377 static void __init register_memory(void)
1378 {
1379 unsigned long gapstart, gapsize, round;
1380 unsigned long long last;
1381 int i;
1382
1383 /*
1384 * Search for the bigest gap in the low 32 bits of the e820
1385 * memory space.
1386 */
1387 last = 0x100000000ull;
1388 gapstart = 0x10000000;
1389 gapsize = 0x400000;
1390 i = e820.nr_map;
1391 while (--i >= 0) {
1392 unsigned long long start = e820.map[i].addr;
1393 unsigned long long end = start + e820.map[i].size;
1394
1395 /*
1396 * Since "last" is at most 4GB, we know we'll
1397 * fit in 32 bits if this condition is true
1398 */
1399 if (last > end) {
1400 unsigned long gap = last - end;
1401
1402 if (gap > gapsize) {
1403 gapsize = gap;
1404 gapstart = end;
1405 }
1406 }
1407 if (start < last)
1408 last = start;
1409 }
1410
1411 /*
1412 * See how much we want to round up: start off with
1413 * rounding to the next 1MB area.
1414 */
1415 round = 0x100000;
1416 while ((gapsize >> 4) > round)
1417 round += round;
1418 /* Fun with two's complement */
1419 pci_mem_start = (gapstart + round) & -round;
1420
1421 printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
1422 pci_mem_start, gapstart, gapsize);
1423 }
1424
1425 #ifdef CONFIG_MCA
1426 static void set_mca_bus(int x)
1427 {
1428 MCA_bus = x;
1429 }
1430 #else
1431 static void set_mca_bus(int x) { }
1432 #endif
1433
1434 /*
1435 * Determine if we were loaded by an EFI loader. If so, then we have also been
1436 * passed the efi memmap, systab, etc., so we should use these data structures
1437 * for initialization. Note, the efi init code path is determined by the
1438 * global efi_enabled. This allows the same kernel image to be used on existing
1439 * systems (with a traditional BIOS) as well as on EFI systems.
1440 */
1441 void __init setup_arch(char **cmdline_p)
1442 {
1443 unsigned long max_low_pfn;
1444
1445 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
1446 pre_setup_arch_hook();
1447 early_cpu_init();
1448
1449 /*
1450 * FIXME: This isn't an official loader_type right
1451 * now but does currently work with elilo.
1452 * If we were configured as an EFI kernel, check to make
1453 * sure that we were loaded correctly from elilo and that
1454 * the system table is valid. If not, then initialize normally.
1455 */
1456 #ifdef CONFIG_EFI
1457 if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
1458 efi_enabled = 1;
1459 #endif
1460
1461 ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
1462 drive_info = DRIVE_INFO;
1463 screen_info = SCREEN_INFO;
1464 edid_info = EDID_INFO;
1465 apm_info.bios = APM_BIOS_INFO;
1466 ist_info = IST_INFO;
1467 saved_videomode = VIDEO_MODE;
1468 if( SYS_DESC_TABLE.length != 0 ) {
1469 set_mca_bus(SYS_DESC_TABLE.table[3] & 0x2);
1470 machine_id = SYS_DESC_TABLE.table[0];
1471 machine_submodel_id = SYS_DESC_TABLE.table[1];
1472 BIOS_revision = SYS_DESC_TABLE.table[2];
1473 }
1474 bootloader_type = LOADER_TYPE;
1475
1476 #ifdef CONFIG_BLK_DEV_RAM
1477 rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
1478 rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
1479 rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
1480 #endif
1481 ARCH_SETUP
1482 if (efi_enabled)
1483 efi_init();
1484 else {
1485 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
1486 print_memory_map(machine_specific_memory_setup());
1487 }
1488
1489 copy_edd();
1490
1491 if (!MOUNT_ROOT_RDONLY)
1492 root_mountflags &= ~MS_RDONLY;
1493 init_mm.start_code = (unsigned long) _text;
1494 init_mm.end_code = (unsigned long) _etext;
1495 init_mm.end_data = (unsigned long) _edata;
1496 init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
1497
1498 code_resource.start = virt_to_phys(_text);
1499 code_resource.end = virt_to_phys(_etext)-1;
1500 data_resource.start = virt_to_phys(_etext);
1501 data_resource.end = virt_to_phys(_edata)-1;
1502
1503 parse_cmdline_early(cmdline_p);
1504
1505 #ifdef CONFIG_EARLY_PRINTK
1506 {
1507 char *s = strstr(*cmdline_p, "earlyprintk=");
1508 if (s) {
1509 setup_early_printk(strchr(s, '=') + 1);
1510 printk("early console enabled\n");
1511 }
1512 }
1513 #endif
1514
1515 max_low_pfn = setup_memory();
1516
1517 /*
1518 * NOTE: before this point _nobody_ is allowed to allocate
1519 * any memory using the bootmem allocator. Although the
1520 * alloctor is now initialised only the first 8Mb of the kernel
1521 * virtual address space has been mapped. All allocations before
1522 * paging_init() has completed must use the alloc_bootmem_low_pages()
1523 * variant (which allocates DMA'able memory) and care must be taken
1524 * not to exceed the 8Mb limit.
1525 */
1526
1527 #ifdef CONFIG_SMP
1528 smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
1529 #endif
1530 paging_init();
1531 remapped_pgdat_init();
1532 sparse_init();
1533 zone_sizes_init();
1534
1535 /*
1536 * NOTE: at this point the bootmem allocator is fully available.
1537 */
1538
1539 dmi_scan_machine();
1540
1541 #ifdef CONFIG_X86_GENERICARCH
1542 generic_apic_probe(*cmdline_p);
1543 #endif
1544 if (efi_enabled)
1545 efi_map_memmap();
1546
1547 #ifdef CONFIG_ACPI
1548 /*
1549 * Parse the ACPI tables for possible boot-time SMP configuration.
1550 */
1551 acpi_boot_table_init();
1552 #endif
1553
1554 #ifdef CONFIG_X86_IO_APIC
1555 check_acpi_pci(); /* Checks more than just ACPI actually */
1556 #endif
1557
1558 #ifdef CONFIG_ACPI
1559 acpi_boot_init();
1560
1561 #if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
1562 if (def_to_bigsmp)
1563 printk(KERN_WARNING "More than 8 CPUs detected and "
1564 "CONFIG_X86_PC cannot handle it.\nUse "
1565 "CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
1566 #endif
1567 #endif
1568 #ifdef CONFIG_X86_LOCAL_APIC
1569 if (smp_found_config)
1570 get_smp_config();
1571 #endif
1572
1573 register_memory();
1574
1575 #ifdef CONFIG_VT
1576 #if defined(CONFIG_VGA_CONSOLE)
1577 if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1578 conswitchp = &vga_con;
1579 #elif defined(CONFIG_DUMMY_CONSOLE)
1580 conswitchp = &dummy_con;
1581 #endif
1582 #endif
1583 tsc_init();
1584 }
1585
1586 static __init int add_pcspkr(void)
1587 {
1588 struct platform_device *pd;
1589 int ret;
1590
1591 pd = platform_device_alloc("pcspkr", -1);
1592 if (!pd)
1593 return -ENOMEM;
1594
1595 ret = platform_device_add(pd);
1596 if (ret)
1597 platform_device_put(pd);
1598
1599 return ret;
1600 }
1601 device_initcall(add_pcspkr);
1602
1603 /*
1604 * Local Variables:
1605 * mode:c
1606 * c-file-style:"k&r"
1607 * c-basic-offset:8
1608 * End:
1609 */
Linux kernel - Deliverables
This page took 0.06317 seconds and 5 git commands to generate.