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