1 /* 2 * arch/xtensa/mm/init.c 3 * 4 * Derived from MIPS, PPC. 5 * 6 * This file is subject to the terms and conditions of the GNU General Public 7 * License. See the file "COPYING" in the main directory of this archive 8 * for more details. 9 * 10 * Copyright (C) 2001 - 2005 Tensilica Inc. 11 * Copyright (C) 2014 Cadence Design Systems Inc. 12 * 13 * Chris Zankel <chris@zankel.net> 14 * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com> 15 * Marc Gauthier 16 * Kevin Chea 17 */ 18 19 #include <linux/kernel.h> 20 #include <linux/errno.h> 21 #include <linux/bootmem.h> 22 #include <linux/gfp.h> 23 #include <linux/swap.h> 24 #include <linux/mman.h> 25 #include <linux/nodemask.h> 26 #include <linux/mm.h> 27 28 #include <asm/bootparam.h> 29 #include <asm/page.h> 30 #include <asm/sections.h> 31 #include <asm/sysmem.h> 32 33 struct sysmem_info sysmem __initdata; 34 35 /* 36 * Find bank with maximal .start such that bank.start <= start 37 */ 38 static inline struct meminfo * __init find_bank(unsigned long start) 39 { 40 unsigned i; 41 struct meminfo *it = NULL; 42 43 for (i = 0; i < sysmem.nr_banks; ++i) 44 if (sysmem.bank[i].start <= start) 45 it = sysmem.bank + i; 46 else 47 break; 48 return it; 49 } 50 51 /* 52 * Move all memory banks starting at 'from' to a new place at 'to', 53 * adjust nr_banks accordingly. 54 * Both 'from' and 'to' must be inside the sysmem.bank. 55 * 56 * Returns: 0 (success), -ENOMEM (not enough space in the sysmem.bank). 57 */ 58 static int __init move_banks(struct meminfo *to, struct meminfo *from) 59 { 60 unsigned n = sysmem.nr_banks - (from - sysmem.bank); 61 62 if (to > from && to - from + sysmem.nr_banks > SYSMEM_BANKS_MAX) 63 return -ENOMEM; 64 if (to != from) 65 memmove(to, from, n * sizeof(struct meminfo)); 66 sysmem.nr_banks += to - from; 67 return 0; 68 } 69 70 /* 71 * Add new bank to sysmem. Resulting sysmem is the union of bytes of the 72 * original sysmem and the new bank. 73 * 74 * Returns: 0 (success), < 0 (error) 75 */ 76 int __init add_sysmem_bank(unsigned long start, unsigned long end) 77 { 78 unsigned i; 79 struct meminfo *it = NULL; 80 unsigned long sz; 81 unsigned long bank_sz = 0; 82 83 if (start == end || 84 (start < end) != (PAGE_ALIGN(start) < (end & PAGE_MASK))) { 85 pr_warn("Ignoring small memory bank 0x%08lx size: %ld bytes\n", 86 start, end - start); 87 return -EINVAL; 88 } 89 90 start = PAGE_ALIGN(start); 91 end &= PAGE_MASK; 92 sz = end - start; 93 94 it = find_bank(start); 95 96 if (it) 97 bank_sz = it->end - it->start; 98 99 if (it && bank_sz >= start - it->start) { 100 if (end - it->start > bank_sz) 101 it->end = end; 102 else 103 return 0; 104 } else { 105 if (!it) 106 it = sysmem.bank; 107 else 108 ++it; 109 110 if (it - sysmem.bank < sysmem.nr_banks && 111 it->start - start <= sz) { 112 it->start = start; 113 if (it->end - it->start < sz) 114 it->end = end; 115 else 116 return 0; 117 } else { 118 if (move_banks(it + 1, it) < 0) { 119 pr_warn("Ignoring memory bank 0x%08lx size %ld bytes\n", 120 start, end - start); 121 return -EINVAL; 122 } 123 it->start = start; 124 it->end = end; 125 return 0; 126 } 127 } 128 sz = it->end - it->start; 129 for (i = it + 1 - sysmem.bank; i < sysmem.nr_banks; ++i) 130 if (sysmem.bank[i].start - it->start <= sz) { 131 if (sz < sysmem.bank[i].end - it->start) 132 it->end = sysmem.bank[i].end; 133 } else { 134 break; 135 } 136 137 move_banks(it + 1, sysmem.bank + i); 138 return 0; 139 } 140 141 /* 142 * mem_reserve(start, end, must_exist) 143 * 144 * Reserve some memory from the memory pool. 145 * If must_exist is set and a part of the region being reserved does not exist 146 * memory map is not altered. 147 * 148 * Parameters: 149 * start Start of region, 150 * end End of region, 151 * must_exist Must exist in memory pool. 152 * 153 * Returns: 154 * 0 (success) 155 * < 0 (error) 156 */ 157 158 int __init mem_reserve(unsigned long start, unsigned long end, int must_exist) 159 { 160 struct meminfo *it; 161 struct meminfo *rm = NULL; 162 unsigned long sz; 163 unsigned long bank_sz = 0; 164 165 start = start & PAGE_MASK; 166 end = PAGE_ALIGN(end); 167 sz = end - start; 168 if (!sz) 169 return -EINVAL; 170 171 it = find_bank(start); 172 173 if (it) 174 bank_sz = it->end - it->start; 175 176 if ((!it || end - it->start > bank_sz) && must_exist) { 177 pr_warn("mem_reserve: [0x%0lx, 0x%0lx) not in any region!\n", 178 start, end); 179 return -EINVAL; 180 } 181 182 if (it && start - it->start < bank_sz) { 183 if (start == it->start) { 184 if (end - it->start < bank_sz) { 185 it->start = end; 186 return 0; 187 } else { 188 rm = it; 189 } 190 } else { 191 it->end = start; 192 if (end - it->start < bank_sz) 193 return add_sysmem_bank(end, 194 it->start + bank_sz); 195 ++it; 196 } 197 } 198 199 if (!it) 200 it = sysmem.bank; 201 202 for (; it < sysmem.bank + sysmem.nr_banks; ++it) { 203 if (it->end - start <= sz) { 204 if (!rm) 205 rm = it; 206 } else { 207 if (it->start - start < sz) 208 it->start = end; 209 break; 210 } 211 } 212 213 if (rm) 214 move_banks(rm, it); 215 216 return 0; 217 } 218 219 220 /* 221 * Initialize the bootmem system and give it all low memory we have available. 222 */ 223 224 void __init bootmem_init(void) 225 { 226 unsigned long pfn; 227 unsigned long bootmap_start, bootmap_size; 228 int i; 229 230 max_low_pfn = max_pfn = 0; 231 min_low_pfn = ~0; 232 233 for (i=0; i < sysmem.nr_banks; i++) { 234 pfn = PAGE_ALIGN(sysmem.bank[i].start) >> PAGE_SHIFT; 235 if (pfn < min_low_pfn) 236 min_low_pfn = pfn; 237 pfn = PAGE_ALIGN(sysmem.bank[i].end - 1) >> PAGE_SHIFT; 238 if (pfn > max_pfn) 239 max_pfn = pfn; 240 } 241 242 if (min_low_pfn > max_pfn) 243 panic("No memory found!\n"); 244 245 max_low_pfn = max_pfn < MAX_MEM_PFN >> PAGE_SHIFT ? 246 max_pfn : MAX_MEM_PFN >> PAGE_SHIFT; 247 248 /* Find an area to use for the bootmem bitmap. */ 249 250 bootmap_size = bootmem_bootmap_pages(max_low_pfn - min_low_pfn); 251 bootmap_size <<= PAGE_SHIFT; 252 bootmap_start = ~0; 253 254 for (i=0; i<sysmem.nr_banks; i++) 255 if (sysmem.bank[i].end - sysmem.bank[i].start >= bootmap_size) { 256 bootmap_start = sysmem.bank[i].start; 257 break; 258 } 259 260 if (bootmap_start == ~0UL) 261 panic("Cannot find %ld bytes for bootmap\n", bootmap_size); 262 263 /* Reserve the bootmem bitmap area */ 264 265 mem_reserve(bootmap_start, bootmap_start + bootmap_size, 1); 266 bootmap_size = init_bootmem_node(NODE_DATA(0), 267 bootmap_start >> PAGE_SHIFT, 268 min_low_pfn, 269 max_low_pfn); 270 271 /* Add all remaining memory pieces into the bootmem map */ 272 273 for (i = 0; i < sysmem.nr_banks; i++) { 274 if (sysmem.bank[i].start >> PAGE_SHIFT < max_low_pfn) { 275 unsigned long end = min(max_low_pfn << PAGE_SHIFT, 276 sysmem.bank[i].end); 277 free_bootmem(sysmem.bank[i].start, 278 end - sysmem.bank[i].start); 279 } 280 } 281 282 } 283 284 285 void __init zones_init(void) 286 { 287 unsigned long zones_size[MAX_NR_ZONES]; 288 int i; 289 290 /* All pages are DMA-able, so we put them all in the DMA zone. */ 291 292 zones_size[ZONE_DMA] = max_low_pfn - ARCH_PFN_OFFSET; 293 for (i = 1; i < MAX_NR_ZONES; i++) 294 zones_size[i] = 0; 295 296 #ifdef CONFIG_HIGHMEM 297 zones_size[ZONE_HIGHMEM] = max_pfn - max_low_pfn; 298 #endif 299 300 free_area_init_node(0, zones_size, ARCH_PFN_OFFSET, NULL); 301 } 302 303 /* 304 * Initialize memory pages. 305 */ 306 307 void __init mem_init(void) 308 { 309 max_mapnr = max_low_pfn - ARCH_PFN_OFFSET; 310 high_memory = (void *) __va(max_low_pfn << PAGE_SHIFT); 311 312 #ifdef CONFIG_HIGHMEM 313 #error HIGHGMEM not implemented in init.c 314 #endif 315 316 free_all_bootmem(); 317 318 mem_init_print_info(NULL); 319 } 320 321 #ifdef CONFIG_BLK_DEV_INITRD 322 extern int initrd_is_mapped; 323 324 void free_initrd_mem(unsigned long start, unsigned long end) 325 { 326 if (initrd_is_mapped) 327 free_reserved_area((void *)start, (void *)end, -1, "initrd"); 328 } 329 #endif 330 331 void free_initmem(void) 332 { 333 free_initmem_default(-1); 334 } 335 336 static void __init parse_memmap_one(char *p) 337 { 338 char *oldp; 339 unsigned long start_at, mem_size; 340 341 if (!p) 342 return; 343 344 oldp = p; 345 mem_size = memparse(p, &p); 346 if (p == oldp) 347 return; 348 349 switch (*p) { 350 case '@': 351 start_at = memparse(p + 1, &p); 352 add_sysmem_bank(start_at, start_at + mem_size); 353 break; 354 355 case '$': 356 start_at = memparse(p + 1, &p); 357 mem_reserve(start_at, start_at + mem_size, 0); 358 break; 359 360 case 0: 361 mem_reserve(mem_size, 0, 0); 362 break; 363 364 default: 365 pr_warn("Unrecognized memmap syntax: %s\n", p); 366 break; 367 } 368 } 369 370 static int __init parse_memmap_opt(char *str) 371 { 372 while (str) { 373 char *k = strchr(str, ','); 374 375 if (k) 376 *k++ = 0; 377 378 parse_memmap_one(str); 379 str = k; 380 } 381 382 return 0; 383 } 384 early_param("memmap", parse_memmap_opt); 385