ARM: 8025/1: Get rid of meminfo

memblock is now fully integrated into the kernel and is the prefered
method for tracking memory. Rather than reinvent the wheel with
meminfo, migrate to using memblock directly instead of meminfo as
an intermediate.

Acked-by: Jason Cooper <jason@lakedaemon.net>
Acked-by: Catalin Marinas <catalin.marinas@arm.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Acked-by: Kukjin Kim <kgene.kim@samsung.com>
Tested-by: Marek Szyprowski <m.szyprowski@samsung.com>
Tested-by: Leif Lindholm <leif.lindholm@linaro.org>
Signed-off-by: Laura Abbott <lauraa@codeaurora.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

1 files changed, 28 insertions, 44 deletions

diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c
index 2a77ba8796ae..c8ab21dc2178 100644
--- a/arch/arm/mm/init.c
+++ b/arch/arm/mm/init.c
@@ -81,24 +81,21 @@ __tagtable(ATAG_INITRD2, parse_tag_initrd2);
  * initialization functions, as well as show_mem() for the skipping
  * of holes in the memory map.  It is populated by arm_add_memory().
  */
-struct meminfo meminfo;
-
 void show_mem(unsigned int filter)
 {
         int free = 0, total = 0, reserved = 0;
-        int shared = 0, cached = 0, slab = 0, i;
-        struct meminfo * mi = &meminfo;
+        int shared = 0, cached = 0, slab = 0;
+        struct memblock_region *reg;
 
         printk("Mem-info:\n");
         show_free_areas(filter);
 
-        for_each_bank (i, mi) {
-                struct membank *bank = &mi->bank[i];
+        for_each_memblock (memory, reg) {
                 unsigned int pfn1, pfn2;
                 struct page *page, *end;
 
-                pfn1 = bank_pfn_start(bank);
-                pfn2 = bank_pfn_end(bank);
+                pfn1 = memblock_region_memory_base_pfn(reg);
+                pfn2 = memblock_region_memory_end_pfn(reg);
 
                 page = pfn_to_page(pfn1);
                 end  = pfn_to_page(pfn2 - 1) + 1;
@@ -115,8 +112,9 @@ void show_mem(unsigned int filter)
                                 free++;
                         else
                                 shared += page_count(page) - 1;
-                        page++;
-                } while (page < end);
+                        pfn1++;
+                        page = pfn_to_page(pfn1);
+                } while (pfn1 < pfn2);
         }
 
         printk("%d pages of RAM\n", total);
@@ -130,16 +128,9 @@ void show_mem(unsigned int filter)
 static void __init find_limits(unsigned long *min, unsigned long *max_low,
                                unsigned long *max_high)
 {
-        struct meminfo *mi = &meminfo;
-        int i;
-
-        /* This assumes the meminfo array is properly sorted */
-        *min = bank_pfn_start(&mi->bank[0]);
-        for_each_bank (i, mi)
-                if (mi->bank[i].highmem)
-                                break;
-        *max_low = bank_pfn_end(&mi->bank[i - 1]);
-        *max_high = bank_pfn_end(&mi->bank[mi->nr_banks - 1]);
+        *max_low = PFN_DOWN(memblock_get_current_limit());
+        *min = PFN_UP(memblock_start_of_DRAM());
+        *max_high = PFN_DOWN(memblock_end_of_DRAM());
 }
 
 #ifdef CONFIG_ZONE_DMA
@@ -274,14 +265,8 @@ phys_addr_t __init arm_memblock_steal(phys_addr_t size, phys_addr_t align)
         return phys;
 }
 
-void __init arm_memblock_init(struct meminfo *mi,
-        const struct machine_desc *mdesc)
+void __init arm_memblock_init(const struct machine_desc *mdesc)
 {
-        int i;
-
-        for (i = 0; i < mi->nr_banks; i++)
-                memblock_add(mi->bank[i].start, mi->bank[i].size);
-
         /* Register the kernel text, kernel data and initrd with memblock. */
 #ifdef CONFIG_XIP_KERNEL
         memblock_reserve(__pa(_sdata), _end - _sdata);
@@ -413,54 +398,53 @@ free_memmap(unsigned long start_pfn, unsigned long end_pfn)
 /*
  * The mem_map array can get very big.  Free the unused area of the memory map.
  */
-static void __init free_unused_memmap(struct meminfo *mi)
+static void __init free_unused_memmap(void)
 {
-        unsigned long bank_start, prev_bank_end = 0;
-        unsigned int i;
+        unsigned long start, prev_end = 0;
+        struct memblock_region *reg;
 
         /*
          * This relies on each bank being in address order.
          * The banks are sorted previously in bootmem_init().
          */
-        for_each_bank(i, mi) {
-                struct membank *bank = &mi->bank[i];
-
-                bank_start = bank_pfn_start(bank);
+        for_each_memblock(memory, reg) {
+                start = memblock_region_memory_base_pfn(reg);
 
 #ifdef CONFIG_SPARSEMEM
                 /*
                  * Take care not to free memmap entries that don't exist
                  * due to SPARSEMEM sections which aren't present.
                  */
-                bank_start = min(bank_start,
-                                 ALIGN(prev_bank_end, PAGES_PER_SECTION));
+                start = min(start,
+                                 ALIGN(prev_end, PAGES_PER_SECTION));
 #else
                 /*
                  * Align down here since the VM subsystem insists that the
                  * memmap entries are valid from the bank start aligned to
                  * MAX_ORDER_NR_PAGES.
                  */
-                bank_start = round_down(bank_start, MAX_ORDER_NR_PAGES);
+                start = round_down(start, MAX_ORDER_NR_PAGES);
 #endif
                 /*
                  * If we had a previous bank, and there is a space
                  * between the current bank and the previous, free it.
                  */
-                if (prev_bank_end && prev_bank_end < bank_start)
-                        free_memmap(prev_bank_end, bank_start);
+                if (prev_end && prev_end < start)
+                        free_memmap(prev_end, start);
 
                 /*
                  * Align up here since the VM subsystem insists that the
                  * memmap entries are valid from the bank end aligned to
                  * MAX_ORDER_NR_PAGES.
                  */
-                prev_bank_end = ALIGN(bank_pfn_end(bank), MAX_ORDER_NR_PAGES);
+                prev_end = ALIGN(memblock_region_memory_end_pfn(reg),
+                                 MAX_ORDER_NR_PAGES);
         }
 
 #ifdef CONFIG_SPARSEMEM
-        if (!IS_ALIGNED(prev_bank_end, PAGES_PER_SECTION))
-                free_memmap(prev_bank_end,
-                            ALIGN(prev_bank_end, PAGES_PER_SECTION));
+        if (!IS_ALIGNED(prev_end, PAGES_PER_SECTION))
+                free_memmap(prev_end,
+                            ALIGN(prev_end, PAGES_PER_SECTION));
 #endif
 }
 
@@ -536,7 +520,7 @@ void __init mem_init(void)
         set_max_mapnr(pfn_to_page(max_pfn) - mem_map);
 
         /* this will put all unused low memory onto the freelists */
-        free_unused_memmap(&meminfo);
+        free_unused_memmap();
         free_all_bootmem();
 
 #ifdef CONFIG_SA1111