x86: make e820.c to have common functions

remove the duplicated copy of these functions.

Signed-off-by: Yinghai Lu <yhlu.kernel@gmail.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 0 insertions, 444 deletions

diff --git a/arch/x86/kernel/e820_64.c b/arch/x86/kernel/e820_64.c
index c45b4dea4055..28a14eb65d3d 100644
--- a/arch/x86/kernel/e820_64.c
+++ b/arch/x86/kernel/e820_64.c
@@ -29,8 +29,6 @@
 #include <asm/kdebug.h>
 #include <asm/trampoline.h>
 
-struct e820map e820;
-
 /*
  * PFN of last memory page.
  */
@@ -176,62 +174,6 @@ again:
         }
         return changed;
 }
-/*
- * This function checks if any part of the range <start,end> is mapped
- * with type.
- */
-int
-e820_any_mapped(unsigned long start, unsigned long end, unsigned type)
-{
-        int i;
-
-        for (i = 0; i < e820.nr_map; i++) {
-                struct e820entry *ei = &e820.map[i];
-
-                if (type && ei->type != type)
-                        continue;
-                if (ei->addr >= end || ei->addr + ei->size <= start)
-                        continue;
-                return 1;
-        }
-        return 0;
-}
-EXPORT_SYMBOL_GPL(e820_any_mapped);
-
-/*
- * This function checks if the entire range <start,end> is mapped with type.
- *
- * Note: this function only works correct if the e820 table is sorted and
- * not-overlapping, which is the case
- */
-int __init e820_all_mapped(unsigned long start, unsigned long end,
-                           unsigned type)
-{
-        int i;
-
-        for (i = 0; i < e820.nr_map; i++) {
-                struct e820entry *ei = &e820.map[i];
-
-                if (type && ei->type != type)
-                        continue;
-                /* is the region (part) in overlap with the current region ?*/
-                if (ei->addr >= end || ei->addr + ei->size <= start)
-                        continue;
-
-                /* if the region is at the beginning of <start,end> we move
-                 * start to the end of the region since it's ok until there
-                 */
-                if (ei->addr <= start)
-                        start = ei->addr + ei->size;
-                /*
-                 * if start is now at or beyond end, we're done, full
-                 * coverage
-                 */
-                if (start >= end)
-                        return 1;
-        }
-        return 0;
-}
 
 /*
  * Find a free area with specified alignment in a specific range.
@@ -435,24 +377,6 @@ e820_register_active_regions(int nid, unsigned long start_pfn,
 }
 
 /*
- * Add a memory region to the kernel e820 map.
- */
-void __init add_memory_region(unsigned long start, unsigned long size, int type)
-{
-        int x = e820.nr_map;
-
-        if (x == E820MAX) {
-                printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
-                return;
-        }
-
-        e820.map[x].addr = start;
-        e820.map[x].size = size;
-        e820.map[x].type = type;
-        e820.nr_map++;
-}
-
-/*
  * Find the hole size (in bytes) in the memory range.
  * @start: starting address of the memory range to scan
  * @end: ending address of the memory range to scan
@@ -473,266 +397,6 @@ unsigned long __init e820_hole_size(unsigned long start, unsigned long end)
         return end - start - (ram << PAGE_SHIFT);
 }
 
-static void __init e820_print_map(char *who)
-{
-        int i;
-
-        for (i = 0; i < e820.nr_map; i++) {
-                printk(KERN_INFO " %s: %016Lx - %016Lx ", who,
-                       (unsigned long long) e820.map[i].addr,
-                       (unsigned long long)
-                       (e820.map[i].addr + e820.map[i].size));
-                switch (e820.map[i].type) {
-                case E820_RAM:
-                        printk(KERN_CONT "(usable)\n");
-                        break;
-                case E820_RESERVED:
-                        printk(KERN_CONT "(reserved)\n");
-                        break;
-                case E820_ACPI:
-                        printk(KERN_CONT "(ACPI data)\n");
-                        break;
-                case E820_NVS:
-                        printk(KERN_CONT "(ACPI NVS)\n");
-                        break;
-                default:
-                        printk(KERN_CONT "type %u\n", e820.map[i].type);
-                        break;
-                }
-        }
-}
-
-/*
- * Sanitize the BIOS e820 map.
- *
- * Some e820 responses include overlapping entries. The following
- * replaces the original e820 map with a new one, removing overlaps.
- *
- */
-static int __init sanitize_e820_map(struct e820entry *biosmap, char *pnr_map)
-{
-        struct change_member {
-                struct e820entry *pbios; /* pointer to original bios entry */
-                unsigned long long addr; /* address for this change point */
-        };
-        static struct change_member change_point_list[2*E820MAX] __initdata;
-        static struct change_member *change_point[2*E820MAX] __initdata;
-        static struct e820entry *overlap_list[E820MAX] __initdata;
-        static struct e820entry new_bios[E820MAX] __initdata;
-        struct change_member *change_tmp;
-        unsigned long current_type, last_type;
-        unsigned long long last_addr;
-        int chgidx, still_changing;
-        int overlap_entries;
-        int new_bios_entry;
-        int old_nr, new_nr, chg_nr;
-        int i;
-
-        /*
-                Visually we're performing the following
-                (1,2,3,4 = memory types)...
-
-                Sample memory map (w/overlaps):
-                   ____22__________________
-                   ______________________4_
-                   ____1111________________
-                   _44_____________________
-                   11111111________________
-                   ____________________33__
-                   ___________44___________
-                   __________33333_________
-                   ______________22________
-                   ___________________2222_
-                   _________111111111______
-                   _____________________11_
-                   _________________4______
-
-                Sanitized equivalent (no overlap):
-                   1_______________________
-                   _44_____________________
-                   ___1____________________
-                   ____22__________________
-                   ______11________________
-                   _________1______________
-                   __________3_____________
-                   ___________44___________
-                   _____________33_________
-                   _______________2________
-                   ________________1_______
-                   _________________4______
-                   ___________________2____
-                   ____________________33__
-                   ______________________4_
-        */
-
-        /* if there's only one memory region, don't bother */
-        if (*pnr_map < 2)
-                return -1;
-
-        old_nr = *pnr_map;
-
-        /* bail out if we find any unreasonable addresses in bios map */
-        for (i = 0; i < old_nr; i++)
-                if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
-                        return -1;
-
-        /* create pointers for initial change-point information (for sorting) */
-        for (i = 0; i < 2 * old_nr; i++)
-                change_point[i] = &change_point_list[i];
-
-        /* record all known change-points (starting and ending addresses),
-           omitting those that are for empty memory regions */
-        chgidx = 0;
-        for (i = 0; i < old_nr; i++)    {
-                if (biosmap[i].size != 0) {
-                        change_point[chgidx]->addr = biosmap[i].addr;
-                        change_point[chgidx++]->pbios = &biosmap[i];
-                        change_point[chgidx]->addr = biosmap[i].addr +
-                                biosmap[i].size;
-                        change_point[chgidx++]->pbios = &biosmap[i];
-                }
-        }
-        chg_nr = chgidx;
-
-        /* sort change-point list by memory addresses (low -> high) */
-        still_changing = 1;
-        while (still_changing)  {
-                still_changing = 0;
-                for (i = 1; i < chg_nr; i++)  {
-                        unsigned long long curaddr, lastaddr;
-                        unsigned long long curpbaddr, lastpbaddr;
-
-                        curaddr = change_point[i]->addr;
-                        lastaddr = change_point[i - 1]->addr;
-                        curpbaddr = change_point[i]->pbios->addr;
-                        lastpbaddr = change_point[i - 1]->pbios->addr;
-
-                        /*
-                         * swap entries, when:
-                         *
-                         * curaddr > lastaddr or
-                         * curaddr == lastaddr and curaddr == curpbaddr and
-                         * lastaddr != lastpbaddr
-                         */
-                        if (curaddr < lastaddr ||
-                            (curaddr == lastaddr && curaddr == curpbaddr &&
-                             lastaddr != lastpbaddr)) {
-                                change_tmp = change_point[i];
-                                change_point[i] = change_point[i-1];
-                                change_point[i-1] = change_tmp;
-                                still_changing = 1;
-                        }
-                }
-        }
-
-        /* create a new bios memory map, removing overlaps */
-        overlap_entries = 0;     /* number of entries in the overlap table */
-        new_bios_entry = 0;      /* index for creating new bios map entries */
-        last_type = 0;           /* start with undefined memory type */
-        last_addr = 0;           /* start with 0 as last starting address */
-
-        /* loop through change-points, determining affect on the new bios map */
-        for (chgidx = 0; chgidx < chg_nr; chgidx++) {
-                /* keep track of all overlapping bios entries */
-                if (change_point[chgidx]->addr ==
-                    change_point[chgidx]->pbios->addr) {
-                        /*
-                         * add map entry to overlap list (> 1 entry
-                         * implies an overlap)
-                         */
-                        overlap_list[overlap_entries++] =
-                                change_point[chgidx]->pbios;
-                } else {
-                        /*
-                         * remove entry from list (order independent,
-                         * so swap with last)
-                         */
-                        for (i = 0; i < overlap_entries; i++) {
-                                if (overlap_list[i] ==
-                                    change_point[chgidx]->pbios)
-                                        overlap_list[i] =
-                                                overlap_list[overlap_entries-1];
-                        }
-                        overlap_entries--;
-                }
-                /*
-                 * if there are overlapping entries, decide which
-                 * "type" to use (larger value takes precedence --
-                 * 1=usable, 2,3,4,4+=unusable)
-                 */
-                current_type = 0;
-                for (i = 0; i < overlap_entries; i++)
-                        if (overlap_list[i]->type > current_type)
-                                current_type = overlap_list[i]->type;
-                /*
-                 * continue building up new bios map based on this
-                 * information
-                 */
-                if (current_type != last_type)  {
-                        if (last_type != 0)      {
-                                new_bios[new_bios_entry].size =
-                                        change_point[chgidx]->addr - last_addr;
-                                /*
-                                 * move forward only if the new size
-                                 * was non-zero
-                                 */
-                                if (new_bios[new_bios_entry].size != 0)
-                                        /*
-                                         * no more space left for new
-                                         * bios entries ?
-                                         */
-                                        if (++new_bios_entry >= E820MAX)
-                                                break;
-                        }
-                        if (current_type != 0)  {
-                                new_bios[new_bios_entry].addr =
-                                        change_point[chgidx]->addr;
-                                new_bios[new_bios_entry].type = current_type;
-                                last_addr = change_point[chgidx]->addr;
-                        }
-                        last_type = current_type;
-                }
-        }
-        /* retain count for new bios entries */
-        new_nr = new_bios_entry;
-
-        /* copy new bios mapping into original location */
-        memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry));
-        *pnr_map = new_nr;
-
-        return 0;
-}
-
-/*
- * Copy the BIOS e820 map into a safe place.
- *
- * Sanity-check it while we're at it..
- *
- * If we're lucky and live on a modern system, the setup code
- * will have given us a memory map that we can use to properly
- * set up memory.  If we aren't, we'll fake a memory map.
- */
-static int __init copy_e820_map(struct e820entry *biosmap, int nr_map)
-{
-        /* Only one memory region (or negative)? Ignore it */
-        if (nr_map < 2)
-                return -1;
-
-        do {
-                u64 start = biosmap->addr;
-                u64 size = biosmap->size;
-                u64 end = start + size;
-                u32 type = biosmap->type;
-
-                /* Overflow in 64 bits? Ignore the memory map. */
-                if (start > end)
-                        return -1;
-
-                add_memory_region(start, size, type);
-        } while (biosmap++, --nr_map);
-        return 0;
-}
-
 static void early_panic(char *msg)
 {
         early_printk(msg);
@@ -829,114 +493,6 @@ void __init finish_e820_parsing(void)
         }
 }
 
