1 files changed, 328 insertions, 228 deletions

diff --git a/arch/x86/kernel/setup_32.c b/arch/x86/kernel/setup_32.c
index 5a2f8e063887..7e06ecd83174 100644
--- a/arch/x86/kernel/setup_32.c
+++ b/arch/x86/kernel/setup_32.c
@@ -59,6 +59,7 @@
 #include <asm/setup.h>
 #include <asm/arch_hooks.h>
 #include <asm/sections.h>
+#include <asm/dmi.h>
 #include <asm/io_apic.h>
 #include <asm/ist.h>
 #include <asm/io.h>
@@ -67,10 +68,13 @@
 #include <asm/bios_ebda.h>
 #include <asm/cacheflush.h>
 #include <asm/processor.h>
+#include <asm/efi.h>
+#include <asm/bugs.h>
 
 /* This value is set up by the early boot code to point to the value
    immediately after the boot time page tables.  It contains a *physical*
    address, and must not be in the .bss segment! */
+unsigned long init_pg_tables_start __initdata = ~0UL;
 unsigned long init_pg_tables_end __initdata = ~0UL;
 
 /*
@@ -182,6 +186,12 @@ int bootloader_type;
 static unsigned int highmem_pages = -1;
 
 /*
+ * Early DMI memory
+ */
+int dmi_alloc_index;
+char dmi_alloc_data[DMI_MAX_DATA];
+
+/*
  * Setup options
  */
 struct screen_info screen_info;
@@ -237,42 +247,6 @@ static inline void copy_edd(void)
 }
 #endif
 
-int __initdata user_defined_memmap;
-
-/*
- * "mem=nopentium" disables the 4MB page tables.
- * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
- * to <mem>, overriding the bios size.
- * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
- * <start> to <start>+<mem>, overriding the bios size.
- *
- * HPA tells me bootloaders need to parse mem=, so no new
- * option should be mem=  [also see Documentation/i386/boot.txt]
- */
-static int __init parse_mem(char *arg)
-{
-        if (!arg)
-                return -EINVAL;
-
-        if (strcmp(arg, "nopentium") == 0) {
-                setup_clear_cpu_cap(X86_FEATURE_PSE);
-        } else {
-                /* If the user specifies memory size, we
-                 * limit the BIOS-provided memory map to
-                 * that size. exactmap can be used to specify
-                 * the exact map. mem=number can be used to
-                 * trim the existing memory map.
-                 */
-                unsigned long long mem_size;
-
-                mem_size = memparse(arg, &arg);
-                limit_regions(mem_size);
-                user_defined_memmap = 1;
-        }
-        return 0;
-}
-early_param("mem", parse_mem);
-
 #ifdef CONFIG_PROC_VMCORE
 /* elfcorehdr= specifies the location of elf core header
  * stored by the crashed kernel.
@@ -395,56 +369,6 @@ unsigned long __init find_max_low_pfn(void)
         return max_low_pfn;
 }
 
-#define BIOS_LOWMEM_KILOBYTES 0x413
-
-/*
- * The BIOS places the EBDA/XBDA at the top of conventional
- * memory, and usually decreases the reported amount of
- * conventional memory (int 0x12) too. This also contains a
- * workaround for Dell systems that neglect to reserve EBDA.
- * The same workaround also avoids a problem with the AMD768MPX
- * chipset: reserve a page before VGA to prevent PCI prefetch
- * into it (errata #56). Usually the page is reserved anyways,
- * unless you have no PS/2 mouse plugged in.
- */
-static void __init reserve_ebda_region(void)
-{
-        unsigned int lowmem, ebda_addr;
-
-        /* To determine the position of the EBDA and the */
-        /* end of conventional memory, we need to look at */
-        /* the BIOS data area. In a paravirtual environment */
-        /* that area is absent. We'll just have to assume */
-        /* that the paravirt case can handle memory setup */
-        /* correctly, without our help. */
-        if (paravirt_enabled())
-                return;
-
-        /* end of low (conventional) memory */
-        lowmem = *(unsigned short *)__va(BIOS_LOWMEM_KILOBYTES);
-        lowmem <<= 10;
-
-        /* start of EBDA area */
-        ebda_addr = get_bios_ebda();
-
-        /* Fixup: bios puts an EBDA in the top 64K segment */
-        /* of conventional memory, but does not adjust lowmem. */
-        if ((lowmem - ebda_addr) <= 0x10000)
-                lowmem = ebda_addr;
-
-        /* Fixup: bios does not report an EBDA at all. */
-        /* Some old Dells seem to need 4k anyhow (bugzilla 2990) */
-        if ((ebda_addr == 0) && (lowmem >= 0x9f000))
-                lowmem = 0x9f000;
-
-        /* Paranoia: should never happen, but... */
-        if ((lowmem == 0) || (lowmem >= 0x100000))
-                lowmem = 0x9f000;
-
-        /* reserve all memory between lowmem and the 1MB mark */
-        reserve_bootmem(lowmem, 0x100000 - lowmem, BOOTMEM_DEFAULT);
-}
-
 #ifndef CONFIG_NEED_MULTIPLE_NODES
 static void __init setup_bootmem_allocator(void);
 static unsigned long __init setup_memory(void)
