[PATCH] mm: use symbolic names instead of indices for zone initialisation
[sfrench/cifs-2.6.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 /* 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  */