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 static int __init early_parse_memmap(char *p) 674 { 675 char *oldp; 676 u64 start_at, mem_size; 677 678 if (!p) 679 return -EINVAL; 680 681 if (!strncmp(p, "exactmap", 8)) { 682 pr_err("\"memmap=exactmap\" invalid on MIPS\n"); 683 return 0; 684 } 685 686 oldp = p; 687 mem_size = memparse(p, &p); 688 if (p == oldp) 689 return -EINVAL; 690 691 if (*p == '@') { 692 start_at = memparse(p+1, &p); 693 add_memory_region(start_at, mem_size, BOOT_MEM_RAM); 694 } else if (*p == '#') { 695 pr_err("\"memmap=nn#ss\" (force ACPI data) invalid on MIPS\n"); 696 return -EINVAL; 697 } else if (*p == '$') { 698 start_at = memparse(p+1, &p); 699 add_memory_region(start_at, mem_size, BOOT_MEM_RESERVED); 700 } else { 701 pr_err("\"memmap\" invalid format!\n"); 702 return -EINVAL; 703 } 704 705 if (*p == '\0') { 706 usermem = 1; 707 return 0; 708 } else 709 return -EINVAL; 710 } 711 early_param("memmap", early_parse_memmap); 712 713 #ifdef CONFIG_PROC_VMCORE 714 unsigned long setup_elfcorehdr, setup_elfcorehdr_size; 715 static int __init early_parse_elfcorehdr(char *p) 716 { 717 int i; 718 719 setup_elfcorehdr = memparse(p, &p); 720 721 for (i = 0; i < boot_mem_map.nr_map; i++) { 722 unsigned long start = boot_mem_map.map[i].addr; 723 unsigned long end = (boot_mem_map.map[i].addr + 724 boot_mem_map.map[i].size); 725 if (setup_elfcorehdr >= start && setup_elfcorehdr < end) { 726 /* 727 * Reserve from the elf core header to the end of 728 * the memory segment, that should all be kdump 729 * reserved memory. 730 */ 731 setup_elfcorehdr_size = end - setup_elfcorehdr; 732 break; 733 } 734 } 735 /* 736 * If we don't find it in the memory map, then we shouldn't 737 * have to worry about it, as the new kernel won't use it. 738 */ 739 return 0; 740 } 741 early_param("elfcorehdr", early_parse_elfcorehdr); 742 #endif 743 744 static void __init arch_mem_addpart(phys_addr_t mem, phys_addr_t end, int type) 745 { 746 phys_addr_t size; 747 int i; 748 749 size = end - mem; 750 if (!size) 751 return; 752 753 /* Make sure it is in the boot_mem_map */ 754 for (i = 0; i < boot_mem_map.nr_map; i++) { 755 if (mem >= boot_mem_map.map[i].addr && 756 mem < (boot_mem_map.map[i].addr + 757 boot_mem_map.map[i].size)) 758 return; 759 } 760 add_memory_region(mem, size, type); 761 } 762 763 #ifdef CONFIG_KEXEC 764 static inline unsigned long long get_total_mem(void) 765 { 766 unsigned long long total; 767 768 total = max_pfn - min_low_pfn; 769 return total << PAGE_SHIFT; 770 } 771 772 static void __init mips_parse_crashkernel(void) 773 { 774 unsigned long long total_mem; 775 unsigned long long crash_size, crash_base; 776 int ret; 777 778 total_mem = get_total_mem(); 779 ret = parse_crashkernel(boot_command_line, total_mem, 780 &crash_size, &crash_base); 781 if (ret != 0 || crash_size <= 0) 782 return; 783 784 if (!memory_region_available(crash_base, crash_size)) { 785 pr_warn("Invalid memory region reserved for crash kernel\n"); 786 return; 787 } 788 789 crashk_res.start = crash_base; 790 crashk_res.end = crash_base + crash_size - 1; 791 } 792 793 static void __init request_crashkernel(struct resource *res) 794 { 795 int ret; 796 797 if (crashk_res.start == crashk_res.end) 798 return; 799 800 ret = request_resource(res, &crashk_res); 801 if (!ret) 802 pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n", 803 (unsigned long)((crashk_res.end - 804 crashk_res.start + 1) >> 20), 805 (unsigned long)(crashk_res.start >> 20)); 806 } 807 #else /* !defined(CONFIG_KEXEC) */ 808 static void __init mips_parse_crashkernel(void) 809 { 810 } 811 812 static void __init request_crashkernel(struct resource *res) 813 { 814 } 815 #endif /* !defined(CONFIG_KEXEC) */ 816 817 #define USE_PROM_CMDLINE IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_BOOTLOADER) 818 #define USE_DTB_CMDLINE IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB) 819 #define EXTEND_WITH_PROM IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND) 820 #define BUILTIN_EXTEND_WITH_PROM \ 821 IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND) 822 823 static void __init arch_mem_init(char **cmdline_p) 824 { 825 struct memblock_region *reg; 826 extern void plat_mem_setup(void); 827 828 /* call board setup routine */ 829 plat_mem_setup(); 830 831 /* 832 * Make sure all kernel memory is in the maps. The "UP" and 833 * "DOWN" are opposite for initdata since if it crosses over 834 * into another memory section you don't want that to be 835 * freed when the initdata is freed. 836 */ 837 arch_mem_addpart(PFN_DOWN(__pa_symbol(&_text)) << PAGE_SHIFT, 838 PFN_UP(__pa_symbol(&_edata)) << PAGE_SHIFT, 839 BOOT_MEM_RAM); 840 arch_mem_addpart(PFN_UP(__pa_symbol(&__init_begin)) << PAGE_SHIFT, 841 PFN_DOWN(__pa_symbol(&__init_end)) << PAGE_SHIFT, 842 BOOT_MEM_INIT_RAM); 843 844 pr_info("Determined physical RAM map:\n"); 845 print_memory_map(); 846 847 #if defined(CONFIG_CMDLINE_BOOL) && defined(CONFIG_CMDLINE_OVERRIDE) 848 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE); 849 #else 850 if ((USE_PROM_CMDLINE && arcs_cmdline[0]) || 851 (USE_DTB_CMDLINE && !boot_command_line[0])) 852 strlcpy(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 853 854 if (EXTEND_WITH_PROM && arcs_cmdline[0]) { 855 if (boot_command_line[0]) 856 strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); 857 strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 858 } 859 860 #if defined(CONFIG_CMDLINE_BOOL) 861 if (builtin_cmdline[0]) { 862 if (boot_command_line[0]) 863 strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); 864 strlcat(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE); 865 } 866 867 if (BUILTIN_EXTEND_WITH_PROM && arcs_cmdline[0]) { 868 if (boot_command_line[0]) 869 strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); 870 strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 871 } 872 #endif 873 #endif 874 strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE); 875 876 *cmdline_p = command_line; 877 878 parse_early_param(); 879 880 if (usermem) { 881 pr_info("User-defined physical RAM map:\n"); 882 print_memory_map(); 883 } 884 885 early_init_fdt_reserve_self(); 886 early_init_fdt_scan_reserved_mem(); 887 888 bootmem_init(); 889 #ifdef CONFIG_PROC_VMCORE 890 if (setup_elfcorehdr && setup_elfcorehdr_size) { 891 printk(KERN_INFO "kdump reserved memory at %lx-%lx\n", 892 setup_elfcorehdr, setup_elfcorehdr_size); 893 reserve_bootmem(setup_elfcorehdr, setup_elfcorehdr_size, 894 BOOTMEM_DEFAULT); 895 } 896 #endif 897 898 mips_parse_crashkernel(); 899 #ifdef CONFIG_KEXEC 900 if (crashk_res.start != crashk_res.end) 901 reserve_bootmem(crashk_res.start, 902 crashk_res.end - crashk_res.start + 1, 903 BOOTMEM_DEFAULT); 904 #endif 905 device_tree_init(); 906 sparse_init(); 907 plat_swiotlb_setup(); 908 909 dma_contiguous_reserve(PFN_PHYS(max_low_pfn)); 910 /* Tell bootmem about cma reserved memblock section */ 911 for_each_memblock(reserved, reg) 912 if (reg->size != 0) 913 reserve_bootmem(reg->base, reg->size, BOOTMEM_DEFAULT); 914 915 reserve_bootmem_region(__pa_symbol(&__nosave_begin), 916 __pa_symbol(&__nosave_end)); /* Reserve for hibernation */ 917 } 918 919 static void __init resource_init(void) 920 { 921 int i; 922 923 if (UNCAC_BASE != IO_BASE) 924 return; 925 926 code_resource.start = __pa_symbol(&_text); 927 code_resource.end = __pa_symbol(&_etext) - 1; 928 data_resource.start = __pa_symbol(&_etext); 929 data_resource.end = __pa_symbol(&_edata) - 1; 930 931 for (i = 0; i < boot_mem_map.nr_map; i++) { 932 struct resource *res; 933 unsigned long start, end; 934 935 start = boot_mem_map.map[i].addr; 936 end = boot_mem_map.map[i].addr + boot_mem_map.map[i].size - 1; 937 if (start >= HIGHMEM_START) 938 continue; 939 if (end >= HIGHMEM_START) 940 end = HIGHMEM_START - 1; 941 942 res = alloc_bootmem(sizeof(struct resource)); 943 944 res->start = start; 945 res->end = end; 946 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 947 948 switch (boot_mem_map.map[i].type) { 949 case BOOT_MEM_RAM: 950 case BOOT_MEM_INIT_RAM: 951 case BOOT_MEM_ROM_DATA: 952 res->name = "System RAM"; 953 res->flags |= IORESOURCE_SYSRAM; 954 break; 955 case BOOT_MEM_RESERVED: 956 default: 957 res->name = "reserved"; 958 } 959 960 request_resource(&iomem_resource, res); 961 962 /* 963 * We don't know which RAM region contains kernel data, 964 * so we try it repeatedly and let the resource manager 965 * test it. 966 */ 967 request_resource(res, &code_resource); 968 request_resource(res, &data_resource); 969 request_crashkernel(res); 970 } 971 } 972 973 #ifdef CONFIG_SMP 974 static void __init prefill_possible_map(void) 975 { 976 int i, possible = num_possible_cpus(); 977 978 if (possible > nr_cpu_ids) 979 possible = nr_cpu_ids; 980 981 for (i = 0; i < possible; i++) 982 set_cpu_possible(i, true); 983 for (; i < NR_CPUS; i++) 984 set_cpu_possible(i, false); 985 986 nr_cpu_ids = possible; 987 } 988 #else 989 static inline void prefill_possible_map(void) {} 990 #endif 991 992 void __init setup_arch(char **cmdline_p) 993 { 994 cpu_probe(); 995 mips_cm_probe(); 996 prom_init(); 997 998 setup_early_fdc_console(); 999 #ifdef CONFIG_EARLY_PRINTK 1000 setup_early_printk(); 1001 #endif 1002 cpu_report(); 1003 check_bugs_early(); 1004 1005 #if defined(CONFIG_VT) 1006 #if defined(CONFIG_VGA_CONSOLE) 1007 conswitchp = &vga_con; 1008 #elif defined(CONFIG_DUMMY_CONSOLE) 1009 conswitchp = &dummy_con; 1010 #endif 1011 #endif 1012 1013 arch_mem_init(cmdline_p); 1014 1015 resource_init(); 1016 plat_smp_setup(); 1017 prefill_possible_map(); 1018 1019 cpu_cache_init(); 1020 paging_init(); 1021 } 1022 1023 unsigned long kernelsp[NR_CPUS]; 1024 unsigned long fw_arg0, fw_arg1, fw_arg2, fw_arg3; 1025 1026 #ifdef CONFIG_USE_OF 1027 unsigned long fw_passed_dtb; 1028 #endif 1029 1030 #ifdef CONFIG_DEBUG_FS 1031 struct dentry *mips_debugfs_dir; 1032 static int __init debugfs_mips(void) 1033 { 1034 struct dentry *d; 1035 1036 d = debugfs_create_dir("mips", NULL); 1037 if (!d) 1038 return -ENOMEM; 1039 mips_debugfs_dir = d; 1040 return 0; 1041 } 1042 arch_initcall(debugfs_mips); 1043 #endif 1044