@@ -462,11 +386,13 @@ static unsigned long __init setup_memory(void)
         if (max_pfn > max_low_pfn) {
                 highstart_pfn = max_low_pfn;
         }
+        memory_present(0, 0, highend_pfn);
         printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
                 pages_to_mb(highend_pfn - highstart_pfn));
         num_physpages = highend_pfn;
         high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
 #else
+        memory_present(0, 0, max_low_pfn);
         num_physpages = max_low_pfn;
         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
 #endif
@@ -488,11 +414,12 @@ static void __init zone_sizes_init(void)
         max_zone_pfns[ZONE_DMA] =
                 virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
         max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
+        remove_all_active_ranges();
 #ifdef CONFIG_HIGHMEM
         max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
-        add_active_range(0, 0, highend_pfn);
+        e820_register_active_regions(0, 0, highend_pfn);
 #else
-        add_active_range(0, 0, max_low_pfn);
+        e820_register_active_regions(0, 0, max_low_pfn);
 #endif
 
         free_area_init_nodes(max_zone_pfns);
@@ -526,25 +453,28 @@ static void __init reserve_crashkernel(void)
         ret = parse_crashkernel(boot_command_line, total_mem,
                         &crash_size, &crash_base);
         if (ret == 0 && crash_size > 0) {
-                if (crash_base > 0) {
-                        printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
-                                        "for crashkernel (System RAM: %ldMB)\n",
-                                        (unsigned long)(crash_size >> 20),
-                                        (unsigned long)(crash_base >> 20),
-                                        (unsigned long)(total_mem >> 20));
-
-                        if (reserve_bootmem(crash_base, crash_size,
-                                        BOOTMEM_EXCLUSIVE) < 0) {
-                                printk(KERN_INFO "crashkernel reservation "
-                                        "failed - memory is in use\n");
-                                return;
-                        }
-
-                        crashk_res.start = crash_base;
-                        crashk_res.end   = crash_base + crash_size - 1;
-                } else
+                if (crash_base <= 0) {
                         printk(KERN_INFO "crashkernel reservation failed - "
                                         "you have to specify a base address\n");
+                        return;
+                }
+
+                if (reserve_bootmem_generic(crash_base, crash_size,
+                                        BOOTMEM_EXCLUSIVE) < 0) {
+                        printk(KERN_INFO "crashkernel reservation failed - "
+                                        "memory is in use\n");
+                        return;
+                }
+
+                printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
+                                "for crashkernel (System RAM: %ldMB)\n",
+                                (unsigned long)(crash_size >> 20),
+                                (unsigned long)(crash_base >> 20),
+                                (unsigned long)(total_mem >> 20));
+
+                crashk_res.start = crash_base;
+                crashk_res.end   = crash_base + crash_size - 1;
+                insert_resource(&iomem_resource, &crashk_res);
         }
 }
 #else
