?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
e1000: FIX: fix wrong txdctl threshold bitmasks
[linux-2.6/mini2440.git] / arch / i386 / kernel / setup.c
blob519e63c3c1306abb1a59b31e017d76e4e671b01d
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 /* for MCA, but anyone else can use it if they want */
94 unsigned int machine_id;
95 #ifdef CONFIG_MCA
96 EXPORT_SYMBOL(machine_id);
97 #endif
98 unsigned int machine_submodel_id;
99 unsigned int BIOS_revision;
100 unsigned int mca_pentium_flag;
101
102 /* For PCI or other memory-mapped resources */
103 unsigned long pci_mem_start = 0x10000000;
104 #ifdef CONFIG_PCI
105 EXPORT_SYMBOL(pci_mem_start);
106 #endif
107
108 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
109 int bootloader_type;
110
111 /* user-defined highmem size */
112 static unsigned int highmem_pages = -1;
113
114 /*
115 * Setup options
116 */
117 struct drive_info_struct { char dummy[32]; } drive_info;
118 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || \
119 defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
120 EXPORT_SYMBOL(drive_info);
121 #endif
122 struct screen_info screen_info;
123 EXPORT_SYMBOL(screen_info);
124 struct apm_info apm_info;
125 EXPORT_SYMBOL(apm_info);
126 struct sys_desc_table_struct {
127 unsigned short length;
128 unsigned char table[0];
129 };
130 struct edid_info edid_info;
131 EXPORT_SYMBOL_GPL(edid_info);
132 struct ist_info ist_info;
133 #if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
134 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
135 EXPORT_SYMBOL(ist_info);
136 #endif
137 struct e820map e820;
138
139 extern void early_cpu_init(void);
140 extern int root_mountflags;
141
142 unsigned long saved_videomode;
143
144 #define RAMDISK_IMAGE_START_MASK 0x07FF
145 #define RAMDISK_PROMPT_FLAG 0x8000
146 #define RAMDISK_LOAD_FLAG 0x4000
147
148 static char command_line[COMMAND_LINE_SIZE];
149
150 unsigned char __initdata boot_params[PARAM_SIZE];
151
152 static struct resource data_resource = {
153 .name = "Kernel data",
154 .start = 0,
155 .end = 0,
156 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
157 };
158
159 static struct resource code_resource = {
160 .name = "Kernel code",
161 .start = 0,
162 .end = 0,
163 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
164 };
165
166 static struct resource system_rom_resource = {
167 .name = "System ROM",
168 .start = 0xf0000,
169 .end = 0xfffff,
170 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
171 };
172
173 static struct resource extension_rom_resource = {
174 .name = "Extension ROM",
175 .start = 0xe0000,
176 .end = 0xeffff,
177 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
178 };
179
180 static struct resource adapter_rom_resources[] = { {
181 .name = "Adapter ROM",
182 .start = 0xc8000,
183 .end = 0,
184 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
185 }, {
186 .name = "Adapter ROM",
187 .start = 0,
188 .end = 0,
189 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
190 }, {
191 .name = "Adapter ROM",
192 .start = 0,
193 .end = 0,
194 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
195 }, {
196 .name = "Adapter ROM",
197 .start = 0,
198 .end = 0,
199 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
200 }, {
201 .name = "Adapter ROM",
202 .start = 0,
203 .end = 0,
204 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
205 }, {
206 .name = "Adapter ROM",
207 .start = 0,
208 .end = 0,
209 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
210 } };
211
212 static struct resource video_rom_resource = {
213 .name = "Video ROM",
214 .start = 0xc0000,
215 .end = 0xc7fff,
216 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
217 };
218
219 static struct resource video_ram_resource = {
220 .name = "Video RAM area",
221 .start = 0xa0000,
222 .end = 0xbffff,
223 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
224 };
225
226 static struct resource standard_io_resources[] = { {
227 .name = "dma1",
228 .start = 0x0000,
229 .end = 0x001f,
230 .flags = IORESOURCE_BUSY | IORESOURCE_IO
231 }, {
232 .name = "pic1",
233 .start = 0x0020,
234 .end = 0x0021,
235 .flags = IORESOURCE_BUSY | IORESOURCE_IO
236 }, {
237 .name = "timer0",
238 .start = 0x0040,
239 .end = 0x0043,
240 .flags = IORESOURCE_BUSY | IORESOURCE_IO
241 }, {
242 .name = "timer1",
243 .start = 0x0050,
244 .end = 0x0053,
245 .flags = IORESOURCE_BUSY | IORESOURCE_IO
246 }, {
247 .name = "keyboard",
248 .start = 0x0060,
249 .end = 0x006f,
250 .flags = IORESOURCE_BUSY | IORESOURCE_IO
251 }, {
252 .name = "dma page reg",
253 .start = 0x0080,
254 .end = 0x008f,
255 .flags = IORESOURCE_BUSY | IORESOURCE_IO
256 }, {
257 .name = "pic2",
258 .start = 0x00a0,
259 .end = 0x00a1,
260 .flags = IORESOURCE_BUSY | IORESOURCE_IO
261 }, {
262 .name = "dma2",
263 .start = 0x00c0,
264 .end = 0x00df,
265 .flags = IORESOURCE_BUSY | IORESOURCE_IO
266 }, {
267 .name = "fpu",
268 .start = 0x00f0,
269 .end = 0x00ff,
270 .flags = IORESOURCE_BUSY | IORESOURCE_IO
271 } };
272
273 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
274
275 static int __init romchecksum(unsigned char *rom, unsigned long length)
276 {
277 unsigned char *p, sum = 0;
278
279 for (p = rom; p < rom + length; p++)
280 sum += *p;
281 return sum == 0;
282 }
283
284 static void __init probe_roms(void)
285 {
286 unsigned long start, length, upper;
287 unsigned char *rom;
288 int i;
289
290 /* video rom */
291 upper = adapter_rom_resources[0].start;
292 for (start = video_rom_resource.start; start < upper; start += 2048) {
293 rom = isa_bus_to_virt(start);
294 if (!romsignature(rom))
295 continue;
296
297 video_rom_resource.start = start;
298
299 /* 0 < length <= 0x7f * 512, historically */
300 length = rom[2] * 512;
301
302 /* if checksum okay, trust length byte */
303 if (length && romchecksum(rom, length))
304 video_rom_resource.end = start + length - 1;
305
306 request_resource(&iomem_resource, &video_rom_resource);
307 break;
308 }
309
310 start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
311 if (start < upper)
312 start = upper;
313
314 /* system rom */
315 request_resource(&iomem_resource, &system_rom_resource);
316 upper = system_rom_resource.start;
317
318 /* check for extension rom (ignore length byte!) */
319 rom = isa_bus_to_virt(extension_rom_resource.start);
320 if (romsignature(rom)) {
321 length = extension_rom_resource.end - extension_rom_resource.start + 1;
322 if (romchecksum(rom, length)) {
323 request_resource(&iomem_resource, &extension_rom_resource);
324 upper = extension_rom_resource.start;
325 }
326 }
327
328 /* check for adapter roms on 2k boundaries */
329 for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
330 rom = isa_bus_to_virt(start);
331 if (!romsignature(rom))
332 continue;
333
334 /* 0 < length <= 0x7f * 512, historically */
335 length = rom[2] * 512;
336
337 /* but accept any length that fits if checksum okay */
338 if (!length || start + length > upper || !romchecksum(rom, length))
339 continue;
340
341 adapter_rom_resources[i].start = start;
342 adapter_rom_resources[i].end = start + length - 1;
343 request_resource(&iomem_resource, &adapter_rom_resources[i]);
344
345 start = adapter_rom_resources[i++].end & ~2047UL;
346 }
347 }
348
349 static void __init limit_regions(unsigned long long size)
350 {
351 unsigned long long current_addr = 0;
352 int i;
353
354 if (efi_enabled) {
355 efi_memory_desc_t *md;
356 void *p;
357
358 for (p = memmap.map, i = 0; p < memmap.map_end;
359 p += memmap.desc_size, i++) {
360 md = p;
361 current_addr = md->phys_addr + (md->num_pages << 12);
362 if (md->type == EFI_CONVENTIONAL_MEMORY) {
363 if (current_addr >= size) {
364 md->num_pages -=
365 (((current_addr-size) + PAGE_SIZE-1) >> PAGE_SHIFT);
366 memmap.nr_map = i + 1;
367 return;
368 }
369 }
370 }
371 }
372 for (i = 0; i < e820.nr_map; i++) {
373 current_addr = e820.map[i].addr + e820.map[i].size;
374 if (current_addr < size)
375 continue;
376
377 if (e820.map[i].type != E820_RAM)
378 continue;
379
380 if (e820.map[i].addr >= size) {
381 /*
382 * This region starts past the end of the
383 * requested size, skip it completely.
384 */
385 e820.nr_map = i;
386 } else {
387 e820.nr_map = i + 1;
388 e820.map[i].size -= current_addr - size;
389 }
390 return;
391 }
392 }
393
394 void __init add_memory_region(unsigned long long start,
395 unsigned long long size, int type)
396 {
397 int x;
398
399 if (!efi_enabled) {
400 x = e820.nr_map;
401
402 if (x == E820MAX) {
403 printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
404 return;
405 }
406
407 e820.map[x].addr = start;
408 e820.map[x].size = size;
409 e820.map[x].type = type;
410 e820.nr_map++;
411 }
412 } /* add_memory_region */
413
414 #define E820_DEBUG 1
415
416 static void __init print_memory_map(char *who)
417 {
418 int i;
419
420 for (i = 0; i < e820.nr_map; i++) {
421 printk(" %s: %016Lx - %016Lx ", who,
422 e820.map[i].addr,
423 e820.map[i].addr + e820.map[i].size);
424 switch (e820.map[i].type) {
425 case E820_RAM: printk("(usable)\n");
426 break;
427 case E820_RESERVED:
428 printk("(reserved)\n");
429 break;
430 case E820_ACPI:
431 printk("(ACPI data)\n");
432 break;
433 case E820_NVS:
434 printk("(ACPI NVS)\n");
435 break;
436 default: printk("type %lu\n", e820.map[i].type);
437 break;
438 }
439 }
440 }
441
442 /*
443 * Sanitize the BIOS e820 map.
444 *
445 * Some e820 responses include overlapping entries. The following
446 * replaces the original e820 map with a new one, removing overlaps.
447 *
448 */
449 struct change_member {
450 struct e820entry *pbios; /* pointer to original bios entry */
451 unsigned long long addr; /* address for this change point */
452 };
453 static struct change_member change_point_list[2*E820MAX] __initdata;
454 static struct change_member *change_point[2*E820MAX] __initdata;
455 static struct e820entry *overlap_list[E820MAX] __initdata;
456 static struct e820entry new_bios[E820MAX] __initdata;
457
458 int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
459 {
460 struct change_member *change_tmp;
461 unsigned long current_type, last_type;
462 unsigned long long last_addr;
463 int chgidx, still_changing;
464 int overlap_entries;
465 int new_bios_entry;
466 int old_nr, new_nr, chg_nr;
467 int i;
468
469 /*
470 Visually we're performing the following (1,2,3,4 = memory types)...
471
472 Sample memory map (w/overlaps):
473 ____22__________________
474 ______________________4_
475 ____1111________________
476 _44_____________________
477 11111111________________
478 ____________________33__
479 ___________44___________
480 __________33333_________
481 ______________22________
482 ___________________2222_
483 _________111111111______
484 _____________________11_
485 _________________4______
486
487 Sanitized equivalent (no overlap):
488 1_______________________
489 _44_____________________
490 ___1____________________
491 ____22__________________
492 ______11________________
493 _________1______________
494 __________3_____________
495 ___________44___________
496 _____________33_________
497 _______________2________
498 ________________1_______
499 _________________4______
500 ___________________2____
501 ____________________33__
502 ______________________4_
503 */
504
505 /* if there's only one memory region, don't bother */
506 if (*pnr_map < 2)
507 return -1;
508
509 old_nr = *pnr_map;
510
511 /* bail out if we find any unreasonable addresses in bios map */
512 for (i=0; i<old_nr; i++)
513 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
514 return -1;
515
516 /* create pointers for initial change-point information (for sorting) */
517 for (i=0; i < 2*old_nr; i++)
518 change_point[i] = &change_point_list[i];
519
520 /* record all known change-points (starting and ending addresses),
521 omitting those that are for empty memory regions */
522 chgidx = 0;
523 for (i=0; i < old_nr; i++) {
524 if (biosmap[i].size != 0) {
525 change_point[chgidx]->addr = biosmap[i].addr;
526 change_point[chgidx++]->pbios = &biosmap[i];
527 change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
528 change_point[chgidx++]->pbios = &biosmap[i];
529 }
530 }
531 chg_nr = chgidx; /* true number of change-points */
532
533 /* sort change-point list by memory addresses (low -> high) */
534 still_changing = 1;
535 while (still_changing) {
536 still_changing = 0;
537 for (i=1; i < chg_nr; i++) {
538 /* if <current_addr> > <last_addr>, swap */
539 /* or, if current=<start_addr> & last=<end_addr>, swap */
540 if ((change_point[i]->addr < change_point[i-1]->addr) ||
541 ((change_point[i]->addr == change_point[i-1]->addr) &&
542 (change_point[i]->addr == change_point[i]->pbios->addr) &&
543 (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
544 )
545 {
546 change_tmp = change_point[i];
547 change_point[i] = change_point[i-1];
548 change_point[i-1] = change_tmp;
549 still_changing=1;
550 }
551 }
552 }
553
554 /* create a new bios memory map, removing overlaps */
555 overlap_entries=0; /* number of entries in the overlap table */
556 new_bios_entry=0; /* index for creating new bios map entries */
557 last_type = 0; /* start with undefined memory type */
558 last_addr = 0; /* start with 0 as last starting address */
559 /* loop through change-points, determining affect on the new bios map */
560 for (chgidx=0; chgidx < chg_nr; chgidx++)
561 {
562 /* keep track of all overlapping bios entries */
563 if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
564 {
565 /* add map entry to overlap list (> 1 entry implies an overlap) */
566 overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
567 }
568 else
569 {
570 /* remove entry from list (order independent, so swap with last) */
571 for (i=0; i<overlap_entries; i++)
572 {
573 if (overlap_list[i] == change_point[chgidx]->pbios)
574 overlap_list[i] = overlap_list[overlap_entries-1];
575 }
576 overlap_entries--;
577 }
578 /* if there are overlapping entries, decide which "type" to use */
579 /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
580 current_type = 0;
581 for (i=0; i<overlap_entries; i++)
582 if (overlap_list[i]->type > current_type)
583 current_type = overlap_list[i]->type;
584 /* continue building up new bios map based on this information */
585 if (current_type != last_type) {
586 if (last_type != 0) {
587 new_bios[new_bios_entry].size =
588 change_point[chgidx]->addr - last_addr;
589 /* move forward only if the new size was non-zero */
590 if (new_bios[new_bios_entry].size != 0)
591 if (++new_bios_entry >= E820MAX)
592 break; /* no more space left for new bios entries */
593 }
594 if (current_type != 0) {
595 new_bios[new_bios_entry].addr = change_point[chgidx]->addr;
596 new_bios[new_bios_entry].type = current_type;
597 last_addr=change_point[chgidx]->addr;
598 }
599 last_type = current_type;
600 }
601 }
602 new_nr = new_bios_entry; /* retain count for new bios entries */
603
604 /* copy new bios mapping into original location */
605 memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
606 *pnr_map = new_nr;
607
608 return 0;
609 }
610
611 /*
612 * Copy the BIOS e820 map into a safe place.
613 *
614 * Sanity-check it while we're at it..
615 *
616 * If we're lucky and live on a modern system, the setup code
617 * will have given us a memory map that we can use to properly
618 * set up memory. If we aren't, we'll fake a memory map.
619 *
620 * We check to see that the memory map contains at least 2 elements
621 * before we'll use it, because the detection code in setup.S may
622 * not be perfect and most every PC known to man has two memory
623 * regions: one from 0 to 640k, and one from 1mb up. (The IBM
624 * thinkpad 560x, for example, does not cooperate with the memory
625 * detection code.)
626 */
627 int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
628 {
629 /* Only one memory region (or negative)? Ignore it */
630 if (nr_map < 2)
631 return -1;
632
633 do {
634 unsigned long long start = biosmap->addr;
635 unsigned long long size = biosmap->size;
636 unsigned long long end = start + size;
637 unsigned long type = biosmap->type;
638
639 /* Overflow in 64 bits? Ignore the memory map. */
640 if (start > end)
641 return -1;
642
643 /*
644 * Some BIOSes claim RAM in the 640k - 1M region.
645 * Not right. Fix it up.
646 */
647 if (type == E820_RAM) {
648 if (start < 0x100000ULL && end > 0xA0000ULL) {
649 if (start < 0xA0000ULL)
650 add_memory_region(start, 0xA0000ULL-start, type);
651 if (end <= 0x100000ULL)
652 continue;
653 start = 0x100000ULL;
654 size = end - start;
655 }
656 }
657 add_memory_region(start, size, type);
658 } while (biosmap++,--nr_map);
659 return 0;
660 }
661
662 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
663 struct edd edd;
664 #ifdef CONFIG_EDD_MODULE
665 EXPORT_SYMBOL(edd);
666 #endif
667 /**
668 * copy_edd() - Copy the BIOS EDD information
669 * from boot_params into a safe place.
670 *
671 */
672 static inline void copy_edd(void)
673 {
674 memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
675 memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
676 edd.mbr_signature_nr = EDD_MBR_SIG_NR;
677 edd.edd_info_nr = EDD_NR;
678 }
679 #else
680 static inline void copy_edd(void)
681 {
682 }
683 #endif
684
685 static int __initdata user_defined_memmap = 0;
686
687 /*
688 * "mem=nopentium" disables the 4MB page tables.
689 * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
690 * to <mem>, overriding the bios size.
691 * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
692 * <start> to <start>+<mem>, overriding the bios size.
693 *
694 * HPA tells me bootloaders need to parse mem=, so no new
695 * option should be mem= [also see Documentation/i386/boot.txt]
696 */
697 static int __init parse_mem(char *arg)
698 {
699 if (!arg)
700 return -EINVAL;
701
702 if (strcmp(arg, "nopentium") == 0) {
703 clear_bit(X86_FEATURE_PSE, boot_cpu_data.x86_capability);
704 disable_pse = 1;
705 } else {
706 /* If the user specifies memory size, we
707 * limit the BIOS-provided memory map to
708 * that size. exactmap can be used to specify
709 * the exact map. mem=number can be used to
710 * trim the existing memory map.
711 */
712 unsigned long long mem_size;
713
714 mem_size = memparse(arg, &arg);
715 limit_regions(mem_size);
716 user_defined_memmap = 1;
717 }
718 return 0;
719 }
720 early_param("mem", parse_mem);
721
722 static int __init parse_memmap(char *arg)
723 {
724 if (!arg)
725 return -EINVAL;
726
727 if (strcmp(arg, "exactmap") == 0) {
728 #ifdef CONFIG_CRASH_DUMP
729 /* If we are doing a crash dump, we
730 * still need to know the real mem
731 * size before original memory map is
732 * reset.
733 */
734 find_max_pfn();
735 saved_max_pfn = max_pfn;
736 #endif
737 e820.nr_map = 0;
738 user_defined_memmap = 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 start_at, mem_size;
747
748 mem_size = memparse(arg, &arg);
749 if (*arg == '@') {
750 start_at = memparse(arg+1, &arg);
751 add_memory_region(start_at, mem_size, E820_RAM);
752 } else if (*arg == '#') {
753 start_at = memparse(arg+1, &arg);
754 add_memory_region(start_at, mem_size, E820_ACPI);
755 } else if (*arg == '$') {
756 start_at = memparse(arg+1, &arg);
757 add_memory_region(start_at, mem_size, E820_RESERVED);
758 } else {
759 limit_regions(mem_size);
760 user_defined_memmap = 1;
761 }
762 }
763 return 0;
764 }
765 early_param("memmap", parse_memmap);
766
767 #ifdef CONFIG_PROC_VMCORE
768 /* elfcorehdr= specifies the location of elf core header
769 * stored by the crashed kernel.
770 */
771 static int __init parse_elfcorehdr(char *arg)
772 {
773 if (!arg)
774 return -EINVAL;
775
776 elfcorehdr_addr = memparse(arg, &arg);
777 return 0;
778 }
779 early_param("elfcorehdr", parse_elfcorehdr);
780 #endif /* CONFIG_PROC_VMCORE */
781
782 /*
783 * highmem=size forces highmem to be exactly 'size' bytes.
784 * This works even on boxes that have no highmem otherwise.
785 * This also works to reduce highmem size on bigger boxes.
786 */
787 static int __init parse_highmem(char *arg)
788 {
789 if (!arg)
790 return -EINVAL;
791
792 highmem_pages = memparse(arg, &arg) >> PAGE_SHIFT;
793 return 0;
794 }
795 early_param("highmem", parse_highmem);
796
797 /*
798 * vmalloc=size forces the vmalloc area to be exactly 'size'
799 * bytes. This can be used to increase (or decrease) the
800 * vmalloc area - the default is 128m.
801 */
802 static int __init parse_vmalloc(char *arg)
803 {
804 if (!arg)
805 return -EINVAL;
806
807 __VMALLOC_RESERVE = memparse(arg, &arg);
808 return 0;
809 }
810 early_param("vmalloc", parse_vmalloc);
811
812 /*
813 * reservetop=size reserves a hole at the top of the kernel address space which
814 * a hypervisor can load into later. Needed for dynamically loaded hypervisors,
815 * so relocating the fixmap can be done before paging initialization.
816 */
817 static int __init parse_reservetop(char *arg)
818 {
819 unsigned long address;
820
821 if (!arg)
822 return -EINVAL;
823
824 address = memparse(arg, &arg);
825 reserve_top_address(address);
826 return 0;
827 }
828 early_param("reservetop", parse_reservetop);
829
830 /*
831 * Callback for efi_memory_walk.
832 */
833 static int __init
834 efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
835 {
836 unsigned long *max_pfn = arg, pfn;
837
838 if (start < end) {
839 pfn = PFN_UP(end -1);
840 if (pfn > *max_pfn)
841 *max_pfn = pfn;
842 }
843 return 0;
844 }
845
846 static int __init
847 efi_memory_present_wrapper(unsigned long start, unsigned long end, void *arg)
848 {
849 memory_present(0, start, end);
850 return 0;
851 }
852
853 /*
854 * This function checks if the entire range <start,end> is mapped with type.
855 *
856 * Note: this function only works correct if the e820 table is sorted and
857 * not-overlapping, which is the case
858 */
859 int __init
860 e820_all_mapped(unsigned long s, unsigned long e, unsigned type)
861 {
862 u64 start = s;
863 u64 end = e;
864 int i;
865 for (i = 0; i < e820.nr_map; i++) {
866 struct e820entry *ei = &e820.map[i];
867 if (type && ei->type != type)
868 continue;
869 /* is the region (part) in overlap with the current region ?*/
870 if (ei->addr >= end || ei->addr + ei->size <= start)
871 continue;
872 /* if the region is at the beginning of <start,end> we move
873 * start to the end of the region since it's ok until there
874 */
875 if (ei->addr <= start)
876 start = ei->addr + ei->size;
877 /* if start is now at or beyond end, we're done, full
878 * coverage */
879 if (start >= end)
880 return 1; /* we're done */
881 }
882 return 0;
883 }
884
885 /*
886 * Find the highest page frame number we have available
887 */
888 void __init find_max_pfn(void)
889 {
890 int i;
891
892 max_pfn = 0;
893 if (efi_enabled) {
894 efi_memmap_walk(efi_find_max_pfn, &max_pfn);
895 efi_memmap_walk(efi_memory_present_wrapper, NULL);
896 return;
897 }
898
899 for (i = 0; i < e820.nr_map; i++) {
900 unsigned long start, end;
901 /* RAM? */
902 if (e820.map[i].type != E820_RAM)
903 continue;
904 start = PFN_UP(e820.map[i].addr);
905 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
906 if (start >= end)
907 continue;
908 if (end > max_pfn)
909 max_pfn = end;
910 memory_present(0, start, end);
911 }
912 }
913
914 /*
915 * Determine low and high memory ranges:
916 */
917 unsigned long __init find_max_low_pfn(void)
918 {
919 unsigned long max_low_pfn;
920
921 max_low_pfn = max_pfn;
922 if (max_low_pfn > MAXMEM_PFN) {
923 if (highmem_pages == -1)
924 highmem_pages = max_pfn - MAXMEM_PFN;
925 if (highmem_pages + MAXMEM_PFN < max_pfn)
926 max_pfn = MAXMEM_PFN + highmem_pages;
927 if (highmem_pages + MAXMEM_PFN > max_pfn) {
928 printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
929 highmem_pages = 0;
930 }
931 max_low_pfn = MAXMEM_PFN;
932 #ifndef CONFIG_HIGHMEM
933 /* Maximum memory usable is what is directly addressable */
934 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
935 MAXMEM>>20);
936 if (max_pfn > MAX_NONPAE_PFN)
937 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
938 else
939 printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
940 max_pfn = MAXMEM_PFN;
941 #else /* !CONFIG_HIGHMEM */
942 #ifndef CONFIG_X86_PAE
943 if (max_pfn > MAX_NONPAE_PFN) {
944 max_pfn = MAX_NONPAE_PFN;
945 printk(KERN_WARNING "Warning only 4GB will be used.\n");
946 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
947 }
948 #endif /* !CONFIG_X86_PAE */
949 #endif /* !CONFIG_HIGHMEM */
950 } else {
951 if (highmem_pages == -1)
952 highmem_pages = 0;
953 #ifdef CONFIG_HIGHMEM
954 if (highmem_pages >= max_pfn) {
955 printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
956 highmem_pages = 0;
957 }
958 if (highmem_pages) {
959 if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
960 printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
961 highmem_pages = 0;
962 }
963 max_low_pfn -= highmem_pages;
964 }
965 #else
966 if (highmem_pages)
967 printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
968 #endif
969 }
970 return max_low_pfn;
971 }
972
973 /*
974 * Free all available memory for boot time allocation. Used
975 * as a callback function by efi_memory_walk()
976 */
977
978 static int __init
979 free_available_memory(unsigned long start, unsigned long end, void *arg)
980 {
981 /* check max_low_pfn */
982 if (start >= (max_low_pfn << PAGE_SHIFT))
983 return 0;
984 if (end >= (max_low_pfn << PAGE_SHIFT))
985 end = max_low_pfn << PAGE_SHIFT;
986 if (start < end)
987 free_bootmem(start, end - start);
988
989 return 0;
990 }
991 /*
992 * Register fully available low RAM pages with the bootmem allocator.
993 */
994 static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
995 {
996 int i;
997
998 if (efi_enabled) {
999 efi_memmap_walk(free_available_memory, NULL);
1000 return;
1001 }
1002 for (i = 0; i < e820.nr_map; i++) {
1003 unsigned long curr_pfn, last_pfn, size;
1004 /*
1005 * Reserve usable low memory
1006 */
1007 if (e820.map[i].type != E820_RAM)
1008 continue;
1009 /*
1010 * We are rounding up the start address of usable memory:
1011 */
1012 curr_pfn = PFN_UP(e820.map[i].addr);
1013 if (curr_pfn >= max_low_pfn)
1014 continue;
1015 /*
1016 * ... and at the end of the usable range downwards:
1017 */
1018 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1019
1020 if (last_pfn > max_low_pfn)
1021 last_pfn = max_low_pfn;
1022
1023 /*
1024 * .. finally, did all the rounding and playing
1025 * around just make the area go away?
1026 */
1027 if (last_pfn <= curr_pfn)
1028 continue;
1029
1030 size = last_pfn - curr_pfn;
1031 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1032 }
1033 }
1034
1035 /*
1036 * workaround for Dell systems that neglect to reserve EBDA
1037 */
1038 static void __init reserve_ebda_region(void)
1039 {
1040 unsigned int addr;
1041 addr = get_bios_ebda();
1042 if (addr)
1043 reserve_bootmem(addr, PAGE_SIZE);
1044 }
1045
1046 #ifndef CONFIG_NEED_MULTIPLE_NODES
1047 void __init setup_bootmem_allocator(void);
1048 static unsigned long __init setup_memory(void)
1049 {
1050 /*
1051 * partially used pages are not usable - thus
1052 * we are rounding upwards:
1053 */
1054 min_low_pfn = PFN_UP(init_pg_tables_end);
1055
1056 find_max_pfn();
1057
1058 max_low_pfn = find_max_low_pfn();
1059
1060 #ifdef CONFIG_HIGHMEM
1061 highstart_pfn = highend_pfn = max_pfn;
1062 if (max_pfn > max_low_pfn) {
1063 highstart_pfn = max_low_pfn;
1064 }
1065 printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1066 pages_to_mb(highend_pfn - highstart_pfn));
1067 num_physpages = highend_pfn;
1068 high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
1069 #else
1070 num_physpages = max_low_pfn;
1071 high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
1072 #endif
1073 #ifdef CONFIG_FLATMEM
1074 max_mapnr = num_physpages;
1075 #endif
1076 printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
1077 pages_to_mb(max_low_pfn));
1078
1079 setup_bootmem_allocator();
1080
1081 return max_low_pfn;
1082 }
1083
1084 void __init zone_sizes_init(void)
1085 {
1086 unsigned long max_zone_pfns[MAX_NR_ZONES];
1087 memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
1088 max_zone_pfns[ZONE_DMA] =
1089 virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
1090 max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
1091 #ifdef CONFIG_HIGHMEM
1092 max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
1093 add_active_range(0, 0, highend_pfn);
1094 #else
1095 add_active_range(0, 0, max_low_pfn);
1096 #endif
1097
1098 free_area_init_nodes(max_zone_pfns);
1099 }
1100 #else
1101 extern unsigned long __init setup_memory(void);
1102 extern void zone_sizes_init(void);
1103 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
1104
1105 void __init setup_bootmem_allocator(void)
1106 {
1107 unsigned long bootmap_size;
1108 /*
1109 * Initialize the boot-time allocator (with low memory only):
1110 */
1111 bootmap_size = init_bootmem(min_low_pfn, max_low_pfn);
1112
1113 register_bootmem_low_pages(max_low_pfn);
1114
1115 /*
1116 * Reserve the bootmem bitmap itself as well. We do this in two
1117 * steps (first step was init_bootmem()) because this catches
1118 * the (very unlikely) case of us accidentally initializing the
1119 * bootmem allocator with an invalid RAM area.
1120 */
1121 reserve_bootmem(__PHYSICAL_START, (PFN_PHYS(min_low_pfn) +
1122 bootmap_size + PAGE_SIZE-1) - (__PHYSICAL_START));
1123
1124 /*
1125 * reserve physical page 0 - it's a special BIOS page on many boxes,
1126 * enabling clean reboots, SMP operation, laptop functions.
1127 */
1128 reserve_bootmem(0, PAGE_SIZE);
1129
1130 /* reserve EBDA region, it's a 4K region */
1131 reserve_ebda_region();
1132
1133 /* could be an AMD 768MPX chipset. Reserve a page before VGA to prevent
1134 PCI prefetch into it (errata #56). Usually the page is reserved anyways,
1135 unless you have no PS/2 mouse plugged in. */
1136 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
1137 boot_cpu_data.x86 == 6)
1138 reserve_bootmem(0xa0000 - 4096, 4096);
1139
1140 #ifdef CONFIG_SMP
1141 /*
1142 * But first pinch a few for the stack/trampoline stuff
1143 * FIXME: Don't need the extra page at 4K, but need to fix
1144 * trampoline before removing it. (see the GDT stuff)
1145 */
1146 reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
1147 #endif
1148 #ifdef CONFIG_ACPI_SLEEP
1149 /*
1150 * Reserve low memory region for sleep support.
1151 */
1152 acpi_reserve_bootmem();
1153 #endif
1154 #ifdef CONFIG_X86_FIND_SMP_CONFIG
1155 /*
1156 * Find and reserve possible boot-time SMP configuration:
1157 */
1158 find_smp_config();
1159 #endif
1160 numa_kva_reserve();
1161 #ifdef CONFIG_BLK_DEV_INITRD
1162 if (LOADER_TYPE && INITRD_START) {
1163 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
1164 reserve_bootmem(INITRD_START, INITRD_SIZE);
1165 initrd_start =
1166 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
1167 initrd_end = initrd_start+INITRD_SIZE;
1168 }
1169 else {
1170 printk(KERN_ERR "initrd extends beyond end of memory "
1171 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
1172 INITRD_START + INITRD_SIZE,
1173 max_low_pfn << PAGE_SHIFT);
1174 initrd_start = 0;
1175 }
1176 }
1177 #endif
1178 #ifdef CONFIG_KEXEC
1179 if (crashk_res.start != crashk_res.end)
1180 reserve_bootmem(crashk_res.start,
1181 crashk_res.end - crashk_res.start + 1);
1182 #endif
1183 }
1184
1185 /*
1186 * The node 0 pgdat is initialized before all of these because
1187 * it's needed for bootmem. node>0 pgdats have their virtual
1188 * space allocated before the pagetables are in place to access
1189 * them, so they can't be cleared then.
1190 *
1191 * This should all compile down to nothing when NUMA is off.
1192 */
1193 void __init remapped_pgdat_init(void)
1194 {
1195 int nid;
1196
1197 for_each_online_node(nid) {
1198 if (nid != 0)
1199 memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
1200 }
1201 }
1202
1203 /*
1204 * Request address space for all standard RAM and ROM resources
1205 * and also for regions reported as reserved by the e820.
1206 */
1207 static void __init
1208 legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
1209 {
1210 int i;
1211
1212 probe_roms();
1213 for (i = 0; i < e820.nr_map; i++) {
1214 struct resource *res;
1215 #ifndef CONFIG_RESOURCES_64BIT
1216 if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
1217 continue;
1218 #endif
1219 res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
1220 switch (e820.map[i].type) {
1221 case E820_RAM: res->name = "System RAM"; break;
1222 case E820_ACPI: res->name = "ACPI Tables"; break;
1223 case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
1224 default: res->name = "reserved";
1225 }
1226 res->start = e820.map[i].addr;
1227 res->end = res->start + e820.map[i].size - 1;
1228 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
1229 if (request_resource(&iomem_resource, res)) {
1230 kfree(res);
1231 continue;
1232 }
1233 if (e820.map[i].type == E820_RAM) {
1234 /*
1235 * We don't know which RAM region contains kernel data,
1236 * so we try it repeatedly and let the resource manager
1237 * test it.
1238 */
1239 request_resource(res, code_resource);
1240 request_resource(res, data_resource);
1241 #ifdef CONFIG_KEXEC
1242 request_resource(res, &crashk_res);
1243 #endif
1244 }
1245 }
1246 }
1247
1248 /*
1249 * Request address space for all standard resources
1250 *
1251 * This is called just before pcibios_init(), which is also a
1252 * subsys_initcall, but is linked in later (in arch/i386/pci/common.c).
1253 */
1254 static int __init request_standard_resources(void)
1255 {
1256 int i;
1257
1258 printk("Setting up standard PCI resources\n");
1259 if (efi_enabled)
1260 efi_initialize_iomem_resources(&code_resource, &data_resource);
1261 else
1262 legacy_init_iomem_resources(&code_resource, &data_resource);
1263
1264 /* EFI systems may still have VGA */
1265 request_resource(&iomem_resource, &video_ram_resource);
1266
1267 /* request I/O space for devices used on all i[345]86 PCs */
1268 for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
1269 request_resource(&ioport_resource, &standard_io_resources[i]);
1270 return 0;
1271 }
1272
1273 subsys_initcall(request_standard_resources);
1274
1275 static void __init register_memory(void)
1276 {
1277 unsigned long gapstart, gapsize, round;
1278 unsigned long long last;
1279 int i;
1280
1281 /*
1282 * Search for the bigest gap in the low 32 bits of the e820
1283 * memory space.
1284 */
1285 last = 0x100000000ull;
1286 gapstart = 0x10000000;
1287 gapsize = 0x400000;
1288 i = e820.nr_map;
1289 while (--i >= 0) {
1290 unsigned long long start = e820.map[i].addr;
1291 unsigned long long end = start + e820.map[i].size;
1292
1293 /*
1294 * Since "last" is at most 4GB, we know we'll
1295 * fit in 32 bits if this condition is true
1296 */
1297 if (last > end) {
1298 unsigned long gap = last - end;
1299
1300 if (gap > gapsize) {
1301 gapsize = gap;
1302 gapstart = end;
1303 }
1304 }
1305 if (start < last)
1306 last = start;
1307 }
1308
1309 /*
1310 * See how much we want to round up: start off with
1311 * rounding to the next 1MB area.
1312 */
1313 round = 0x100000;
1314 while ((gapsize >> 4) > round)
1315 round += round;
1316 /* Fun with two's complement */
1317 pci_mem_start = (gapstart + round) & -round;
1318
1319 printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
1320 pci_mem_start, gapstart, gapsize);
1321 }
1322
1323 #ifdef CONFIG_MCA
1324 static void set_mca_bus(int x)
1325 {
1326 MCA_bus = x;
1327 }
1328 #else
1329 static void set_mca_bus(int x) { }
1330 #endif
1331
1332 /*
1333 * Determine if we were loaded by an EFI loader. If so, then we have also been
1334 * passed the efi memmap, systab, etc., so we should use these data structures
1335 * for initialization. Note, the efi init code path is determined by the
1336 * global efi_enabled. This allows the same kernel image to be used on existing
1337 * systems (with a traditional BIOS) as well as on EFI systems.
1338 */
1339 void __init setup_arch(char **cmdline_p)
1340 {
1341 unsigned long max_low_pfn;
1342
1343 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
1344 pre_setup_arch_hook();
1345 early_cpu_init();
1346
1347 /*
1348 * FIXME: This isn't an official loader_type right
1349 * now but does currently work with elilo.
1350 * If we were configured as an EFI kernel, check to make
1351 * sure that we were loaded correctly from elilo and that
1352 * the system table is valid. If not, then initialize normally.
1353 */
1354 #ifdef CONFIG_EFI
1355 if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
1356 efi_enabled = 1;
1357 #endif
1358
1359 ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
1360 drive_info = DRIVE_INFO;
1361 screen_info = SCREEN_INFO;
1362 edid_info = EDID_INFO;
1363 apm_info.bios = APM_BIOS_INFO;
1364 ist_info = IST_INFO;
1365 saved_videomode = VIDEO_MODE;
1366 if( SYS_DESC_TABLE.length != 0 ) {
1367 set_mca_bus(SYS_DESC_TABLE.table[3] & 0x2);
1368 machine_id = SYS_DESC_TABLE.table[0];
1369 machine_submodel_id = SYS_DESC_TABLE.table[1];
1370 BIOS_revision = SYS_DESC_TABLE.table[2];
1371 }
1372 bootloader_type = LOADER_TYPE;
1373
1374 #ifdef CONFIG_BLK_DEV_RAM
1375 rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
1376 rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
1377 rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
1378 #endif
1379 ARCH_SETUP
1380 if (efi_enabled)
1381 efi_init();
1382 else {
1383 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
1384 print_memory_map(machine_specific_memory_setup());
1385 }
1386
1387 copy_edd();
1388
1389 if (!MOUNT_ROOT_RDONLY)
1390 root_mountflags &= ~MS_RDONLY;
1391 init_mm.start_code = (unsigned long) _text;
1392 init_mm.end_code = (unsigned long) _etext;
1393 init_mm.end_data = (unsigned long) _edata;
1394 init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
1395
1396 code_resource.start = virt_to_phys(_text);
1397 code_resource.end = virt_to_phys(_etext)-1;
1398 data_resource.start = virt_to_phys(_etext);
1399 data_resource.end = virt_to_phys(_edata)-1;
1400
1401 parse_early_param();
1402
1403 if (user_defined_memmap) {
1404 printk(KERN_INFO "user-defined physical RAM map:\n");
1405 print_memory_map("user");
1406 }
1407
1408 strlcpy(command_line, saved_command_line, COMMAND_LINE_SIZE);
1409 *cmdline_p = command_line;
1410
1411 max_low_pfn = setup_memory();
1412
1413 /*
1414 * NOTE: before this point _nobody_ is allowed to allocate
1415 * any memory using the bootmem allocator. Although the
1416 * alloctor is now initialised only the first 8Mb of the kernel
1417 * virtual address space has been mapped. All allocations before
1418 * paging_init() has completed must use the alloc_bootmem_low_pages()
1419 * variant (which allocates DMA'able memory) and care must be taken
1420 * not to exceed the 8Mb limit.
1421 */
1422
1423 #ifdef CONFIG_SMP
1424 smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
1425 #endif
1426 paging_init();
1427 remapped_pgdat_init();
1428 sparse_init();
1429 zone_sizes_init();
1430
1431 /*
1432 * NOTE: at this point the bootmem allocator is fully available.
1433 */
1434
1435 dmi_scan_machine();
1436
1437 #ifdef CONFIG_X86_GENERICARCH
1438 generic_apic_probe();
1439 #endif
1440 if (efi_enabled)
1441 efi_map_memmap();
1442
1443 #ifdef CONFIG_ACPI
1444 /*
1445 * Parse the ACPI tables for possible boot-time SMP configuration.
1446 */
1447 acpi_boot_table_init();
1448 #endif
1449
1450 #ifdef CONFIG_PCI
1451 #ifdef CONFIG_X86_IO_APIC
1452 check_acpi_pci(); /* Checks more than just ACPI actually */
1453 #endif
1454 #endif
1455
1456 #ifdef CONFIG_ACPI
1457 acpi_boot_init();
1458
1459 #if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
1460 if (def_to_bigsmp)
1461 printk(KERN_WARNING "More than 8 CPUs detected and "
1462 "CONFIG_X86_PC cannot handle it.\nUse "
1463 "CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
1464 #endif
1465 #endif
1466 #ifdef CONFIG_X86_LOCAL_APIC
1467 if (smp_found_config)
1468 get_smp_config();
1469 #endif
1470
1471 register_memory();
1472
1473 #ifdef CONFIG_VT
1474 #if defined(CONFIG_VGA_CONSOLE)
1475 if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1476 conswitchp = &vga_con;
1477 #elif defined(CONFIG_DUMMY_CONSOLE)
1478 conswitchp = &dummy_con;
1479 #endif
1480 #endif
1481 tsc_init();
1482 }
1483
1484 static __init int add_pcspkr(void)
1485 {
1486 struct platform_device *pd;
1487 int ret;
1488
1489 pd = platform_device_alloc("pcspkr", -1);
1490 if (!pd)
1491 return -ENOMEM;
1492
1493 ret = platform_device_add(pd);
1494 if (ret)
1495 platform_device_put(pd);
1496
1497 return ret;
1498 }
1499 device_initcall(add_pcspkr);
1500
1501 /*
1502 * Local Variables:
1503 * mode:c
1504 * c-file-style:"k&r"
1505 * c-basic-offset:8
1506 * End:
1507 */
Support for the Chinese Samsung S3C2440 based development boards