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