@@ -558,44 +488,57 @@ static bool do_relocate_initrd = false;
 
 static void __init reserve_initrd(void)
 {
-        unsigned long ramdisk_image = boot_params.hdr.ramdisk_image;
-        unsigned long ramdisk_size  = boot_params.hdr.ramdisk_size;
-        unsigned long ramdisk_end   = ramdisk_image + ramdisk_size;
-        unsigned long end_of_lowmem = max_low_pfn << PAGE_SHIFT;
-        unsigned long ramdisk_here;
-
-        initrd_start = 0;
+        u64 ramdisk_image = boot_params.hdr.ramdisk_image;
+        u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
+        u64 ramdisk_end   = ramdisk_image + ramdisk_size;
+        u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
+        u64 ramdisk_here;
 
         if (!boot_params.hdr.type_of_loader ||
             !ramdisk_image || !ramdisk_size)
                 return;         /* No initrd provided by bootloader */
 
-        if (ramdisk_end < ramdisk_image) {
-                printk(KERN_ERR "initrd wraps around end of memory, "
-                       "disabling initrd\n");
-                return;
-        }
+        initrd_start = 0;
+
         if (ramdisk_size >= end_of_lowmem/2) {
+                free_early(ramdisk_image, ramdisk_end);
                 printk(KERN_ERR "initrd too large to handle, "
                        "disabling initrd\n");
                 return;
         }
+
+        printk(KERN_INFO "old RAMDISK: %08llx - %08llx\n", ramdisk_image,
+                        ramdisk_end);
+
+
         if (ramdisk_end <= end_of_lowmem) {
                 /* All in lowmem, easy case */
-                reserve_bootmem(ramdisk_image, ramdisk_size, BOOTMEM_DEFAULT);
+                /*
+                 * don't need to reserve again, already reserved early
+                 * in i386_start_kernel
+                 */
                 initrd_start = ramdisk_image + PAGE_OFFSET;
                 initrd_end = initrd_start+ramdisk_size;
                 return;
         }
 
         /* We need to move the initrd down into lowmem */
-        ramdisk_here = (end_of_lowmem - ramdisk_size) & PAGE_MASK;
+        ramdisk_here = find_e820_area(min_low_pfn<<PAGE_SHIFT,
+                                 end_of_lowmem, ramdisk_size,
+                                 PAGE_SIZE);
+
+        if (ramdisk_here == -1ULL)
+                panic("Cannot find place for new RAMDISK of size %lld\n",
+                         ramdisk_size);
 
         /* Note: this includes all the lowmem currently occupied by
            the initrd, we rely on that fact to keep the data intact. */
-        reserve_bootmem(ramdisk_here, ramdisk_size, BOOTMEM_DEFAULT);
+        reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
+                         "NEW RAMDISK");
         initrd_start = ramdisk_here + PAGE_OFFSET;
         initrd_end   = initrd_start + ramdisk_size;
+        printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
+                         ramdisk_here, ramdisk_here + ramdisk_size);
 
         do_relocate_initrd = true;
 }
@@ -604,10 +547,10 @@ static void __init reserve_initrd(void)
 
 static void __init relocate_initrd(void)
 {
-        unsigned long ramdisk_image = boot_params.hdr.ramdisk_image;
-        unsigned long ramdisk_size  = boot_params.hdr.ramdisk_size;
-        unsigned long end_of_lowmem = max_low_pfn << PAGE_SHIFT;
-        unsigned long ramdisk_here;
+        u64 ramdisk_image = boot_params.hdr.ramdisk_image;
+        u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
+        u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
+        u64 ramdisk_here;
         unsigned long slop, clen, mapaddr;
         char *p, *q;
 
@@ -624,6 +567,10 @@ static void __init relocate_initrd(void)
                 p = (char *)__va(ramdisk_image);
                 memcpy(q, p, clen);
                 q += clen;
+                /* need to free these low pages...*/
+                printk(KERN_INFO "Freeing old partial RAMDISK %08llx-%08llx\n",
+                         ramdisk_image, ramdisk_image + clen - 1);
+                free_bootmem(ramdisk_image, clen);
                 ramdisk_image += clen;
                 ramdisk_size  -= clen;
         }
