13f65ce4dSChris Zankel /* 23f65ce4dSChris Zankel * arch/xtensa/mm/init.c 33f65ce4dSChris Zankel * 43f65ce4dSChris Zankel * Derived from MIPS, PPC. 53f65ce4dSChris Zankel * 63f65ce4dSChris Zankel * This file is subject to the terms and conditions of the GNU General Public 73f65ce4dSChris Zankel * License. See the file "COPYING" in the main directory of this archive 83f65ce4dSChris Zankel * for more details. 93f65ce4dSChris Zankel * 103f65ce4dSChris Zankel * Copyright (C) 2001 - 2005 Tensilica Inc. 119d4b52dfSMax Filippov * Copyright (C) 2014 Cadence Design Systems Inc. 123f65ce4dSChris Zankel * 133f65ce4dSChris Zankel * Chris Zankel <chris@zankel.net> 143f65ce4dSChris Zankel * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com> 153f65ce4dSChris Zankel * Marc Gauthier 163f65ce4dSChris Zankel * Kevin Chea 173f65ce4dSChris Zankel */ 183f65ce4dSChris Zankel 193f65ce4dSChris Zankel #include <linux/kernel.h> 203f65ce4dSChris Zankel #include <linux/errno.h> 213f65ce4dSChris Zankel #include <linux/bootmem.h> 225a0e3ad6STejun Heo #include <linux/gfp.h> 2365559100SMax Filippov #include <linux/highmem.h> 243f65ce4dSChris Zankel #include <linux/swap.h> 256656920bSChris Zankel #include <linux/mman.h> 266656920bSChris Zankel #include <linux/nodemask.h> 276656920bSChris Zankel #include <linux/mm.h> 283f65ce4dSChris Zankel 293f65ce4dSChris Zankel #include <asm/bootparam.h> 303f65ce4dSChris Zankel #include <asm/page.h> 31f022d0faSGeert Uytterhoeven #include <asm/sections.h> 329ba067f9SMax Filippov #include <asm/sysmem.h> 339ba067f9SMax Filippov 349ba067f9SMax Filippov struct sysmem_info sysmem __initdata; 359ba067f9SMax Filippov 368585b316SMax Filippov static void __init sysmem_dump(void) 378585b316SMax Filippov { 388585b316SMax Filippov unsigned i; 398585b316SMax Filippov 408585b316SMax Filippov pr_debug("Sysmem:\n"); 418585b316SMax Filippov for (i = 0; i < sysmem.nr_banks; ++i) 428585b316SMax Filippov pr_debug(" 0x%08lx - 0x%08lx (%ldK)\n", 438585b316SMax Filippov sysmem.bank[i].start, sysmem.bank[i].end, 448585b316SMax Filippov (sysmem.bank[i].end - sysmem.bank[i].start) >> 10); 458585b316SMax Filippov } 468585b316SMax Filippov 479d4b52dfSMax Filippov /* 489d4b52dfSMax Filippov * Find bank with maximal .start such that bank.start <= start 499d4b52dfSMax Filippov */ 509d4b52dfSMax Filippov static inline struct meminfo * __init find_bank(unsigned long start) 519d4b52dfSMax Filippov { 529d4b52dfSMax Filippov unsigned i; 539d4b52dfSMax Filippov struct meminfo *it = NULL; 549d4b52dfSMax Filippov 559d4b52dfSMax Filippov for (i = 0; i < sysmem.nr_banks; ++i) 569d4b52dfSMax Filippov if (sysmem.bank[i].start <= start) 579d4b52dfSMax Filippov it = sysmem.bank + i; 589d4b52dfSMax Filippov else 599d4b52dfSMax Filippov break; 609d4b52dfSMax Filippov return it; 619d4b52dfSMax Filippov } 629d4b52dfSMax Filippov 639d4b52dfSMax Filippov /* 649d4b52dfSMax Filippov * Move all memory banks starting at 'from' to a new place at 'to', 659d4b52dfSMax Filippov * adjust nr_banks accordingly. 669d4b52dfSMax Filippov * Both 'from' and 'to' must be inside the sysmem.bank. 679d4b52dfSMax Filippov * 689d4b52dfSMax Filippov * Returns: 0 (success), -ENOMEM (not enough space in the sysmem.bank). 699d4b52dfSMax Filippov */ 709d4b52dfSMax Filippov static int __init move_banks(struct meminfo *to, struct meminfo *from) 719d4b52dfSMax Filippov { 729d4b52dfSMax Filippov unsigned n = sysmem.nr_banks - (from - sysmem.bank); 739d4b52dfSMax Filippov 749d4b52dfSMax Filippov if (to > from && to - from + sysmem.nr_banks > SYSMEM_BANKS_MAX) 759d4b52dfSMax Filippov return -ENOMEM; 769d4b52dfSMax Filippov if (to != from) 779d4b52dfSMax Filippov memmove(to, from, n * sizeof(struct meminfo)); 789d4b52dfSMax Filippov sysmem.nr_banks += to - from; 799d4b52dfSMax Filippov return 0; 809d4b52dfSMax Filippov } 819d4b52dfSMax Filippov 829d4b52dfSMax Filippov /* 839d4b52dfSMax Filippov * Add new bank to sysmem. Resulting sysmem is the union of bytes of the 849d4b52dfSMax Filippov * original sysmem and the new bank. 859d4b52dfSMax Filippov * 869d4b52dfSMax Filippov * Returns: 0 (success), < 0 (error) 879d4b52dfSMax Filippov */ 889ba067f9SMax Filippov int __init add_sysmem_bank(unsigned long start, unsigned long end) 899ba067f9SMax Filippov { 909d4b52dfSMax Filippov unsigned i; 919d4b52dfSMax Filippov struct meminfo *it = NULL; 929d4b52dfSMax Filippov unsigned long sz; 939d4b52dfSMax Filippov unsigned long bank_sz = 0; 949d4b52dfSMax Filippov 959d4b52dfSMax Filippov if (start == end || 969d4b52dfSMax Filippov (start < end) != (PAGE_ALIGN(start) < (end & PAGE_MASK))) { 979d4b52dfSMax Filippov pr_warn("Ignoring small memory bank 0x%08lx size: %ld bytes\n", 989ba067f9SMax Filippov start, end - start); 999ba067f9SMax Filippov return -EINVAL; 1009ba067f9SMax Filippov } 1019ba067f9SMax Filippov 1029d4b52dfSMax Filippov start = PAGE_ALIGN(start); 1039d4b52dfSMax Filippov end &= PAGE_MASK; 1049d4b52dfSMax Filippov sz = end - start; 1059d4b52dfSMax Filippov 1069d4b52dfSMax Filippov it = find_bank(start); 1079d4b52dfSMax Filippov 1089d4b52dfSMax Filippov if (it) 1099d4b52dfSMax Filippov bank_sz = it->end - it->start; 1109d4b52dfSMax Filippov 1119d4b52dfSMax Filippov if (it && bank_sz >= start - it->start) { 1129d4b52dfSMax Filippov if (end - it->start > bank_sz) 1139d4b52dfSMax Filippov it->end = end; 1149d4b52dfSMax Filippov else 1159d4b52dfSMax Filippov return 0; 1169d4b52dfSMax Filippov } else { 1179d4b52dfSMax Filippov if (!it) 1189d4b52dfSMax Filippov it = sysmem.bank; 1199d4b52dfSMax Filippov else 1209d4b52dfSMax Filippov ++it; 1219d4b52dfSMax Filippov 1229d4b52dfSMax Filippov if (it - sysmem.bank < sysmem.nr_banks && 1239d4b52dfSMax Filippov it->start - start <= sz) { 1249d4b52dfSMax Filippov it->start = start; 1259d4b52dfSMax Filippov if (it->end - it->start < sz) 1269d4b52dfSMax Filippov it->end = end; 1279d4b52dfSMax Filippov else 1289d4b52dfSMax Filippov return 0; 1299d4b52dfSMax Filippov } else { 1309d4b52dfSMax Filippov if (move_banks(it + 1, it) < 0) { 1319d4b52dfSMax Filippov pr_warn("Ignoring memory bank 0x%08lx size %ld bytes\n", 1329d4b52dfSMax Filippov start, end - start); 1339d4b52dfSMax Filippov return -EINVAL; 1349d4b52dfSMax Filippov } 1359d4b52dfSMax Filippov it->start = start; 1369d4b52dfSMax Filippov it->end = end; 1379d4b52dfSMax Filippov return 0; 1389d4b52dfSMax Filippov } 1399d4b52dfSMax Filippov } 1409d4b52dfSMax Filippov sz = it->end - it->start; 1419d4b52dfSMax Filippov for (i = it + 1 - sysmem.bank; i < sysmem.nr_banks; ++i) 1429d4b52dfSMax Filippov if (sysmem.bank[i].start - it->start <= sz) { 1439d4b52dfSMax Filippov if (sz < sysmem.bank[i].end - it->start) 1449d4b52dfSMax Filippov it->end = sysmem.bank[i].end; 1459d4b52dfSMax Filippov } else { 1469d4b52dfSMax Filippov break; 1479d4b52dfSMax Filippov } 1489d4b52dfSMax Filippov 1499d4b52dfSMax Filippov move_banks(it + 1, sysmem.bank + i); 1509ba067f9SMax Filippov return 0; 1519ba067f9SMax Filippov } 1523f65ce4dSChris Zankel 1533f65ce4dSChris Zankel /* 1543f65ce4dSChris Zankel * mem_reserve(start, end, must_exist) 1553f65ce4dSChris Zankel * 1563f65ce4dSChris Zankel * Reserve some memory from the memory pool. 15762327918SMax Filippov * If must_exist is set and a part of the region being reserved does not exist 15862327918SMax Filippov * memory map is not altered. 1593f65ce4dSChris Zankel * 1603f65ce4dSChris Zankel * Parameters: 1613f65ce4dSChris Zankel * start Start of region, 1623f65ce4dSChris Zankel * end End of region, 1633f65ce4dSChris Zankel * must_exist Must exist in memory pool. 1643f65ce4dSChris Zankel * 1653f65ce4dSChris Zankel * Returns: 16662327918SMax Filippov * 0 (success) 16762327918SMax Filippov * < 0 (error) 1683f65ce4dSChris Zankel */ 1693f65ce4dSChris Zankel 1703f65ce4dSChris Zankel int __init mem_reserve(unsigned long start, unsigned long end, int must_exist) 1713f65ce4dSChris Zankel { 17262327918SMax Filippov struct meminfo *it; 17362327918SMax Filippov struct meminfo *rm = NULL; 17462327918SMax Filippov unsigned long sz; 17562327918SMax Filippov unsigned long bank_sz = 0; 1763f65ce4dSChris Zankel 1773f65ce4dSChris Zankel start = start & PAGE_MASK; 1783f65ce4dSChris Zankel end = PAGE_ALIGN(end); 17962327918SMax Filippov sz = end - start; 18062327918SMax Filippov if (!sz) 18162327918SMax Filippov return -EINVAL; 1823f65ce4dSChris Zankel 18362327918SMax Filippov it = find_bank(start); 1843f65ce4dSChris Zankel 18562327918SMax Filippov if (it) 18662327918SMax Filippov bank_sz = it->end - it->start; 18762327918SMax Filippov 18862327918SMax Filippov if ((!it || end - it->start > bank_sz) && must_exist) { 18962327918SMax Filippov pr_warn("mem_reserve: [0x%0lx, 0x%0lx) not in any region!\n", 19062327918SMax Filippov start, end); 19162327918SMax Filippov return -EINVAL; 19262327918SMax Filippov } 19362327918SMax Filippov 194be6ae382SMax Filippov if (it && start - it->start <= bank_sz) { 19562327918SMax Filippov if (start == it->start) { 19662327918SMax Filippov if (end - it->start < bank_sz) { 19762327918SMax Filippov it->start = end; 1983f65ce4dSChris Zankel return 0; 199c4c4594bSChris Zankel } else { 20062327918SMax Filippov rm = it; 2013f65ce4dSChris Zankel } 20262327918SMax Filippov } else { 20362327918SMax Filippov it->end = start; 20462327918SMax Filippov if (end - it->start < bank_sz) 20562327918SMax Filippov return add_sysmem_bank(end, 20662327918SMax Filippov it->start + bank_sz); 20762327918SMax Filippov ++it; 20862327918SMax Filippov } 20962327918SMax Filippov } 21062327918SMax Filippov 21162327918SMax Filippov if (!it) 21262327918SMax Filippov it = sysmem.bank; 21362327918SMax Filippov 21462327918SMax Filippov for (; it < sysmem.bank + sysmem.nr_banks; ++it) { 21562327918SMax Filippov if (it->end - start <= sz) { 21662327918SMax Filippov if (!rm) 21762327918SMax Filippov rm = it; 21862327918SMax Filippov } else { 21962327918SMax Filippov if (it->start - start < sz) 22062327918SMax Filippov it->start = end; 22162327918SMax Filippov break; 22262327918SMax Filippov } 22362327918SMax Filippov } 22462327918SMax Filippov 22562327918SMax Filippov if (rm) 22662327918SMax Filippov move_banks(rm, it); 22762327918SMax Filippov 22862327918SMax Filippov return 0; 2293f65ce4dSChris Zankel } 2303f65ce4dSChris Zankel 2313f65ce4dSChris Zankel 2323f65ce4dSChris Zankel /* 233e9d6dca5SMax Filippov * Initialize the bootmem system and give it all low memory we have available. 2343f65ce4dSChris Zankel */ 2353f65ce4dSChris Zankel 2363f65ce4dSChris Zankel void __init bootmem_init(void) 2373f65ce4dSChris Zankel { 2383f65ce4dSChris Zankel unsigned long pfn; 2393f65ce4dSChris Zankel unsigned long bootmap_start, bootmap_size; 2403f65ce4dSChris Zankel int i; 2413f65ce4dSChris Zankel 242566fb58eSMax Filippov /* Reserve all memory below PLATFORM_DEFAULT_MEM_START, as memory 243566fb58eSMax Filippov * accounting doesn't work for pages below that address. 244566fb58eSMax Filippov * 245566fb58eSMax Filippov * If PLATFORM_DEFAULT_MEM_START is zero reserve page at address 0: 246566fb58eSMax Filippov * successfull allocations should never return NULL. 247566fb58eSMax Filippov */ 248566fb58eSMax Filippov if (PLATFORM_DEFAULT_MEM_START) 249566fb58eSMax Filippov mem_reserve(0, PLATFORM_DEFAULT_MEM_START, 0); 250566fb58eSMax Filippov else 251566fb58eSMax Filippov mem_reserve(0, 1, 0); 252566fb58eSMax Filippov 2538585b316SMax Filippov sysmem_dump(); 2543f65ce4dSChris Zankel max_low_pfn = max_pfn = 0; 2553f65ce4dSChris Zankel min_low_pfn = ~0; 2563f65ce4dSChris Zankel 2573f65ce4dSChris Zankel for (i=0; i < sysmem.nr_banks; i++) { 2583f65ce4dSChris Zankel pfn = PAGE_ALIGN(sysmem.bank[i].start) >> PAGE_SHIFT; 2593f65ce4dSChris Zankel if (pfn < min_low_pfn) 2603f65ce4dSChris Zankel min_low_pfn = pfn; 2613f65ce4dSChris Zankel pfn = PAGE_ALIGN(sysmem.bank[i].end - 1) >> PAGE_SHIFT; 2623f65ce4dSChris Zankel if (pfn > max_pfn) 2633f65ce4dSChris Zankel max_pfn = pfn; 2643f65ce4dSChris Zankel } 2653f65ce4dSChris Zankel 2663f65ce4dSChris Zankel if (min_low_pfn > max_pfn) 2673f65ce4dSChris Zankel panic("No memory found!\n"); 2683f65ce4dSChris Zankel 269d39af902SMax Filippov max_low_pfn = min(max_pfn, MAX_LOW_PFN); 2703f65ce4dSChris Zankel 2713f65ce4dSChris Zankel /* Find an area to use for the bootmem bitmap. */ 2723f65ce4dSChris Zankel 273264da9f7SJohannes Weiner bootmap_size = bootmem_bootmap_pages(max_low_pfn - min_low_pfn); 274264da9f7SJohannes Weiner bootmap_size <<= PAGE_SHIFT; 2753f65ce4dSChris Zankel bootmap_start = ~0; 2763f65ce4dSChris Zankel 2773f65ce4dSChris Zankel for (i=0; i<sysmem.nr_banks; i++) 2783f65ce4dSChris Zankel if (sysmem.bank[i].end - sysmem.bank[i].start >= bootmap_size) { 2793f65ce4dSChris Zankel bootmap_start = sysmem.bank[i].start; 2803f65ce4dSChris Zankel break; 2813f65ce4dSChris Zankel } 2823f65ce4dSChris Zankel 2833f65ce4dSChris Zankel if (bootmap_start == ~0UL) 2843f65ce4dSChris Zankel panic("Cannot find %ld bytes for bootmap\n", bootmap_size); 2853f65ce4dSChris Zankel 2863f65ce4dSChris Zankel /* Reserve the bootmem bitmap area */ 2873f65ce4dSChris Zankel 2883f65ce4dSChris Zankel mem_reserve(bootmap_start, bootmap_start + bootmap_size, 1); 2890bef42e5SJohannes Weiner bootmap_size = init_bootmem_node(NODE_DATA(0), 2903f65ce4dSChris Zankel bootmap_start >> PAGE_SHIFT, 2910bef42e5SJohannes Weiner min_low_pfn, 2923f65ce4dSChris Zankel max_low_pfn); 2933f65ce4dSChris Zankel 2943f65ce4dSChris Zankel /* Add all remaining memory pieces into the bootmem map */ 2953f65ce4dSChris Zankel 296e9d6dca5SMax Filippov for (i = 0; i < sysmem.nr_banks; i++) { 297e9d6dca5SMax Filippov if (sysmem.bank[i].start >> PAGE_SHIFT < max_low_pfn) { 298e9d6dca5SMax Filippov unsigned long end = min(max_low_pfn << PAGE_SHIFT, 299e9d6dca5SMax Filippov sysmem.bank[i].end); 3003f65ce4dSChris Zankel free_bootmem(sysmem.bank[i].start, 301e9d6dca5SMax Filippov end - sysmem.bank[i].start); 302e9d6dca5SMax Filippov } 303e9d6dca5SMax Filippov } 3043f65ce4dSChris Zankel 3053f65ce4dSChris Zankel } 3063f65ce4dSChris Zankel 3073f65ce4dSChris Zankel 308e5083a63SJohannes Weiner void __init zones_init(void) 3093f65ce4dSChris Zankel { 3103f65ce4dSChris Zankel /* All pages are DMA-able, so we put them all in the DMA zone. */ 31165559100SMax Filippov unsigned long zones_size[MAX_NR_ZONES] = { 31265559100SMax Filippov [ZONE_DMA] = max_low_pfn - ARCH_PFN_OFFSET, 3133f65ce4dSChris Zankel #ifdef CONFIG_HIGHMEM 31465559100SMax Filippov [ZONE_HIGHMEM] = max_pfn - max_low_pfn, 3153f65ce4dSChris Zankel #endif 31665559100SMax Filippov }; 317c947a585SJohannes Weiner free_area_init_node(0, zones_size, ARCH_PFN_OFFSET, NULL); 3183f65ce4dSChris Zankel } 3193f65ce4dSChris Zankel 3203f65ce4dSChris Zankel /* 3213f65ce4dSChris Zankel * Initialize memory pages. 3223f65ce4dSChris Zankel */ 3233f65ce4dSChris Zankel 3243f65ce4dSChris Zankel void __init mem_init(void) 3253f65ce4dSChris Zankel { 326288a60cfSChris Zankel #ifdef CONFIG_HIGHMEM 32765559100SMax Filippov unsigned long tmp; 32865559100SMax Filippov 32965559100SMax Filippov reset_all_zones_managed_pages(); 33065559100SMax Filippov for (tmp = max_low_pfn; tmp < max_pfn; tmp++) 33165559100SMax Filippov free_highmem_page(pfn_to_page(tmp)); 3323f65ce4dSChris Zankel #endif 3333f65ce4dSChris Zankel 33465559100SMax Filippov max_mapnr = max_pfn - ARCH_PFN_OFFSET; 33565559100SMax Filippov high_memory = (void *)__va(max_low_pfn << PAGE_SHIFT); 33665559100SMax Filippov 3370c988534SJiang Liu free_all_bootmem(); 3383f65ce4dSChris Zankel 339808c2c37SJiang Liu mem_init_print_info(NULL); 34065559100SMax Filippov pr_info("virtual kernel memory layout:\n" 34165559100SMax Filippov #ifdef CONFIG_HIGHMEM 34265559100SMax Filippov " pkmap : 0x%08lx - 0x%08lx (%5lu kB)\n" 34365559100SMax Filippov " fixmap : 0x%08lx - 0x%08lx (%5lu kB)\n" 34465559100SMax Filippov #endif 3455a0b1d78SMax Filippov #ifdef CONFIG_MMU 346f1883aa7SMax Filippov " vmalloc : 0x%08lx - 0x%08lx (%5lu MB)\n" 3475a0b1d78SMax Filippov #endif 3485a0b1d78SMax Filippov " lowmem : 0x%08lx - 0x%08lx (%5lu MB)\n", 34965559100SMax Filippov #ifdef CONFIG_HIGHMEM 35065559100SMax Filippov PKMAP_BASE, PKMAP_BASE + LAST_PKMAP * PAGE_SIZE, 35165559100SMax Filippov (LAST_PKMAP*PAGE_SIZE) >> 10, 35265559100SMax Filippov FIXADDR_START, FIXADDR_TOP, 35365559100SMax Filippov (FIXADDR_TOP - FIXADDR_START) >> 10, 35465559100SMax Filippov #endif 3555a0b1d78SMax Filippov #ifdef CONFIG_MMU 35665559100SMax Filippov VMALLOC_START, VMALLOC_END, 35765559100SMax Filippov (VMALLOC_END - VMALLOC_START) >> 20, 35865559100SMax Filippov PAGE_OFFSET, PAGE_OFFSET + 35965559100SMax Filippov (max_low_pfn - min_low_pfn) * PAGE_SIZE, 3605a0b1d78SMax Filippov #else 3615a0b1d78SMax Filippov min_low_pfn * PAGE_SIZE, max_low_pfn * PAGE_SIZE, 3625a0b1d78SMax Filippov #endif 36365559100SMax Filippov ((max_low_pfn - min_low_pfn) * PAGE_SIZE) >> 20); 3643f65ce4dSChris Zankel } 3653f65ce4dSChris Zankel 3663f65ce4dSChris Zankel #ifdef CONFIG_BLK_DEV_INITRD 3673f65ce4dSChris Zankel extern int initrd_is_mapped; 3683f65ce4dSChris Zankel 3693f65ce4dSChris Zankel void free_initrd_mem(unsigned long start, unsigned long end) 3703f65ce4dSChris Zankel { 3717acb2c2eSJiang Liu if (initrd_is_mapped) 372dbe67df4SJiang Liu free_reserved_area((void *)start, (void *)end, -1, "initrd"); 3733f65ce4dSChris Zankel } 3743f65ce4dSChris Zankel #endif 3753f65ce4dSChris Zankel 3763f65ce4dSChris Zankel void free_initmem(void) 3773f65ce4dSChris Zankel { 378dbe67df4SJiang Liu free_initmem_default(-1); 3793f65ce4dSChris Zankel } 38006bd2824SMax Filippov 38106bd2824SMax Filippov static void __init parse_memmap_one(char *p) 38206bd2824SMax Filippov { 38306bd2824SMax Filippov char *oldp; 38406bd2824SMax Filippov unsigned long start_at, mem_size; 38506bd2824SMax Filippov 38606bd2824SMax Filippov if (!p) 38706bd2824SMax Filippov return; 38806bd2824SMax Filippov 38906bd2824SMax Filippov oldp = p; 39006bd2824SMax Filippov mem_size = memparse(p, &p); 39106bd2824SMax Filippov if (p == oldp) 39206bd2824SMax Filippov return; 39306bd2824SMax Filippov 39406bd2824SMax Filippov switch (*p) { 39506bd2824SMax Filippov case '@': 39606bd2824SMax Filippov start_at = memparse(p + 1, &p); 39706bd2824SMax Filippov add_sysmem_bank(start_at, start_at + mem_size); 39806bd2824SMax Filippov break; 39906bd2824SMax Filippov 40006bd2824SMax Filippov case '$': 40106bd2824SMax Filippov start_at = memparse(p + 1, &p); 40206bd2824SMax Filippov mem_reserve(start_at, start_at + mem_size, 0); 40306bd2824SMax Filippov break; 40406bd2824SMax Filippov 40506bd2824SMax Filippov case 0: 40606bd2824SMax Filippov mem_reserve(mem_size, 0, 0); 40706bd2824SMax Filippov break; 40806bd2824SMax Filippov 40906bd2824SMax Filippov default: 41006bd2824SMax Filippov pr_warn("Unrecognized memmap syntax: %s\n", p); 41106bd2824SMax Filippov break; 41206bd2824SMax Filippov } 41306bd2824SMax Filippov } 41406bd2824SMax Filippov 41506bd2824SMax Filippov static int __init parse_memmap_opt(char *str) 41606bd2824SMax Filippov { 41706bd2824SMax Filippov while (str) { 41806bd2824SMax Filippov char *k = strchr(str, ','); 41906bd2824SMax Filippov 42006bd2824SMax Filippov if (k) 42106bd2824SMax Filippov *k++ = 0; 42206bd2824SMax Filippov 42306bd2824SMax Filippov parse_memmap_one(str); 42406bd2824SMax Filippov str = k; 42506bd2824SMax Filippov } 42606bd2824SMax Filippov 42706bd2824SMax Filippov return 0; 42806bd2824SMax Filippov } 42906bd2824SMax Filippov early_param("memmap", parse_memmap_opt); 430