-u64 __init update_memory_range(u64 start, u64 size, unsigned old_type,
-                                unsigned new_type)
-{
-        int i;
-        u64 real_updated_size = 0;
-
-        BUG_ON(old_type == new_type);
-
-        for (i = 0; i < e820.nr_map; i++) {
-                struct e820entry *ei = &e820.map[i];
-                u64 final_start, final_end;
-                if (ei->type != old_type)
-                        continue;
-                /* totally covered? */
-                if (ei->addr >= start &&
-                    (ei->addr + ei->size) <= (start + size)) {
-                        ei->type = new_type;
-                        real_updated_size += ei->size;
-                        continue;
-                }
-                /* partially covered */
-                final_start = max(start, ei->addr);
-                final_end = min(start + size, ei->addr + ei->size);
-                if (final_start >= final_end)
-                        continue;
-                add_memory_region(final_start, final_end - final_start,
-                                         new_type);
-                real_updated_size += final_end - final_start;
-        }
-        return real_updated_size;
-}
-
-void __init update_e820(void)
-{
-        u8 nr_map;
-
-        nr_map = e820.nr_map;
-        if (sanitize_e820_map(e820.map, &nr_map))
-                return;
-        e820.nr_map = nr_map;
-        printk(KERN_INFO "modified physical RAM map:\n");
-        e820_print_map("modified");
-}
-
-unsigned long pci_mem_start = 0xaeedbabe;
-EXPORT_SYMBOL(pci_mem_start);
-
-/*
- * Search for the biggest gap in the low 32 bits of the e820
- * memory space.  We pass this space to PCI to assign MMIO resources
- * for hotplug or unconfigured devices in.
- * Hopefully the BIOS let enough space left.
- */
-__init void e820_setup_gap(void)
-{
-        unsigned long gapstart, gapsize, round;
-        unsigned long last;
-        int i;
-        int found = 0;
-
-        last = 0x100000000ull;
-        gapstart = 0x10000000;
-        gapsize = 0x400000;
-        i = e820.nr_map;
-        while (--i >= 0) {
-                unsigned long long start = e820.map[i].addr;
-                unsigned long long end = start + e820.map[i].size;
-
-                /*
-                 * Since "last" is at most 4GB, we know we'll
-                 * fit in 32 bits if this condition is true
-                 */
-                if (last > end) {
-                        unsigned long gap = last - end;
-
-                        if (gap > gapsize) {
-                                gapsize = gap;
-                                gapstart = end;
-                                found = 1;
-                        }
-                }
-                if (start < last)
-                        last = start;
-        }
-
-        if (!found) {
-                gapstart = (end_pfn << PAGE_SHIFT) + 1024*1024;
-                printk(KERN_ERR "PCI: Warning: Cannot find a gap in the 32bit "
-                       "address range\n"
-                       KERN_ERR "PCI: Unassigned devices with 32bit resource "
-                       "registers may break!\n");
-        }
-
-        /*
-         * See how much we want to round up: start off with
-         * rounding to the next 1MB area.
-         */
-        round = 0x100000;
-        while ((gapsize >> 4) > round)
-                round += round;
-        /* Fun with two's complement */
-        pci_mem_start = (gapstart + round) & -round;
-
-        printk(KERN_INFO
-               "Allocating PCI resources starting at %lx (gap: %lx:%lx)\n",
-               pci_mem_start, gapstart, gapsize);
-}
-
 int __init arch_get_ram_range(int slot, u64 *addr, u64 *size)
 {
         int i;