@@ -642,66 +589,47 @@ static void __init relocate_initrd(void)
                 ramdisk_image += clen;
                 ramdisk_size  -= clen;
         }
+        /* high pages is not converted by early_res_to_bootmem */
+        ramdisk_image = boot_params.hdr.ramdisk_image;
+        ramdisk_size  = boot_params.hdr.ramdisk_size;
+        printk(KERN_INFO "Copied RAMDISK from %016llx - %016llx to %08llx - %08llx\n",
+                ramdisk_image, ramdisk_image + ramdisk_size - 1,
+                ramdisk_here, ramdisk_here + ramdisk_size - 1);
+
+        /* need to free that, otherwise init highmem will reserve it again */
+        free_early(ramdisk_image, ramdisk_image+ramdisk_size);
 }
 
 #endif /* CONFIG_BLK_DEV_INITRD */
 
 void __init setup_bootmem_allocator(void)
 {
-        unsigned long bootmap_size;
+        int i;
+        unsigned long bootmap_size, bootmap;
         /*
          * Initialize the boot-time allocator (with low memory only):
          */
-        bootmap_size = init_bootmem(min_low_pfn, max_low_pfn);
-
-        register_bootmem_low_pages(max_low_pfn);
-
-        /*
-         * Reserve the bootmem bitmap itself as well. We do this in two
-         * steps (first step was init_bootmem()) because this catches
-         * the (very unlikely) case of us accidentally initializing the
-         * bootmem allocator with an invalid RAM area.
-         */
-        reserve_bootmem(__pa_symbol(_text), (PFN_PHYS(min_low_pfn) +
-                         bootmap_size + PAGE_SIZE-1) - __pa_symbol(_text),
-                         BOOTMEM_DEFAULT);
-
-        /*
-         * reserve physical page 0 - it's a special BIOS page on many boxes,
-         * enabling clean reboots, SMP operation, laptop functions.
-         */
-        reserve_bootmem(0, PAGE_SIZE, BOOTMEM_DEFAULT);
-
-        /* reserve EBDA region */
-        reserve_ebda_region();
-
-#ifdef CONFIG_SMP
-        /*
-         * But first pinch a few for the stack/trampoline stuff
-         * FIXME: Don't need the extra page at 4K, but need to fix
-         * trampoline before removing it. (see the GDT stuff)
-         */
-        reserve_bootmem(PAGE_SIZE, PAGE_SIZE, BOOTMEM_DEFAULT);
-#endif
-#ifdef CONFIG_ACPI_SLEEP
-        /*
-         * Reserve low memory region for sleep support.
-         */
-        acpi_reserve_bootmem();
-#endif
-#ifdef CONFIG_X86_FIND_SMP_CONFIG
-        /*
-         * Find and reserve possible boot-time SMP configuration:
-         */
-        find_smp_config();
-#endif
+        bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT;
+        bootmap = find_e820_area(min_low_pfn<<PAGE_SHIFT,
+                                 max_pfn_mapped<<PAGE_SHIFT, bootmap_size,
+                                 PAGE_SIZE);
+        if (bootmap == -1L)
+                panic("Cannot find bootmem map of size %ld\n", bootmap_size);
+        reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP");
 #ifdef CONFIG_BLK_DEV_INITRD
         reserve_initrd();
 #endif
-        numa_kva_reserve();
-        reserve_crashkernel();
+        bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, max_low_pfn);
+        printk(KERN_INFO "  mapped low ram: 0 - %08lx\n",
+                 max_pfn_mapped<<PAGE_SHIFT);
+        printk(KERN_INFO "  low ram: %08lx - %08lx\n",
+                 min_low_pfn<<PAGE_SHIFT, max_low_pfn<<PAGE_SHIFT);
+        printk(KERN_INFO "  bootmap %08lx - %08lx\n",
+                 bootmap, bootmap + bootmap_size);
+        for_each_online_node(i)
+                free_bootmem_with_active_regions(i, max_low_pfn);
+        early_res_to_bootmem(0, max_low_pfn<<PAGE_SHIFT);
 
