[IA64] simplified efi memory map parsing

New version leaves the original memory map unmodified.
Also saves any granule trimmings for use by the uncached
memory allocator.

Inspired by Khalid Aziz (various traces of his patch still
remain).  Fixes to uncached_build_memmap() and sn2 testing
by Martin Hicks.

Signed-off-by: Tony Luck <tony.luck@intel.com>

4 files changed, 254 insertions, 193 deletions

diff --git a/arch/ia64/kernel/efi.c b/arch/ia64/kernel/efi.c
index 179f230816ed..1291db581721 100644
--- a/arch/ia64/kernel/efi.c
+++ b/arch/ia64/kernel/efi.c
@@ -239,57 +239,30 @@ is_available_memory (efi_memory_desc_t *md)
         return 0;
 }
 
-/*
- * Trim descriptor MD so its starts at address START_ADDR.  If the descriptor covers
- * memory that is normally available to the kernel, issue a warning that some memory
- * is being ignored.
- */
-static void
-trim_bottom (efi_memory_desc_t *md, u64 start_addr)
-{
-        u64 num_skipped_pages;
-
-        if (md->phys_addr >= start_addr || !md->num_pages)
-                return;
-
-        num_skipped_pages = (start_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
-        if (num_skipped_pages > md->num_pages)
-                num_skipped_pages = md->num_pages;
+typedef struct kern_memdesc {
+        u64 attribute;
+        u64 start;
+        u64 num_pages;
+} kern_memdesc_t;
 
-        if (is_available_memory(md))
-                printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
-                       "at 0x%lx\n", __FUNCTION__,
-                       (num_skipped_pages << EFI_PAGE_SHIFT) >> 10,
-                       md->phys_addr, start_addr - IA64_GRANULE_SIZE);
-        /*
-         * NOTE: Don't set md->phys_addr to START_ADDR because that could cause the memory
-         * descriptor list to become unsorted.  In such a case, md->num_pages will be
-         * zero, so the Right Thing will happen.
-         */
-        md->phys_addr += num_skipped_pages << EFI_PAGE_SHIFT;
-        md->num_pages -= num_skipped_pages;
-}
+static kern_memdesc_t *kern_memmap;
 
 static void
