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