-        reserve_ibft_region();
 }
 
 /*
@@ -731,12 +659,6 @@ static void set_mca_bus(int x)
 static void set_mca_bus(int x) { }
 #endif
 
-/* Overridden in paravirt.c if CONFIG_PARAVIRT */
-char * __init __attribute__((weak)) memory_setup(void)
-{
-        return machine_specific_memory_setup();
-}
-
 #ifdef CONFIG_NUMA
 /*
  * In the golden day, when everything among i386 and x86_64 will be
@@ -749,6 +671,8 @@ int x86_cpu_to_node_map_init[NR_CPUS] = {
 DEFINE_PER_CPU(int, x86_cpu_to_node_map) = NUMA_NO_NODE;
 #endif
 
+static void probe_roms(void);
+
 /*
  * Determine if we were loaded by an EFI loader.  If so, then we have also been
  * passed the efi memmap, systab, etc., so we should use these data structures
@@ -758,17 +682,21 @@ DEFINE_PER_CPU(int, x86_cpu_to_node_map) = NUMA_NO_NODE;
  */
 void __init setup_arch(char **cmdline_p)
 {
+        int i;
         unsigned long max_low_pfn;
 
         memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
         pre_setup_arch_hook();
         early_cpu_init();
         early_ioremap_init();
+        reserve_setup_data();
 
 #ifdef CONFIG_EFI
         if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
-                     "EL32", 4))
+                     "EL32", 4)) {
                 efi_enabled = 1;
+                efi_reserve_early();
+        }
 #endif
 
         ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
@@ -792,8 +720,7 @@ void __init setup_arch(char **cmdline_p)
 #endif
         ARCH_SETUP
 
-        printk(KERN_INFO "BIOS-provided physical RAM map:\n");
-        print_memory_map(memory_setup());
+        setup_memory_map();
 
         copy_edd();
 
@@ -811,12 +738,18 @@ void __init setup_arch(char **cmdline_p)
         bss_resource.start = virt_to_phys(&__bss_start);
         bss_resource.end = virt_to_phys(&__bss_stop)-1;
 
+        parse_setup_data();
+
         parse_early_param();
 
-        if (user_defined_memmap) {
-                printk(KERN_INFO "user-defined physical RAM map:\n");
-                print_memory_map("user");
-        }
+        finish_e820_parsing();
+
+        probe_roms();
+
+        /* after parse_early_param, so could debug it */
+        insert_resource(&iomem_resource, &code_resource);
+        insert_resource(&iomem_resource, &data_resource);
+        insert_resource(&iomem_resource, &bss_resource);
 
         strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
         *cmdline_p = command_line;
@@ -824,14 +757,67 @@ void __init setup_arch(char **cmdline_p)
         if (efi_enabled)
                 efi_init();
 
+        if (ppro_with_ram_bug()) {
+                e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
+                                  E820_RESERVED);
+                sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
+                printk(KERN_INFO "fixed physical RAM map:\n");
+                e820_print_map("bad_ppro");
+        }
+
+        e820_register_active_regions(0, 0, -1UL);
+        /*
+         * partially used pages are not usable - thus
+         * we are rounding upwards:
+         */
+        max_pfn = e820_end_of_ram();
+
+        /* preallocate 4k for mptable mpc */
+        early_reserve_e820_mpc_new();
         /* update e820 for memory not covered by WB MTRRs */
-        propagate_e820_map();
         mtrr_bp_init();
-        if (mtrr_trim_uncached_memory(max_pfn))
-                propagate_e820_map();
+        if (mtrr_trim_uncached_memory(max_pfn)) {
+                remove_all_active_ranges();
+                e820_register_active_regions(0, 0, -1UL);
+                max_pfn = e820_end_of_ram();
+        }
+
+        dmi_scan_machine();
+
+        io_delay_init();
+
+#ifdef CONFIG_ACPI
+        /*
+         * Parse the ACPI tables for possible boot-time SMP configuration.
+         */
+        acpi_boot_table_init();
+#endif
+
+#ifdef CONFIG_ACPI_NUMA
+        /*
+         * Parse SRAT to discover nodes.
+         */
+        acpi_numa_init();
+#endif
 
         max_low_pfn = setup_memory();
 
