1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 1995 Linus Torvalds 7 * Copyright (C) 1995 Waldorf Electronics 8 * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 03 Ralf Baechle 9 * Copyright (C) 1996 Stoned Elipot 10 * Copyright (C) 1999 Silicon Graphics, Inc. 11 * Copyright (C) 2000, 2001, 2002, 2007 Maciej W. Rozycki 12 */ 13 #include <linux/init.h> 14 #include <linux/ioport.h> 15 #include <linux/export.h> 16 #include <linux/screen_info.h> 17 #include <linux/memblock.h> 18 #include <linux/bootmem.h> 19 #include <linux/initrd.h> 20 #include <linux/root_dev.h> 21 #include <linux/highmem.h> 22 #include <linux/console.h> 23 #include <linux/pfn.h> 24 #include <linux/debugfs.h> 25 #include <linux/kexec.h> 26 #include <linux/sizes.h> 27 #include <linux/device.h> 28 #include <linux/dma-contiguous.h> 29 #include <linux/decompress/generic.h> 30 #include <linux/of_fdt.h> 31 32 #include <asm/addrspace.h> 33 #include <asm/bootinfo.h> 34 #include <asm/bugs.h> 35 #include <asm/cache.h> 36 #include <asm/cdmm.h> 37 #include <asm/cpu.h> 38 #include <asm/debug.h> 39 #include <asm/sections.h> 40 #include <asm/setup.h> 41 #include <asm/smp-ops.h> 42 #include <asm/prom.h> 43 44 #ifdef CONFIG_MIPS_ELF_APPENDED_DTB 45 const char __section(.appended_dtb) __appended_dtb[0x100000]; 46 #endif /* CONFIG_MIPS_ELF_APPENDED_DTB */ 47 48 struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly; 49 50 EXPORT_SYMBOL(cpu_data); 51 52 #ifdef CONFIG_VT 53 struct screen_info screen_info; 54 #endif 55 56 /* 57 * Setup information 58 * 59 * These are initialized so they are in the .data section 60 */ 61 unsigned long mips_machtype __read_mostly = MACH_UNKNOWN; 62 63 EXPORT_SYMBOL(mips_machtype); 64 65 struct boot_mem_map boot_mem_map; 66 67 static char __initdata command_line[COMMAND_LINE_SIZE]; 68 char __initdata arcs_cmdline[COMMAND_LINE_SIZE]; 69 70 #ifdef CONFIG_CMDLINE_BOOL 71 static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE; 72 #endif 73 74 /* 75 * mips_io_port_base is the begin of the address space to which x86 style 76 * I/O ports are mapped. 77 */ 78 const unsigned long mips_io_port_base = -1; 79 EXPORT_SYMBOL(mips_io_port_base); 80 81 static struct resource code_resource = { .name = "Kernel code", }; 82 static struct resource data_resource = { .name = "Kernel data", }; 83 84 static void *detect_magic __initdata = detect_memory_region; 85 86 void __init add_memory_region(phys_addr_t start, phys_addr_t size, long type) 87 { 88 int x = boot_mem_map.nr_map; 89 int i; 90 91 /* 92 * If the region reaches the top of the physical address space, adjust 93 * the size slightly so that (start + size) doesn't overflow 94 */ 95 if (start + size - 1 == (phys_addr_t)ULLONG_MAX) 96 --size; 97 98 /* Sanity check */ 99 if (start + size < start) { 100 pr_warn("Trying to add an invalid memory region, skipped\n"); 101 return; 102 } 103 104 /* 105 * Try to merge with existing entry, if any. 106 */ 107 for (i = 0; i < boot_mem_map.nr_map; i++) { 108 struct boot_mem_map_entry *entry = boot_mem_map.map + i; 109 unsigned long top; 110 111 if (entry->type != type) 112 continue; 113 114 if (start + size < entry->addr) 115 continue; /* no overlap */ 116 117 if (entry->addr + entry->size < start) 118 continue; /* no overlap */ 119 120 top = max(entry->addr + entry->size, start + size); 121 entry->addr = min(entry->addr, start); 122 entry->size = top - entry->addr; 123 124 return; 125 } 126 127 if (boot_mem_map.nr_map == BOOT_MEM_MAP_MAX) { 128 pr_err("Ooops! Too many entries in the memory map!\n"); 129 return; 130 } 131 132 boot_mem_map.map[x].addr = start; 133 boot_mem_map.map[x].size = size; 134 boot_mem_map.map[x].type = type; 135 boot_mem_map.nr_map++; 136 } 137 138 void __init detect_memory_region(phys_addr_t start, phys_addr_t sz_min, phys_addr_t sz_max) 139 { 140 void *dm = &detect_magic; 141 phys_addr_t size; 142 143 for (size = sz_min; size < sz_max; size <<= 1) { 144 if (!memcmp(dm, dm + size, sizeof(detect_magic))) 145 break; 146 } 147 148 pr_debug("Memory: %lluMB of RAM detected at 0x%llx (min: %lluMB, max: %lluMB)\n", 149 ((unsigned long long) size) / SZ_1M, 150 (unsigned long long) start, 151 ((unsigned long long) sz_min) / SZ_1M, 152 ((unsigned long long) sz_max) / SZ_1M); 153 154 add_memory_region(start, size, BOOT_MEM_RAM); 155 } 156 157 bool __init memory_region_available(phys_addr_t start, phys_addr_t size) 158 { 159 int i; 160 bool in_ram = false, free = true; 161 162 for (i = 0; i < boot_mem_map.nr_map; i++) { 163 phys_addr_t start_, end_; 164 165 start_ = boot_mem_map.map[i].addr; 166 end_ = boot_mem_map.map[i].addr + boot_mem_map.map[i].size; 167 168 switch (boot_mem_map.map[i].type) { 169 case BOOT_MEM_RAM: 170 if (start >= start_ && start + size <= end_) 171 in_ram = true; 172 break; 173 case BOOT_MEM_RESERVED: 174 if ((start >= start_ && start < end_) || 175 (start < start_ && start + size >= start_)) 176 free = false; 177 break; 178 default: 179 continue; 180 } 181 } 182 183 return in_ram && free; 184 } 185 186 static void __init print_memory_map(void) 187 { 188 int i; 189 const int field = 2 * sizeof(unsigned long); 190 191 for (i = 0; i < boot_mem_map.nr_map; i++) { 192 printk(KERN_INFO " memory: %0*Lx @ %0*Lx ", 193 field, (unsigned long long) boot_mem_map.map[i].size, 194 field, (unsigned long long) boot_mem_map.map[i].addr); 195 196 switch (boot_mem_map.map[i].type) { 197 case BOOT_MEM_RAM: 198 printk(KERN_CONT "(usable)\n"); 199 break; 200 case BOOT_MEM_INIT_RAM: 201 printk(KERN_CONT "(usable after init)\n"); 202 break; 203 case BOOT_MEM_ROM_DATA: 204 printk(KERN_CONT "(ROM data)\n"); 205 break; 206 case BOOT_MEM_RESERVED: 207 printk(KERN_CONT "(reserved)\n"); 208 break; 209 default: 210 printk(KERN_CONT "type %lu\n", boot_mem_map.map[i].type); 211 break; 212 } 213 } 214 } 215 216 /* 217 * Manage initrd 218 */ 219 #ifdef CONFIG_BLK_DEV_INITRD 220 221 static int __init rd_start_early(char *p) 222 { 223 unsigned long start = memparse(p, &p); 224 225 #ifdef CONFIG_64BIT 226 /* Guess if the sign extension was forgotten by bootloader */ 227 if (start < XKPHYS) 228 start = (int)start; 229 #endif 230 initrd_start = start; 231 initrd_end += start; 232 return 0; 233 } 234 early_param("rd_start", rd_start_early); 235 236 static int __init rd_size_early(char *p) 237 { 238 initrd_end += memparse(p, &p); 239 return 0; 240 } 241 early_param("rd_size", rd_size_early); 242 243 /* it returns the next free pfn after initrd */ 244 static unsigned long __init init_initrd(void) 245 { 246 unsigned long end; 247 248 /* 249 * Board specific code or command line parser should have 250 * already set up initrd_start and initrd_end. In these cases 251 * perfom sanity checks and use them if all looks good. 252 */ 253 if (!initrd_start || initrd_end <= initrd_start) 254 goto disable; 255 256 if (initrd_start & ~PAGE_MASK) { 257 pr_err("initrd start must be page aligned\n"); 258 goto disable; 259 } 260 if (initrd_start < PAGE_OFFSET) { 261 pr_err("initrd start < PAGE_OFFSET\n"); 262 goto disable; 263 } 264 265 /* 266 * Sanitize initrd addresses. For example firmware 267 * can't guess if they need to pass them through 268 * 64-bits values if the kernel has been built in pure 269 * 32-bit. We need also to switch from KSEG0 to XKPHYS 270 * addresses now, so the code can now safely use __pa(). 271 */ 272 end = __pa(initrd_end); 273 initrd_end = (unsigned long)__va(end); 274 initrd_start = (unsigned long)__va(__pa(initrd_start)); 275 276 ROOT_DEV = Root_RAM0; 277 return PFN_UP(end); 278 disable: 279 initrd_start = 0; 280 initrd_end = 0; 281 return 0; 282 } 283 284 /* In some conditions (e.g. big endian bootloader with a little endian 285 kernel), the initrd might appear byte swapped. Try to detect this and 286 byte swap it if needed. */ 287 static void __init maybe_bswap_initrd(void) 288 { 289 #if defined(CONFIG_CPU_CAVIUM_OCTEON) 290 u64 buf; 291 292 /* Check for CPIO signature */ 293 if (!memcmp((void *)initrd_start, "070701", 6)) 294 return; 295 296 /* Check for compressed initrd */ 297 if (decompress_method((unsigned char *)initrd_start, 8, NULL)) 298 return; 299 300 /* Try again with a byte swapped header */ 301 buf = swab64p((u64 *)initrd_start); 302 if (!memcmp(&buf, "070701", 6) || 303 decompress_method((unsigned char *)(&buf), 8, NULL)) { 304 unsigned long i; 305 306 pr_info("Byteswapped initrd detected\n"); 307 for (i = initrd_start; i < ALIGN(initrd_end, 8); i += 8) 308 swab64s((u64 *)i); 309 } 310 #endif 311 } 312 313 static void __init finalize_initrd(void) 314 { 315 unsigned long size = initrd_end - initrd_start; 316 317 if (size == 0) { 318 printk(KERN_INFO "Initrd not found or empty"); 319 goto disable; 320 } 321 if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) { 322 printk(KERN_ERR "Initrd extends beyond end of memory"); 323 goto disable; 324 } 325 326 maybe_bswap_initrd(); 327 328 reserve_bootmem(__pa(initrd_start), size, BOOTMEM_DEFAULT); 329 initrd_below_start_ok = 1; 330 331 pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n", 332 initrd_start, size); 333 return; 334 disable: 335 printk(KERN_CONT " - disabling initrd\n"); 336 initrd_start = 0; 337 initrd_end = 0; 338 } 339 340 #else /* !CONFIG_BLK_DEV_INITRD */ 341 342 static unsigned long __init init_initrd(void) 343 { 344 return 0; 345 } 346 347 #define finalize_initrd() do {} while (0) 348 349 #endif 350 351 /* 352 * Initialize the bootmem allocator. It also setup initrd related data 353 * if needed. 354 */ 355 #if defined(CONFIG_SGI_IP27) || (defined(CONFIG_CPU_LOONGSON3) && defined(CONFIG_NUMA)) 356 357 static void __init bootmem_init(void) 358 { 359 init_initrd(); 360 finalize_initrd(); 361 } 362 363 #else /* !CONFIG_SGI_IP27 */ 364 365 static unsigned long __init bootmap_bytes(unsigned long pages) 366 { 367 unsigned long bytes = DIV_ROUND_UP(pages, 8); 368 369 return ALIGN(bytes, sizeof(long)); 370 } 371 372 static void __init bootmem_init(void) 373 { 374 unsigned long reserved_end; 375 unsigned long mapstart = ~0UL; 376 unsigned long bootmap_size; 377 bool bootmap_valid = false; 378 int i; 379 380 /* 381 * Sanity check any INITRD first. We don't take it into account 382 * for bootmem setup initially, rely on the end-of-kernel-code 383 * as our memory range starting point. Once bootmem is inited we 384 * will reserve the area used for the initrd. 385 */ 386 init_initrd(); 387 reserved_end = (unsigned long) PFN_UP(__pa_symbol(&_end)); 388 389 /* 390 * max_low_pfn is not a number of pages. The number of pages 391 * of the system is given by 'max_low_pfn - min_low_pfn'. 392 */ 393 min_low_pfn = ~0UL; 394 max_low_pfn = 0; 395 396 /* 397 * Find the highest page frame number we have available. 398 */ 399 for (i = 0; i < boot_mem_map.nr_map; i++) { 400 unsigned long start, end; 401 402 if (boot_mem_map.map[i].type != BOOT_MEM_RAM) 403 continue; 404 405 start = PFN_UP(boot_mem_map.map[i].addr); 406 end = PFN_DOWN(boot_mem_map.map[i].addr 407 + boot_mem_map.map[i].size); 408 409 #ifndef CONFIG_HIGHMEM 410 /* 411 * Skip highmem here so we get an accurate max_low_pfn if low 412 * memory stops short of high memory. 413 * If the region overlaps HIGHMEM_START, end is clipped so 414 * max_pfn excludes the highmem portion. 415 */ 416 if (start >= PFN_DOWN(HIGHMEM_START)) 417 continue; 418 if (end > PFN_DOWN(HIGHMEM_START)) 419 end = PFN_DOWN(HIGHMEM_START); 420 #endif 421 422 if (end > max_low_pfn) 423 max_low_pfn = end; 424 if (start < min_low_pfn) 425 min_low_pfn = start; 426 if (end <= reserved_end) 427 continue; 428 #ifdef CONFIG_BLK_DEV_INITRD 429 /* Skip zones before initrd and initrd itself */ 430 if (initrd_end && end <= (unsigned long)PFN_UP(__pa(initrd_end))) 431 continue; 432 #endif 433 if (start >= mapstart) 434 continue; 435 mapstart = max(reserved_end, start); 436 } 437 438 if (min_low_pfn >= max_low_pfn) 439 panic("Incorrect memory mapping !!!"); 440 if (min_low_pfn > ARCH_PFN_OFFSET) { 441 pr_info("Wasting %lu bytes for tracking %lu unused pages\n", 442 (min_low_pfn - ARCH_PFN_OFFSET) * sizeof(struct page), 443 min_low_pfn - ARCH_PFN_OFFSET); 444 } else if (min_low_pfn < ARCH_PFN_OFFSET) { 445 pr_info("%lu free pages won't be used\n", 446 ARCH_PFN_OFFSET - min_low_pfn); 447 } 448 min_low_pfn = ARCH_PFN_OFFSET; 449 450 /* 451 * Determine low and high memory ranges 452 */ 453 max_pfn = max_low_pfn; 454 if (max_low_pfn > PFN_DOWN(HIGHMEM_START)) { 455 #ifdef CONFIG_HIGHMEM 456 highstart_pfn = PFN_DOWN(HIGHMEM_START); 457 highend_pfn = max_low_pfn; 458 #endif 459 max_low_pfn = PFN_DOWN(HIGHMEM_START); 460 } 461 462 #ifdef CONFIG_BLK_DEV_INITRD 463 /* 464 * mapstart should be after initrd_end 465 */ 466 if (initrd_end) 467 mapstart = max(mapstart, (unsigned long)PFN_UP(__pa(initrd_end))); 468 #endif 469 470 /* 471 * check that mapstart doesn't overlap with any of 472 * memory regions that have been reserved through eg. DTB 473 */ 474 bootmap_size = bootmap_bytes(max_low_pfn - min_low_pfn); 475 476 bootmap_valid = memory_region_available(PFN_PHYS(mapstart), 477 bootmap_size); 478 for (i = 0; i < boot_mem_map.nr_map && !bootmap_valid; i++) { 479 unsigned long mapstart_addr; 480 481 switch (boot_mem_map.map[i].type) { 482 case BOOT_MEM_RESERVED: 483 mapstart_addr = PFN_ALIGN(boot_mem_map.map[i].addr + 484 boot_mem_map.map[i].size); 485 if (PHYS_PFN(mapstart_addr) < mapstart) 486 break; 487 488 bootmap_valid = memory_region_available(mapstart_addr, 489 bootmap_size); 490 if (bootmap_valid) 491 mapstart = PHYS_PFN(mapstart_addr); 492 break; 493 default: 494 break; 495 } 496 } 497 498 if (!bootmap_valid) 499 panic("No memory area to place a bootmap bitmap"); 500 501 /* 502 * Initialize the boot-time allocator with low memory only. 503 */ 504 if (bootmap_size != init_bootmem_node(NODE_DATA(0), mapstart, 505 min_low_pfn, max_low_pfn)) 506 panic("Unexpected memory size required for bootmap"); 507 508 for (i = 0; i < boot_mem_map.nr_map; i++) { 509 unsigned long start, end; 510 511 start = PFN_UP(boot_mem_map.map[i].addr); 512 end = PFN_DOWN(boot_mem_map.map[i].addr 513 + boot_mem_map.map[i].size); 514 515 if (start <= min_low_pfn) 516 start = min_low_pfn; 517 if (start >= end) 518 continue; 519 520 #ifndef CONFIG_HIGHMEM 521 if (end > max_low_pfn) 522 end = max_low_pfn; 523 524 /* 525 * ... finally, is the area going away? 526 */ 527 if (end <= start) 528 continue; 529 #endif 530 531 memblock_add_node(PFN_PHYS(start), PFN_PHYS(end - start), 0); 532 } 533 534 /* 535 * Register fully available low RAM pages with the bootmem allocator. 536 */ 537 for (i = 0; i < boot_mem_map.nr_map; i++) { 538 unsigned long start, end, size; 539 540 start = PFN_UP(boot_mem_map.map[i].addr); 541 end = PFN_DOWN(boot_mem_map.map[i].addr 542 + boot_mem_map.map[i].size); 543 544 /* 545 * Reserve usable memory. 546 */ 547 switch (boot_mem_map.map[i].type) { 548 case BOOT_MEM_RAM: 549 break; 550 case BOOT_MEM_INIT_RAM: 551 memory_present(0, start, end); 552 continue; 553 default: 554 /* Not usable memory */ 555 if (start > min_low_pfn && end < max_low_pfn) 556 reserve_bootmem(boot_mem_map.map[i].addr, 557 boot_mem_map.map[i].size, 558 BOOTMEM_DEFAULT); 559 continue; 560 } 561 562 /* 563 * We are rounding up the start address of usable memory 564 * and at the end of the usable range downwards. 565 */ 566 if (start >= max_low_pfn) 567 continue; 568 if (start < reserved_end) 569 start = reserved_end; 570 if (end > max_low_pfn) 571 end = max_low_pfn; 572 573 /* 574 * ... finally, is the area going away? 575 */ 576 if (end <= start) 577 continue; 578 size = end - start; 579 580 /* Register lowmem ranges */ 581 free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT); 582 memory_present(0, start, end); 583 } 584 585 /* 586 * Reserve the bootmap memory. 587 */ 588 reserve_bootmem(PFN_PHYS(mapstart), bootmap_size, BOOTMEM_DEFAULT); 589 590 #ifdef CONFIG_RELOCATABLE 591 /* 592 * The kernel reserves all memory below its _end symbol as bootmem, 593 * but the kernel may now be at a much higher address. The memory 594 * between the original and new locations may be returned to the system. 595 */ 596 if (__pa_symbol(_text) > __pa_symbol(VMLINUX_LOAD_ADDRESS)) { 597 unsigned long offset; 598 extern void show_kernel_relocation(const char *level); 599 600 offset = __pa_symbol(_text) - __pa_symbol(VMLINUX_LOAD_ADDRESS); 601 free_bootmem(__pa_symbol(VMLINUX_LOAD_ADDRESS), offset); 602 603 #if defined(CONFIG_DEBUG_KERNEL) && defined(CONFIG_DEBUG_INFO) 604 /* 605 * This information is necessary when debugging the kernel 606 * But is a security vulnerability otherwise! 607 */ 608 show_kernel_relocation(KERN_INFO); 609 #endif 610 } 611 #endif 612 613 /* 614 * Reserve initrd memory if needed. 615 */ 616 finalize_initrd(); 617 } 618 619 #endif /* CONFIG_SGI_IP27 */ 620 621 /* 622 * arch_mem_init - initialize memory management subsystem 623 * 624 * o plat_mem_setup() detects the memory configuration and will record detected 625 * memory areas using add_memory_region. 626 * 627 * At this stage the memory configuration of the system is known to the 628 * kernel but generic memory management system is still entirely uninitialized. 629 * 630 * o bootmem_init() 631 * o sparse_init() 632 * o paging_init() 633 * o dma_contiguous_reserve() 634 * 635 * At this stage the bootmem allocator is ready to use. 636 * 637 * NOTE: historically plat_mem_setup did the entire platform initialization. 638 * This was rather impractical because it meant plat_mem_setup had to 639 * get away without any kind of memory allocator. To keep old code from 640 * breaking plat_setup was just renamed to plat_mem_setup and a second platform 641 * initialization hook for anything else was introduced. 642 */ 643 644 static int usermem __initdata; 645 646 static int __init early_parse_mem(char *p) 647 { 648 phys_addr_t start, size; 649 650 /* 651 * If a user specifies memory size, we 652 * blow away any automatically generated 653 * size. 654 */ 655 if (usermem == 0) { 656 boot_mem_map.nr_map = 0; 657 usermem = 1; 658 } 659 start = 0; 660 size = memparse(p, &p); 661 if (*p == '@') 662 start = memparse(p + 1, &p); 663 664 add_memory_region(start, size, BOOT_MEM_RAM); 665 666 if (start && start > PHYS_OFFSET) 667 add_memory_region(PHYS_OFFSET, start - PHYS_OFFSET, 668 BOOT_MEM_RESERVED); 669 return 0; 670 } 671 early_param("mem", early_parse_mem); 672 673 #ifdef CONFIG_PROC_VMCORE 674 unsigned long setup_elfcorehdr, setup_elfcorehdr_size; 675 static int __init early_parse_elfcorehdr(char *p) 676 { 677 int i; 678 679 setup_elfcorehdr = memparse(p, &p); 680 681 for (i = 0; i < boot_mem_map.nr_map; i++) { 682 unsigned long start = boot_mem_map.map[i].addr; 683 unsigned long end = (boot_mem_map.map[i].addr + 684 boot_mem_map.map[i].size); 685 if (setup_elfcorehdr >= start && setup_elfcorehdr < end) { 686 /* 687 * Reserve from the elf core header to the end of 688 * the memory segment, that should all be kdump 689 * reserved memory. 690 */ 691 setup_elfcorehdr_size = end - setup_elfcorehdr; 692 break; 693 } 694 } 695 /* 696 * If we don't find it in the memory map, then we shouldn't 697 * have to worry about it, as the new kernel won't use it. 698 */ 699 return 0; 700 } 701 early_param("elfcorehdr", early_parse_elfcorehdr); 702 #endif 703 704 static void __init arch_mem_addpart(phys_addr_t mem, phys_addr_t end, int type) 705 { 706 phys_addr_t size; 707 int i; 708 709 size = end - mem; 710 if (!size) 711 return; 712 713 /* Make sure it is in the boot_mem_map */ 714 for (i = 0; i < boot_mem_map.nr_map; i++) { 715 if (mem >= boot_mem_map.map[i].addr && 716 mem < (boot_mem_map.map[i].addr + 717 boot_mem_map.map[i].size)) 718 return; 719 } 720 add_memory_region(mem, size, type); 721 } 722 723 #ifdef CONFIG_KEXEC 724 static inline unsigned long long get_total_mem(void) 725 { 726 unsigned long long total; 727 728 total = max_pfn - min_low_pfn; 729 return total << PAGE_SHIFT; 730 } 731 732 static void __init mips_parse_crashkernel(void) 733 { 734 unsigned long long total_mem; 735 unsigned long long crash_size, crash_base; 736 int ret; 737 738 total_mem = get_total_mem(); 739 ret = parse_crashkernel(boot_command_line, total_mem, 740 &crash_size, &crash_base); 741 if (ret != 0 || crash_size <= 0) 742 return; 743 744 if (!memory_region_available(crash_base, crash_size)) { 745 pr_warn("Invalid memory region reserved for crash kernel\n"); 746 return; 747 } 748 749 crashk_res.start = crash_base; 750 crashk_res.end = crash_base + crash_size - 1; 751 } 752 753 static void __init request_crashkernel(struct resource *res) 754 { 755 int ret; 756 757 if (crashk_res.start == crashk_res.end) 758 return; 759 760 ret = request_resource(res, &crashk_res); 761 if (!ret) 762 pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n", 763 (unsigned long)((crashk_res.end - 764 crashk_res.start + 1) >> 20), 765 (unsigned long)(crashk_res.start >> 20)); 766 } 767 #else /* !defined(CONFIG_KEXEC) */ 768 static void __init mips_parse_crashkernel(void) 769 { 770 } 771 772 static void __init request_crashkernel(struct resource *res) 773 { 774 } 775 #endif /* !defined(CONFIG_KEXEC) */ 776 777 #define USE_PROM_CMDLINE IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_BOOTLOADER) 778 #define USE_DTB_CMDLINE IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB) 779 #define EXTEND_WITH_PROM IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND) 780 #define BUILTIN_EXTEND_WITH_PROM \ 781 IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND) 782 783 static void __init arch_mem_init(char **cmdline_p) 784 { 785 struct memblock_region *reg; 786 extern void plat_mem_setup(void); 787 788 /* call board setup routine */ 789 plat_mem_setup(); 790 791 /* 792 * Make sure all kernel memory is in the maps. The "UP" and 793 * "DOWN" are opposite for initdata since if it crosses over 794 * into another memory section you don't want that to be 795 * freed when the initdata is freed. 796 */ 797 arch_mem_addpart(PFN_DOWN(__pa_symbol(&_text)) << PAGE_SHIFT, 798 PFN_UP(__pa_symbol(&_edata)) << PAGE_SHIFT, 799 BOOT_MEM_RAM); 800 arch_mem_addpart(PFN_UP(__pa_symbol(&__init_begin)) << PAGE_SHIFT, 801 PFN_DOWN(__pa_symbol(&__init_end)) << PAGE_SHIFT, 802 BOOT_MEM_INIT_RAM); 803 804 pr_info("Determined physical RAM map:\n"); 805 print_memory_map(); 806 807 #if defined(CONFIG_CMDLINE_BOOL) && defined(CONFIG_CMDLINE_OVERRIDE) 808 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE); 809 #else 810 if ((USE_PROM_CMDLINE && arcs_cmdline[0]) || 811 (USE_DTB_CMDLINE && !boot_command_line[0])) 812 strlcpy(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 813 814 if (EXTEND_WITH_PROM && arcs_cmdline[0]) { 815 if (boot_command_line[0]) 816 strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); 817 strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 818 } 819 820 #if defined(CONFIG_CMDLINE_BOOL) 821 if (builtin_cmdline[0]) { 822 if (boot_command_line[0]) 823 strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); 824 strlcat(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE); 825 } 826 827 if (BUILTIN_EXTEND_WITH_PROM && arcs_cmdline[0]) { 828 if (boot_command_line[0]) 829 strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); 830 strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 831 } 832 #endif 833 #endif 834 strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE); 835 836 *cmdline_p = command_line; 837 838 parse_early_param(); 839 840 if (usermem) { 841 pr_info("User-defined physical RAM map:\n"); 842 print_memory_map(); 843 } 844 845 early_init_fdt_reserve_self(); 846 early_init_fdt_scan_reserved_mem(); 847 848 bootmem_init(); 849 #ifdef CONFIG_PROC_VMCORE 850 if (setup_elfcorehdr && setup_elfcorehdr_size) { 851 printk(KERN_INFO "kdump reserved memory at %lx-%lx\n", 852 setup_elfcorehdr, setup_elfcorehdr_size); 853 reserve_bootmem(setup_elfcorehdr, setup_elfcorehdr_size, 854 BOOTMEM_DEFAULT); 855 } 856 #endif 857 858 mips_parse_crashkernel(); 859 #ifdef CONFIG_KEXEC 860 if (crashk_res.start != crashk_res.end) 861 reserve_bootmem(crashk_res.start, 862 crashk_res.end - crashk_res.start + 1, 863 BOOTMEM_DEFAULT); 864 #endif 865 device_tree_init(); 866 sparse_init(); 867 plat_swiotlb_setup(); 868 869 dma_contiguous_reserve(PFN_PHYS(max_low_pfn)); 870 /* Tell bootmem about cma reserved memblock section */ 871 for_each_memblock(reserved, reg) 872 if (reg->size != 0) 873 reserve_bootmem(reg->base, reg->size, BOOTMEM_DEFAULT); 874 875 reserve_bootmem_region(__pa_symbol(&__nosave_begin), 876 __pa_symbol(&__nosave_end)); /* Reserve for hibernation */ 877 } 878 879 static void __init resource_init(void) 880 { 881 int i; 882 883 if (UNCAC_BASE != IO_BASE) 884 return; 885 886 code_resource.start = __pa_symbol(&_text); 887 code_resource.end = __pa_symbol(&_etext) - 1; 888 data_resource.start = __pa_symbol(&_etext); 889 data_resource.end = __pa_symbol(&_edata) - 1; 890 891 for (i = 0; i < boot_mem_map.nr_map; i++) { 892 struct resource *res; 893 unsigned long start, end; 894 895 start = boot_mem_map.map[i].addr; 896 end = boot_mem_map.map[i].addr + boot_mem_map.map[i].size - 1; 897 if (start >= HIGHMEM_START) 898 continue; 899 if (end >= HIGHMEM_START) 900 end = HIGHMEM_START - 1; 901 902 res = alloc_bootmem(sizeof(struct resource)); 903 904 res->start = start; 905 res->end = end; 906 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 907 908 switch (boot_mem_map.map[i].type) { 909 case BOOT_MEM_RAM: 910 case BOOT_MEM_INIT_RAM: 911 case BOOT_MEM_ROM_DATA: 912 res->name = "System RAM"; 913 res->flags |= IORESOURCE_SYSRAM; 914 break; 915 case BOOT_MEM_RESERVED: 916 default: 917 res->name = "reserved"; 918 } 919 920 request_resource(&iomem_resource, res); 921 922 /* 923 * We don't know which RAM region contains kernel data, 924 * so we try it repeatedly and let the resource manager 925 * test it. 926 */ 927 request_resource(res, &code_resource); 928 request_resource(res, &data_resource); 929 request_crashkernel(res); 930 } 931 } 932 933 #ifdef CONFIG_SMP 934 static void __init prefill_possible_map(void) 935 { 936 int i, possible = num_possible_cpus(); 937 938 if (possible > nr_cpu_ids) 939 possible = nr_cpu_ids; 940 941 for (i = 0; i < possible; i++) 942 set_cpu_possible(i, true); 943 for (; i < NR_CPUS; i++) 944 set_cpu_possible(i, false); 945 946 nr_cpu_ids = possible; 947 } 948 #else 949 static inline void prefill_possible_map(void) {} 950 #endif 951 952 void __init setup_arch(char **cmdline_p) 953 { 954 cpu_probe(); 955 mips_cm_probe(); 956 prom_init(); 957 958 setup_early_fdc_console(); 959 #ifdef CONFIG_EARLY_PRINTK 960 setup_early_printk(); 961 #endif 962 cpu_report(); 963 check_bugs_early(); 964 965 #if defined(CONFIG_VT) 966 #if defined(CONFIG_VGA_CONSOLE) 967 conswitchp = &vga_con; 968 #elif defined(CONFIG_DUMMY_CONSOLE) 969 conswitchp = &dummy_con; 970 #endif 971 #endif 972 973 arch_mem_init(cmdline_p); 974 975 resource_init(); 976 plat_smp_setup(); 977 prefill_possible_map(); 978 979 cpu_cache_init(); 980 paging_init(); 981 } 982 983 unsigned long kernelsp[NR_CPUS]; 984 unsigned long fw_arg0, fw_arg1, fw_arg2, fw_arg3; 985 986 #ifdef CONFIG_USE_OF 987 unsigned long fw_passed_dtb; 988 #endif 989 990 #ifdef CONFIG_DEBUG_FS 991 struct dentry *mips_debugfs_dir; 992 static int __init debugfs_mips(void) 993 { 994 struct dentry *d; 995 996 d = debugfs_create_dir("mips", NULL); 997 if (!d) 998 return -ENOMEM; 999 mips_debugfs_dir = d; 1000 return 0; 1001 } 1002 arch_initcall(debugfs_mips); 1003 #endif 1004