arch/mips/kernel/setup.c

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