+#ifdef CONFIG_ACPI_SLEEP
+        /*
+         * Reserve low memory region for sleep support.
+         */
+        acpi_reserve_bootmem();
+#endif
+#ifdef CONFIG_X86_FIND_SMP_CONFIG
+        /*
+         * Find and reserve possible boot-time SMP configuration:
+         */
+        find_smp_config();
+#endif
+        reserve_crashkernel();
+
+        reserve_ibft_region();
+
 #ifdef CONFIG_KVM_CLOCK
         kvmclock_init();
 #endif
@@ -855,9 +841,6 @@ void __init setup_arch(char **cmdline_p)
          * not to exceed the 8Mb limit.
          */
 
-#ifdef CONFIG_SMP
-        smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
-#endif
         paging_init();
 
         /*
@@ -869,10 +852,6 @@ void __init setup_arch(char **cmdline_p)
                 init_ohci1394_dma_on_all_controllers();
 #endif
 
-        remapped_pgdat_init();
-        sparse_init();
-        zone_sizes_init();
-
         /*
          * NOTE: at this point the bootmem allocator is fully available.
          */
@@ -881,11 +860,11 @@ void __init setup_arch(char **cmdline_p)
         relocate_initrd();
 #endif
 
-        paravirt_post_allocator_init();
-
-        dmi_scan_machine();
+        remapped_pgdat_init();
+        sparse_init();
+        zone_sizes_init();
 
-        io_delay_init();
+        paravirt_post_allocator_init();
 
 #ifdef CONFIG_X86_SMP
         /*
@@ -903,32 +882,31 @@ void __init setup_arch(char **cmdline_p)
         generic_apic_probe();
 #endif
 
-#ifdef CONFIG_ACPI
-        /*
-         * Parse the ACPI tables for possible boot-time SMP configuration.
-         */
-        acpi_boot_table_init();
-#endif
-
         early_quirks();
 
 #ifdef CONFIG_ACPI
         acpi_boot_init();
-
+#endif
+#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
+        if (smp_found_config)
+                get_smp_config();
+#endif
 #if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
         if (def_to_bigsmp)
                 printk(KERN_WARNING "More than 8 CPUs detected and "
                         "CONFIG_X86_PC cannot handle it.\nUse "
                         "CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
 #endif
-#endif
-#ifdef CONFIG_X86_LOCAL_APIC
-        if (smp_found_config)
-                get_smp_config();
-#endif
 
-        e820_register_memory();
-        e820_mark_nosave_regions();
+        e820_reserve_resources();
+        e820_mark_nosave_regions(max_low_pfn);
+
+        request_resource(&iomem_resource, &video_ram_resource);
+        /* request I/O space for devices used on all i[345]86 PCs */
+        for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
+                request_resource(&ioport_resource, &standard_io_resources[i]);
+
+        e820_setup_gap();
 
 #ifdef CONFIG_VT
 #if defined(CONFIG_VGA_CONSOLE)
@@ -940,25 +918,147 @@ void __init setup_arch(char **cmdline_p)
 #endif
 }
 