-trim_top (efi_memory_desc_t *md, u64 end_addr)
+walk (efi_freemem_callback_t callback, void *arg, u64 attr)
 {
-        u64 num_dropped_pages, md_end_addr;
+        kern_memdesc_t *k;
+        u64 start, end, voff;
 
-        md_end_addr = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
-
-        if (md_end_addr <= end_addr || !md->num_pages)
-                return;
-
-        num_dropped_pages = (md_end_addr - end_addr) >> EFI_PAGE_SHIFT;
-        if (num_dropped_pages > md->num_pages)
-                num_dropped_pages = md->num_pages;
-
-        if (is_available_memory(md))
-                printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
-                       "at 0x%lx\n", __FUNCTION__,
-                       (num_dropped_pages << EFI_PAGE_SHIFT) >> 10,
-                       md->phys_addr, end_addr);
-        md->num_pages -= num_dropped_pages;
+        voff = (attr == EFI_MEMORY_WB) ? PAGE_OFFSET : __IA64_UNCACHED_OFFSET;
+        for (k = kern_memmap; k->start != ~0UL; k++) {
+                if (k->attribute != attr)
+                        continue;
+                start = PAGE_ALIGN(k->start);
+                end = (k->start + (k->num_pages << EFI_PAGE_SHIFT)) & PAGE_MASK;
+                if (start < end)
+                        if ((*callback)(start + voff, end + voff, arg) < 0)
+                                return;
+        }
 }
 
 /*
@@ -299,148 +272,19 @@ trim_top (efi_memory_desc_t *md, u64 end_addr)
 void
 efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
 {
-        int prev_valid = 0;
-        struct range {
-                u64 start;
-                u64 end;
-        } prev, curr;
-        void *efi_map_start, *efi_map_end, *p, *q;
-        efi_memory_desc_t *md, *check_md;
-        u64 efi_desc_size, start, end, granule_addr, last_granule_addr, first_non_wb_addr = 0;
-        unsigned long total_mem = 0;
-
-        efi_map_start = __va(ia64_boot_param->efi_memmap);
-        efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
-        efi_desc_size = ia64_boot_param->efi_memdesc_size;
-
-        for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
-                md = p;
-
-                /* skip over non-WB memory descriptors; that's all we're interested in... */
-                if (!(md->attribute & EFI_MEMORY_WB))
-                        continue;
-
-                /*
-                 * granule_addr is the base of md's first granule.
-                 * [granule_addr - first_non_wb_addr) is guaranteed to
-                 * be contiguous WB memory.
-                 */
-                granule_addr = GRANULEROUNDDOWN(md->phys_addr);
-                first_non_wb_addr = max(first_non_wb_addr, granule_addr);
-
-                if (first_non_wb_addr < md->phys_addr) {
-                        trim_bottom(md, granule_addr + IA64_GRANULE_SIZE);
-                        granule_addr = GRANULEROUNDDOWN(md->phys_addr);
-                        first_non_wb_addr = max(first_non_wb_addr, granule_addr);
-                }
-
-                for (q = p; q < efi_map_end; q += efi_desc_size) {
-                        check_md = q;
-
-                        if ((check_md->attribute & EFI_MEMORY_WB) &&
-                            (check_md->phys_addr == first_non_wb_addr))
-                                first_non_wb_addr += check_md->num_pages << EFI_PAGE_SHIFT;
-                        else
-                                break;          /* non-WB or hole */
-                }
-
-                last_granule_addr = GRANULEROUNDDOWN(first_non_wb_addr);
-                if (last_granule_addr < md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT))
-                        trim_top(md, last_granule_addr);
-
-                if (is_available_memory(md)) {
-                        if (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) >= max_addr) {
-                                if (md->phys_addr >= max_addr)
-                                        continue;
-                                md->num_pages = (max_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
-                                first_non_wb_addr = max_addr;
-                        }
-
-                        if (total_mem >= mem_limit)
-                                continue;
-
-                        if (total_mem + (md->num_pages << EFI_PAGE_SHIFT) > mem_limit) {
-                                unsigned long limit_addr = md->phys_addr;
-
-                                limit_addr += mem_limit - total_mem;
-                                limit_addr = GRANULEROUNDDOWN(limit_addr);
-
-                                if (md->phys_addr > limit_addr)
-                                        continue;
-
-                                md->num_pages = (limit_addr - md->phys_addr) >>
-                                                EFI_PAGE_SHIFT;
-                                first_non_wb_addr = max_addr = md->phys_addr +
-                                              (md->num_pages << EFI_PAGE_SHIFT);
-                        }
-                        total_mem += (md->num_pages << EFI_PAGE_SHIFT);
-
-                        if (md->num_pages == 0)
-                                continue;
-
-                        curr.start = PAGE_OFFSET + md->phys_addr;
-                        curr.end   = curr.start + (md->num_pages << EFI_PAGE_SHIFT);
-
-                        if (!prev_valid) {
-                                prev = curr;
-                                prev_valid = 1;
-                        } else {
-                                if (curr.start < prev.start)
-                                        printk(KERN_ERR "Oops: EFI memory table not ordered!\n");
-
-                                if (prev.end == curr.start) {
-                                        /* merge two consecutive memory ranges */
-                                        prev.end = curr.end;
-                                } else {
-                                        start = PAGE_ALIGN(prev.start);
-                                        end = prev.end & PAGE_MASK;
-                                        if ((end > start) && (*callback)(start, end, arg) < 0)
-                                                return;
-                                        prev = curr;
-                                }
-                        }
-                }
-        }
-        if (prev_valid) {
+        walk(callback, arg, EFI_MEMORY_WB);