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>

3 files changed, 99 insertions, 156 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
diff --git a/arch/arm/mm/mmu.c b/arch/arm/mm/mmu.c
index a991ce2f18d4..82ea2b3fb9b5 100644
--- a/arch/arm/mm/mmu.c
+++ b/arch/arm/mm/mmu.c
@@ -1062,74 +1062,47 @@ phys_addr_t arm_lowmem_limit __initdata = 0;
 void __init sanity_check_meminfo(void)
 {
         phys_addr_t memblock_limit = 0;
-        int i, j, highmem = 0;
+        int highmem = 0;
         phys_addr_t vmalloc_limit = __pa(vmalloc_min - 1) + 1;
+        struct memblock_region *reg;
 
-        for (i = 0, j = 0; i < meminfo.nr_banks; i++) {
-                struct membank *bank = &meminfo.bank[j];
-                phys_addr_t size_limit;
-
-                *bank = meminfo.bank[i];
-                size_limit = bank->size;
+        for_each_memblock(memory, reg) {
+                phys_addr_t block_start = reg->base;
+                phys_addr_t block_end = reg->base + reg->size;
+                phys_addr_t size_limit = reg->size;
 
-                if (bank->start >= vmalloc_limit)
+                if (reg->base >= vmalloc_limit)
                         highmem = 1;
                 else
-                        size_limit = vmalloc_limit - bank->start;
+                        size_limit = vmalloc_limit - reg->base;
 
-                bank->highmem = highmem;
 
-#ifdef CONFIG_HIGHMEM
-                /*
-                 * Split those memory banks which are partially overlapping
-                 * the vmalloc area greatly simplifying things later.
-                 */
-                if (!highmem && bank->size > size_limit) {
-                        if (meminfo.nr_banks >= NR_BANKS) {
-                                printk(KERN_CRIT "NR_BANKS too low, "
-                                                 "ignoring high memory\n");
-                        } else {
-                                memmove(bank + 1, bank,
-                                        (meminfo.nr_banks - i) * sizeof(*bank));
-                                meminfo.nr_banks++;
-                                i++;
-                                bank[1].size -= size_limit;
-                                bank[1].start = vmalloc_limit;
-                                bank[1].highmem = highmem = 1;
-                                j++;
+                if (!IS_ENABLED(CONFIG_HIGHMEM) || cache_is_vipt_aliasing()) {
+
+                        if (highmem) {
+                                pr_notice("Ignoring RAM at %pa-%pa (!CONFIG_HIGHMEM)\n",
+                                        &block_start, &block_end);
+                                memblock_remove(reg->base, reg->size);
+                                continue;
                         }
-                        bank->size = size_limit;
-                }
-#else
-                /*
-                 * Highmem banks not allowed with !CONFIG_HIGHMEM.
-                 */
-                if (highmem) {
-                        printk(KERN_NOTICE "Ignoring RAM at %.8llx-%.8llx "
-                               "(!CONFIG_HIGHMEM).\n",
-                               (unsigned long long)bank->start,
-                               (unsigned long long)bank->start + bank->size - 1);
-                        continue;
-                }
 
-                /*
-                 * Check whether this memory bank would partially overlap
-                 * the vmalloc area.
-                 */
-                if (bank->size > size_limit) {
-                        printk(KERN_NOTICE "Truncating RAM at %.8llx-%.8llx "
-                               "to -%.8llx (vmalloc region overlap).\n",
-                               (unsigned long long)bank->start,
-                               (unsigned long long)bank->start + bank->size - 1,
-                               (unsigned long long)bank->start + size_limit - 1);
-                        bank->size = size_limit;
+                        if (reg->size > size_limit) {
+                                phys_addr_t overlap_size = reg->size - size_limit;
+
+                                pr_notice("Truncating RAM at %pa-%pa to -%pa",
+                                      &block_start, &block_end, &vmalloc_limit);
+                                memblock_remove(vmalloc_limit, overlap_size);
+                                block_end = vmalloc_limit;
+                        }
                 }
-#endif
-                if (!bank->highmem) {
-                        phys_addr_t bank_end = bank->start + bank->size;
 
-                        if (bank_end > arm_lowmem_limit)
-                                arm_lowmem_limit = bank_end;
+                if (!highmem) {
+                        if (block_end > arm_lowmem_limit) {
+                                if (reg->size > size_limit)
+                                        arm_lowmem_limit = vmalloc_limit;
+                                else
+                                        arm_lowmem_limit = block_end;
+                        }
 
                         /*
                          * Find the first non-section-aligned page, and point
@@ -1145,35 +1118,15 @@ void __init sanity_check_meminfo(void)
                          * occurs before any free memory is mapped.
                          */
                         if (!memblock_limit) {
-                                if (!IS_ALIGNED(bank->start, SECTION_SIZE))
-                                        memblock_limit = bank->start;
-                                else if (!IS_ALIGNED(bank_end, SECTION_SIZE))
-                                        memblock_limit = bank_end;
+                                if (!IS_ALIGNED(block_start, SECTION_SIZE))
+                                        memblock_limit = block_start;
+                                else if (!IS_ALIGNED(block_end, SECTION_SIZE))
+                                        memblock_limit = arm_lowmem_limit;
                         }
-                }
-                j++;
-        }
-#ifdef CONFIG_HIGHMEM
-        if (highmem) {
-                const char *reason = NULL;
 
-                if (cache_is_vipt_aliasing()) {
-                        /*
-                         * Interactions between kmap and other mappings
-                         * make highmem support with aliasing VIPT caches
-                         * rather difficult.
-                         */
-                        reason = "with VIPT aliasing cache";
-                }
-                if (reason) {
-                        printk(KERN_CRIT "HIGHMEM is not supported %s, ignoring high memory\n",
-                                reason);
-                        while (j > 0 && meminfo.bank[j - 1].highmem)
-                                j--;
                 }
         }
-#endif
-        meminfo.nr_banks = j;
+
         high_memory = __va(arm_lowmem_limit - 1) + 1;
 
         /*
diff --git a/arch/arm/mm/nommu.c b/arch/arm/mm/nommu.c
index 55764a7ef1f0..da1874f9f8cf 100644
--- a/arch/arm/mm/nommu.c
+++ b/arch/arm/mm/nommu.c
@@ -88,30 +88,35 @@ static unsigned long irbar_read(void)
 void __init sanity_check_meminfo_mpu(void)
 {
         int i;
-        struct membank *bank = meminfo.bank;
         phys_addr_t phys_offset = PHYS_OFFSET;
         phys_addr_t aligned_region_size, specified_mem_size, rounded_mem_size;
-
-        /* Initially only use memory continuous from PHYS_OFFSET */
-        if (bank_phys_start(&bank[0]) != phys_offset)
-                panic("First memory bank must be contiguous from PHYS_OFFSET");
-
-        /* Banks have already been sorted by start address */
-        for (i = 1; i < meminfo.nr_banks; i++) {
-                if (bank[i].start <= bank_phys_end(&bank[0]) &&
-                    bank_phys_end(&bank[i]) > bank_phys_end(&bank[0])) {
-                        bank[0].size = bank_phys_end(&bank[i]) - bank[0].start;
+        struct memblock_region *reg;
+        bool first = true;
+        phys_addr_t mem_start;
+        phys_addr_t mem_end;
+
+        for_each_memblock(memory, reg) {
+                if (first) {
+                        /*
+                         * Initially only use memory continuous from
+                         * PHYS_OFFSET */
+                        if (reg->base != phys_offset)
+                                panic("First memory bank must be contiguous from PHYS_OFFSET");
+
+                        mem_start = reg->base;
+                        mem_end = reg->base + reg->size;
+                        specified_mem_size = reg->size;
+                        first = false;
                 } else {
-                        pr_notice("Ignoring RAM after 0x%.8lx. "
-                        "First non-contiguous (ignored) bank start: 0x%.8lx\n",
-                                (unsigned long)bank_phys_end(&bank[0]),
-                                (unsigned long)bank_phys_start(&bank[i]));
-                        break;
+                        /*
+                         * memblock auto merges contiguous blocks, remove
+                         * all blocks afterwards
+                         */
+                        pr_notice("Ignoring RAM after %pa, memory at %pa ignored\n",
+                                  &mem_start, &reg->base);
+                        memblock_remove(reg->base, reg->size);
                 }
         }
-        /* All contiguous banks are now merged in to the first bank */
-        meminfo.nr_banks = 1;
-        specified_mem_size = bank[0].size;
 
         /*
          * MPU has curious alignment requirements: Size must be power of 2, and
@@ -128,23 +133,24 @@ void __init sanity_check_meminfo_mpu(void)
          */
         aligned_region_size = (phys_offset - 1) ^ (phys_offset);
         /* Find the max power-of-two sized region that fits inside our bank */
-        rounded_mem_size = (1 <<  __fls(bank[0].size)) - 1;
+        rounded_mem_size = (1 <<  __fls(specified_mem_size)) - 1;
 
         /* The actual region size is the smaller of the two */
         aligned_region_size = aligned_region_size < rounded_mem_size
                                 ? aligned_region_size + 1
                                 : rounded_mem_size + 1;
 
-        if (aligned_region_size != specified_mem_size)
-                pr_warn("Truncating memory from 0x%.8lx to 0x%.8lx (MPU region constraints)",
-                                (unsigned long)specified_mem_size,
-                                (unsigned long)aligned_region_size);
+        if (aligned_region_size != specified_mem_size) {
+                pr_warn("Truncating memory from %pa to %pa (MPU region constraints)",
+                                &specified_mem_size, &aligned_region_size);
+                memblock_remove(mem_start + aligned_region_size,
+                                specified_mem_size - aligned_round_size);
+
+                mem_end = mem_start + aligned_region_size;
+        }
 
-        meminfo.bank[0].size = aligned_region_size;
-        pr_debug("MPU Region from 0x%.8lx size 0x%.8lx (end 0x%.8lx))\n",
-                (unsigned long)phys_offset,
-                (unsigned long)aligned_region_size,
-                (unsigned long)bank_phys_end(&bank[0]));
+        pr_debug("MPU Region from %pa size %pa (end %pa))\n",
+                &phys_offset, &aligned_region_size, &mem_end);
 
 }
 
@@ -292,7 +298,7 @@ void __init sanity_check_meminfo(void)
 {
         phys_addr_t end;
         sanity_check_meminfo_mpu();
-        end = bank_phys_end(&meminfo.bank[meminfo.nr_banks - 1]);
+        end = memblock_end_of_DRAM();
         high_memory = __va(end - 1) + 1;
 }