-/*
- * Request address space for all standard resources
- *
- * This is called just before pcibios_init(), which is also a
- * subsys_initcall, but is linked in later (in arch/i386/pci/common.c).
- */
-static int __init request_standard_resources(void)
+static struct resource system_rom_resource = {
+        .name   = "System ROM",
+        .start  = 0xf0000,
+        .end    = 0xfffff,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+};
+
+static struct resource extension_rom_resource = {
+        .name   = "Extension ROM",
+        .start  = 0xe0000,
+        .end    = 0xeffff,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+};
+
+static struct resource adapter_rom_resources[] = { {
+        .name   = "Adapter ROM",
+        .start  = 0xc8000,
+        .end    = 0,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+}, {
+        .name   = "Adapter ROM",
+        .start  = 0,
+        .end    = 0,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+}, {
+        .name   = "Adapter ROM",
+        .start  = 0,
+        .end    = 0,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+}, {
+        .name   = "Adapter ROM",
+        .start  = 0,
+        .end    = 0,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+}, {
+        .name   = "Adapter ROM",
+        .start  = 0,
+        .end    = 0,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+}, {
+        .name   = "Adapter ROM",
+        .start  = 0,
+        .end    = 0,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+} };
+
+static struct resource video_rom_resource = {
+        .name   = "Video ROM",
+        .start  = 0xc0000,
+        .end    = 0xc7fff,
+        .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
+};
+
+#define ROMSIGNATURE 0xaa55
+
+static int __init romsignature(const unsigned char *rom)
 {
+        const unsigned short * const ptr = (const unsigned short *)rom;
+        unsigned short sig;
+
+        return probe_kernel_address(ptr, sig) == 0 && sig == ROMSIGNATURE;
+}
+
+static int __init romchecksum(const unsigned char *rom, unsigned long length)
+{
+        unsigned char sum, c;
+
+        for (sum = 0; length && probe_kernel_address(rom++, c) == 0; length--)
+                sum += c;
+        return !length && !sum;
+}
+
+static void __init probe_roms(void)
+{
+        const unsigned char *rom;
+        unsigned long start, length, upper;
+        unsigned char c;
         int i;
 
-        printk(KERN_INFO "Setting up standard PCI resources\n");
-        init_iomem_resources(&code_resource, &data_resource, &bss_resource);
+        /* video rom */
+        upper = adapter_rom_resources[0].start;
+        for (start = video_rom_resource.start; start < upper; start += 2048) {
+                rom = isa_bus_to_virt(start);
+                if (!romsignature(rom))
+                        continue;
 
-        request_resource(&iomem_resource, &video_ram_resource);
+                video_rom_resource.start = start;
 
-        /* request I/O space for devices used on all i[345]86 PCs */
-        for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
-                request_resource(&ioport_resource, &standard_io_resources[i]);
-        return 0;
+                if (probe_kernel_address(rom + 2, c) != 0)
+                        continue;
+
+                /* 0 < length <= 0x7f * 512, historically */
+                length = c * 512;
+
+                /* if checksum okay, trust length byte */
+                if (length && romchecksum(rom, length))
+                        video_rom_resource.end = start + length - 1;
+
+                request_resource(&iomem_resource, &video_rom_resource);
+                break;
+        }
+
+        start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
+        if (start < upper)
+                start = upper;
+
+        /* system rom */
+        request_resource(&iomem_resource, &system_rom_resource);
+        upper = system_rom_resource.start;
+
+        /* check for extension rom (ignore length byte!) */
+        rom = isa_bus_to_virt(extension_rom_resource.start);
+        if (romsignature(rom)) {
+                length = extension_rom_resource.end - extension_rom_resource.start + 1;
+                if (romchecksum(rom, length)) {
+                        request_resource(&iomem_resource, &extension_rom_resource);
+                        upper = extension_rom_resource.start;
+                }
+        }
+
+        /* check for adapter roms on 2k boundaries */
+        for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
+                rom = isa_bus_to_virt(start);
+                if (!romsignature(rom))
+                        continue;
+
+                if (probe_kernel_address(rom + 2, c) != 0)
+                        continue;
+
+                /* 0 < length <= 0x7f * 512, historically */
+                length = c * 512;
+
+                /* but accept any length that fits if checksum okay */
+                if (!length || start + length > upper || !romchecksum(rom, length))
+                        continue;
+
+                adapter_rom_resources[i].start = start;
+                adapter_rom_resources[i].end = start + length - 1;
+                request_resource(&iomem_resource, &adapter_rom_resources[i]);
+
+                start = adapter_rom_resources[i++].end & ~2047UL;
+        }
 }
 
-subsys_initcall(request_standard_resources);