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/cpu.h>
  15 #include <linux/delay.h>
  16 #include <linux/ioport.h>
  17 #include <linux/export.h>
  18 #include <linux/screen_info.h>
  19 #include <linux/memblock.h>
  20 #include <linux/initrd.h>
  21 #include <linux/root_dev.h>
  22 #include <linux/highmem.h>
  23 #include <linux/console.h>
  24 #include <linux/pfn.h>
  25 #include <linux/debugfs.h>
  26 #include <linux/kexec.h>
  27 #include <linux/sizes.h>
  28 #include <linux/device.h>
  29 #include <linux/dma-map-ops.h>
  30 #include <linux/decompress/generic.h>
  31 #include <linux/of_fdt.h>
  32 #include <linux/dmi.h>
  33 #include <linux/crash_dump.h>
  34
  35 #include <asm/addrspace.h>
  36 #include <asm/bootinfo.h>
  37 #include <asm/bugs.h>
  38 #include <asm/cache.h>
  39 #include <asm/cdmm.h>
  40 #include <asm/cpu.h>
  41 #include <asm/debug.h>
  42 #include <asm/sections.h>
  43 #include <asm/setup.h>
  44 #include <asm/smp-ops.h>
  45 #include <asm/prom.h>
  46
  47 #ifdef CONFIG_MIPS_ELF_APPENDED_DTB
  48 char __section(".appended_dtb") __appended_dtb[0x100000];
  49 #endif /* CONFIG_MIPS_ELF_APPENDED_DTB */
  50
  51 struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly;
  52
  53 EXPORT_SYMBOL(cpu_data);
  54
  55 #ifdef CONFIG_VT
  56 struct screen_info screen_info;
  57 #endif
  58
  59 /*
  60  * Setup information
  61  *
  62  * These are initialized so they are in the .data section
  63  */
  64 unsigned long mips_machtype __read_mostly = MACH_UNKNOWN;
  65
  66 EXPORT_SYMBOL(mips_machtype);
  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 const char builtin_cmdline[] __initconst = CONFIG_CMDLINE;
  73 #else
  74 static const char builtin_cmdline[] __initconst = "";
  75 #endif
  76
  77 /*
  78  * mips_io_port_base is the begin of the address space to which x86 style
  79  * I/O ports are mapped.
  80  */
  81 unsigned long mips_io_port_base = -1;
  82 EXPORT_SYMBOL(mips_io_port_base);
  83
  84 static struct resource code_resource = { .name = "Kernel code", };
  85 static struct resource data_resource = { .name = "Kernel data", };
  86 static struct resource bss_resource = { .name = "Kernel bss", };
  87
  88 unsigned long __kaslr_offset __ro_after_init;
  89 EXPORT_SYMBOL(__kaslr_offset);
  90
  91 static void *detect_magic __initdata = detect_memory_region;
  92
  93 #ifdef CONFIG_MIPS_AUTO_PFN_OFFSET
  94 unsigned long ARCH_PFN_OFFSET;
  95 EXPORT_SYMBOL(ARCH_PFN_OFFSET);
  96 #endif
  97
  98 void __init detect_memory_region(phys_addr_t start, phys_addr_t sz_min, phys_addr_t sz_max)
  99 {
 100         void *dm = &detect_magic;
 101         phys_addr_t size;
 102
 103         for (size = sz_min; size < sz_max; size <<= 1) {
 104                 if (!memcmp(dm, dm + size, sizeof(detect_magic)))
 105                         break;
 106         }
 107
 108         pr_debug("Memory: %lluMB of RAM detected at 0x%llx (min: %lluMB, max: %lluMB)\n",
 109                 ((unsigned long long) size) / SZ_1M,
 110                 (unsigned long long) start,
 111                 ((unsigned long long) sz_min) / SZ_1M,
 112                 ((unsigned long long) sz_max) / SZ_1M);
 113
 114         memblock_add(start, size);
 115 }
 116
 117 /*
 118  * Manage initrd
 119  */
 120 #ifdef CONFIG_BLK_DEV_INITRD
 121
 122 static int __init rd_start_early(char *p)
 123 {
 124         unsigned long start = memparse(p, &p);
 125
 126 #ifdef CONFIG_64BIT
 127         /* Guess if the sign extension was forgotten by bootloader */
 128         if (start < XKPHYS)
 129                 start = (int)start;
 130 #endif
 131         initrd_start = start;
 132         initrd_end += start;
 133         return 0;
 134 }
 135 early_param("rd_start", rd_start_early);
 136
 137 static int __init rd_size_early(char *p)
 138 {
 139         initrd_end += memparse(p, &p);
 140         return 0;
 141 }
 142 early_param("rd_size", rd_size_early);
 143
 144 /* it returns the next free pfn after initrd */
 145 static unsigned long __init init_initrd(void)
 146 {
 147         unsigned long end;
 148
 149         /*
 150          * Board specific code or command line parser should have
 151          * already set up initrd_start and initrd_end. In these cases
 152          * perfom sanity checks and use them if all looks good.
 153          */
 154         if (!initrd_start || initrd_end <= initrd_start)
 155                 goto disable;
 156
 157         if (initrd_start & ~PAGE_MASK) {
 158                 pr_err("initrd start must be page aligned\n");
 159                 goto disable;
 160         }
 161
 162         /*
 163          * Sanitize initrd addresses. For example firmware
 164          * can't guess if they need to pass them through
 165          * 64-bits values if the kernel has been built in pure
 166          * 32-bit. We need also to switch from KSEG0 to XKPHYS
 167          * addresses now, so the code can now safely use __pa().
 168          */
 169         end = __pa(initrd_end);
 170         initrd_end = (unsigned long)__va(end);
 171         initrd_start = (unsigned long)__va(__pa(initrd_start));
 172
 173         if (initrd_start < PAGE_OFFSET) {
 174                 pr_err("initrd start < PAGE_OFFSET\n");
 175                 goto disable;
 176         }
 177
 178         ROOT_DEV = Root_RAM0;
 179         return PFN_UP(end);
 180 disable:
 181         initrd_start = 0;
 182         initrd_end = 0;
 183         return 0;
 184 }
 185
 186 /* In some conditions (e.g. big endian bootloader with a little endian
 187    kernel), the initrd might appear byte swapped.  Try to detect this and
 188    byte swap it if needed.  */
 189 static void __init maybe_bswap_initrd(void)
 190 {
 191 #if defined(CONFIG_CPU_CAVIUM_OCTEON)
 192         u64 buf;
 193
 194         /* Check for CPIO signature */
 195         if (!memcmp((void *)initrd_start, "070701", 6))
 196                 return;
 197
 198         /* Check for compressed initrd */
 199         if (decompress_method((unsigned char *)initrd_start, 8, NULL))
 200                 return;
 201
 202         /* Try again with a byte swapped header */
 203         buf = swab64p((u64 *)initrd_start);
 204         if (!memcmp(&buf, "070701", 6) ||
 205             decompress_method((unsigned char *)(&buf), 8, NULL)) {
 206                 unsigned long i;
 207
 208                 pr_info("Byteswapped initrd detected\n");
 209                 for (i = initrd_start; i < ALIGN(initrd_end, 8); i += 8)
 210                         swab64s((u64 *)i);
 211         }
 212 #endif
 213 }
 214
 215 static void __init finalize_initrd(void)
 216 {
 217         unsigned long size = initrd_end - initrd_start;
 218
 219         if (size == 0) {
 220                 printk(KERN_INFO "Initrd not found or empty");
 221                 goto disable;
 222         }
 223         if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) {
 224                 printk(KERN_ERR "Initrd extends beyond end of memory");
 225                 goto disable;
 226         }
 227
 228         maybe_bswap_initrd();
 229
 230         memblock_reserve(__pa(initrd_start), size);
 231         initrd_below_start_ok = 1;
 232
 233         pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n",
 234                 initrd_start, size);
 235         return;
 236 disable:
 237         printk(KERN_CONT " - disabling initrd\n");
 238         initrd_start = 0;
 239         initrd_end = 0;
 240 }
 241
 242 #else  /* !CONFIG_BLK_DEV_INITRD */
 243
 244 static unsigned long __init init_initrd(void)
 245 {
 246         return 0;
 247 }
 248
 249 #define finalize_initrd()       do {} while (0)
 250
 251 #endif
 252
 253 /*
 254  * Initialize the bootmem allocator. It also setup initrd related data
 255  * if needed.
 256  */
 257 #if defined(CONFIG_SGI_IP27) || (defined(CONFIG_CPU_LOONGSON64) && defined(CONFIG_NUMA))
 258
 259 static void __init bootmem_init(void)
 260 {
 261         init_initrd();
 262         finalize_initrd();
 263 }
 264
 265 #else  /* !CONFIG_SGI_IP27 */
 266
 267 static void __init bootmem_init(void)
 268 {
 269         phys_addr_t ramstart, ramend;
 270         unsigned long start, end;
 271         int i;
 272
 273         ramstart = memblock_start_of_DRAM();
 274         ramend = memblock_end_of_DRAM();
 275
 276         /*
 277          * Sanity check any INITRD first. We don't take it into account
 278          * for bootmem setup initially, rely on the end-of-kernel-code
 279          * as our memory range starting point. Once bootmem is inited we
 280          * will reserve the area used for the initrd.
 281          */
 282         init_initrd();
 283
 284         /* Reserve memory occupied by kernel. */
 285         memblock_reserve(__pa_symbol(&_text),
 286                         __pa_symbol(&_end) - __pa_symbol(&_text));
 287
 288         /* max_low_pfn is not a number of pages but the end pfn of low mem */
 289
 290 #ifdef CONFIG_MIPS_AUTO_PFN_OFFSET
 291         ARCH_PFN_OFFSET = PFN_UP(ramstart);
 292 #else
 293         /*
 294          * Reserve any memory between the start of RAM and PHYS_OFFSET
 295          */
 296         if (ramstart > PHYS_OFFSET)
 297                 memblock_reserve(PHYS_OFFSET, ramstart - PHYS_OFFSET);
 298
 299         if (PFN_UP(ramstart) > ARCH_PFN_OFFSET) {
 300                 pr_info("Wasting %lu bytes for tracking %lu unused pages\n",
 301                         (unsigned long)((PFN_UP(ramstart) - ARCH_PFN_OFFSET) * sizeof(struct page)),
 302                         (unsigned long)(PFN_UP(ramstart) - ARCH_PFN_OFFSET));
 303         }
 304 #endif
 305
 306         min_low_pfn = ARCH_PFN_OFFSET;
 307         max_pfn = PFN_DOWN(ramend);
 308         for_each_mem_pfn_range(i, MAX_NUMNODES, &start, &end, NULL) {
 309                 /*
 310                  * Skip highmem here so we get an accurate max_low_pfn if low
 311                  * memory stops short of high memory.
 312                  * If the region overlaps HIGHMEM_START, end is clipped so
 313                  * max_pfn excludes the highmem portion.
 314                  */
 315                 if (start >= PFN_DOWN(HIGHMEM_START))
 316                         continue;
 317                 if (end > PFN_DOWN(HIGHMEM_START))
 318                         end = PFN_DOWN(HIGHMEM_START);
 319                 if (end > max_low_pfn)
 320                         max_low_pfn = end;
 321         }
 322
 323         if (min_low_pfn >= max_low_pfn)
 324                 panic("Incorrect memory mapping !!!");
 325
 326         if (max_pfn > PFN_DOWN(HIGHMEM_START)) {
 327 #ifdef CONFIG_HIGHMEM
 328                 highstart_pfn = PFN_DOWN(HIGHMEM_START);
 329                 highend_pfn = max_pfn;
 330 #else
 331                 max_low_pfn = PFN_DOWN(HIGHMEM_START);
 332                 max_pfn = max_low_pfn;
 333 #endif
 334         }
 335
 336         /*
 337          * Reserve initrd memory if needed.
 338          */
 339         finalize_initrd();
 340 }
 341
 342 #endif  /* CONFIG_SGI_IP27 */
 343
 344 static int usermem __initdata;
 345
 346 static int __init early_parse_mem(char *p)
 347 {
 348         phys_addr_t start, size;
 349
 350         /*
 351          * If a user specifies memory size, we
 352          * blow away any automatically generated
 353          * size.
 354          */
 355         if (usermem == 0) {
 356                 usermem = 1;
 357                 memblock_remove(memblock_start_of_DRAM(),
 358                         memblock_end_of_DRAM() - memblock_start_of_DRAM());
 359         }
 360         start = 0;
 361         size = memparse(p, &p);
 362         if (*p == '@')
 363                 start = memparse(p + 1, &p);
 364
 365         memblock_add(start, size);
 366
 367         return 0;
 368 }
 369 early_param("mem", early_parse_mem);
 370
 371 static int __init early_parse_memmap(char *p)
 372 {
 373         char *oldp;
 374         u64 start_at, mem_size;
 375
 376         if (!p)
 377                 return -EINVAL;
 378
 379         if (!strncmp(p, "exactmap", 8)) {
 380                 pr_err("\"memmap=exactmap\" invalid on MIPS\n");
 381                 return 0;
 382         }
 383
 384         oldp = p;
 385         mem_size = memparse(p, &p);
 386         if (p == oldp)
 387                 return -EINVAL;
 388
 389         if (*p == '@') {
 390                 start_at = memparse(p+1, &p);
 391                 memblock_add(start_at, mem_size);
 392         } else if (*p == '#') {
 393                 pr_err("\"memmap=nn#ss\" (force ACPI data) invalid on MIPS\n");
 394                 return -EINVAL;
 395         } else if (*p == '$') {
 396                 start_at = memparse(p+1, &p);
 397                 memblock_add(start_at, mem_size);
 398                 memblock_reserve(start_at, mem_size);
 399         } else {
 400                 pr_err("\"memmap\" invalid format!\n");
 401                 return -EINVAL;
 402         }
 403
 404         if (*p == '\0') {
 405                 usermem = 1;
 406                 return 0;
 407         } else
 408                 return -EINVAL;
 409 }
 410 early_param("memmap", early_parse_memmap);
 411
 412 static void __init mips_reserve_vmcore(void)
 413 {
 414 #ifdef CONFIG_PROC_VMCORE
 415         phys_addr_t start, end;
 416         u64 i;
 417
 418         if (!elfcorehdr_size) {
 419                 for_each_mem_range(i, &start, &end) {
 420                         if (elfcorehdr_addr >= start && elfcorehdr_addr < end) {
 421                                 /*
 422                                  * Reserve from the elf core header to the end of
 423                                  * the memory segment, that should all be kdump
 424                                  * reserved memory.
 425                                  */
 426                                 elfcorehdr_size = end - elfcorehdr_addr;
 427                                 break;
 428                         }
 429                 }
 430         }
 431
 432         pr_info("Reserving %ldKB of memory at %ldKB for kdump\n",
 433                 (unsigned long)elfcorehdr_size >> 10, (unsigned long)elfcorehdr_addr >> 10);
 434
 435         memblock_reserve(elfcorehdr_addr, elfcorehdr_size);
 436 #endif
 437 }
 438
 439 #ifdef CONFIG_KEXEC
 440
 441 /* 64M alignment for crash kernel regions */
 442 #define CRASH_ALIGN     SZ_64M
 443 #define CRASH_ADDR_MAX  SZ_512M
 444
 445 static void __init mips_parse_crashkernel(void)
 446 {
 447         unsigned long long total_mem;
 448         unsigned long long crash_size, crash_base;
 449         int ret;
 450
 451         total_mem = memblock_phys_mem_size();
 452         ret = parse_crashkernel(boot_command_line, total_mem,
 453                                 &crash_size, &crash_base);
 454         if (ret != 0 || crash_size <= 0)
 455                 return;
 456
 457         if (crash_base <= 0) {
 458                 crash_base = memblock_phys_alloc_range(crash_size, CRASH_ALIGN,
 459                                                        CRASH_ALIGN,
 460                                                        CRASH_ADDR_MAX);
 461                 if (!crash_base) {
 462                         pr_warn("crashkernel reservation failed - No suitable area found.\n");
 463                         return;
 464                 }
 465         } else {
 466                 unsigned long long start;
 467
 468                 start = memblock_phys_alloc_range(crash_size, 1,
 469                                                   crash_base,
 470                                                   crash_base + crash_size);
 471                 if (start != crash_base) {
 472                         pr_warn("Invalid memory region reserved for crash kernel\n");
 473                         return;
 474                 }
 475         }
 476
 477         crashk_res.start = crash_base;
 478         crashk_res.end   = crash_base + crash_size - 1;
 479 }
 480
 481 static void __init request_crashkernel(struct resource *res)
 482 {
 483         int ret;
 484
 485         if (crashk_res.start == crashk_res.end)
 486                 return;
 487
 488         ret = request_resource(res, &crashk_res);
 489         if (!ret)
 490                 pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
 491                         (unsigned long)(resource_size(&crashk_res) >> 20),
 492                         (unsigned long)(crashk_res.start  >> 20));
 493 }
 494 #else /* !defined(CONFIG_KEXEC)         */
 495 static void __init mips_parse_crashkernel(void)
 496 {
 497 }
 498
 499 static void __init request_crashkernel(struct resource *res)
 500 {
 501 }
 502 #endif /* !defined(CONFIG_KEXEC)  */
 503
 504 static void __init check_kernel_sections_mem(void)
 505 {
 506         phys_addr_t start = __pa_symbol(&_text);
 507         phys_addr_t size = __pa_symbol(&_end) - start;
 508
 509         if (!memblock_is_region_memory(start, size)) {
 510                 pr_info("Kernel sections are not in the memory maps\n");
 511                 memblock_add(start, size);
 512         }
 513 }
 514
 515 static void __init bootcmdline_append(const char *s, size_t max)
 516 {
 517         if (!s[0] || !max)
 518                 return;
 519
 520         if (boot_command_line[0])
 521                 strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
 522
 523         strlcat(boot_command_line, s, max);
 524 }
 525
 526 #ifdef CONFIG_OF_EARLY_FLATTREE
 527
 528 static int __init bootcmdline_scan_chosen(unsigned long node, const char *uname,
 529                                           int depth, void *data)
 530 {
 531         bool *dt_bootargs = data;
 532         const char *p;
 533         int l;
 534
 535         if (depth != 1 || !data ||
 536             (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
 537                 return 0;
 538
 539         p = of_get_flat_dt_prop(node, "bootargs", &l);
 540         if (p != NULL && l > 0) {
 541                 bootcmdline_append(p, min(l, COMMAND_LINE_SIZE));
 542                 *dt_bootargs = true;
 543         }
 544
 545         return 1;
 546 }
 547
 548 #endif /* CONFIG_OF_EARLY_FLATTREE */
 549
 550 static void __init bootcmdline_init(void)
 551 {
 552         bool dt_bootargs = false;
 553
 554         /*
 555          * If CMDLINE_OVERRIDE is enabled then initializing the command line is
 556          * trivial - we simply use the built-in command line unconditionally &
 557          * unmodified.
 558          */
 559         if (IS_ENABLED(CONFIG_CMDLINE_OVERRIDE)) {
 560                 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
 561                 return;
 562         }
 563
 564         /*
 565          * If the user specified a built-in command line &
 566          * MIPS_CMDLINE_BUILTIN_EXTEND, then the built-in command line is
 567          * prepended to arguments from the bootloader or DT so we'll copy them
 568          * to the start of boot_command_line here. Otherwise, empty
 569          * boot_command_line to undo anything early_init_dt_scan_chosen() did.
 570          */
 571         if (IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND))
 572                 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
 573         else
 574                 boot_command_line[0] = 0;
 575
 576 #ifdef CONFIG_OF_EARLY_FLATTREE
 577         /*
 578          * If we're configured to take boot arguments from DT, look for those
 579          * now.
 580          */
 581         if (IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB) ||
 582             IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND))
 583                 of_scan_flat_dt(bootcmdline_scan_chosen, &dt_bootargs);
 584 #endif
 585
 586         /*
 587          * If we didn't get any arguments from DT (regardless of whether that's
 588          * because we weren't configured to look for them, or because we looked
 589          * & found none) then we'll take arguments from the bootloader.
 590          * plat_mem_setup() should have filled arcs_cmdline with arguments from
 591          * the bootloader.
 592          */
 593         if (IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND) || !dt_bootargs)
 594                 bootcmdline_append(arcs_cmdline, COMMAND_LINE_SIZE);
 595
 596         /*
 597          * If the user specified a built-in command line & we didn't already
 598          * prepend it, we append it to boot_command_line here.
 599          */
 600         if (IS_ENABLED(CONFIG_CMDLINE_BOOL) &&
 601             !IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND))
 602                 bootcmdline_append(builtin_cmdline, COMMAND_LINE_SIZE);
 603 }
 604
 605 /*
 606  * arch_mem_init - initialize memory management subsystem
 607  *
 608  *  o plat_mem_setup() detects the memory configuration and will record detected
 609  *    memory areas using memblock_add.
 610  *
 611  * At this stage the memory configuration of the system is known to the
 612  * kernel but generic memory management system is still entirely uninitialized.
 613  *
 614  *  o bootmem_init()
 615  *  o sparse_init()
 616  *  o paging_init()
 617  *  o dma_contiguous_reserve()
 618  *
 619  * At this stage the bootmem allocator is ready to use.
 620  *
 621  * NOTE: historically plat_mem_setup did the entire platform initialization.
 622  *       This was rather impractical because it meant plat_mem_setup had to
 623  * get away without any kind of memory allocator.  To keep old code from
 624  * breaking plat_setup was just renamed to plat_mem_setup and a second platform
 625  * initialization hook for anything else was introduced.
 626  */
 627 static void __init arch_mem_init(char **cmdline_p)
 628 {
 629         /* call board setup routine */
 630         plat_mem_setup();
 631         memblock_set_bottom_up(true);
 632
 633         bootcmdline_init();
 634         strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
 635         *cmdline_p = command_line;
 636
 637         parse_early_param();
 638
 639         if (usermem)
 640                 pr_info("User-defined physical RAM map overwrite\n");
 641
 642         check_kernel_sections_mem();
 643
 644         early_init_fdt_reserve_self();
 645         early_init_fdt_scan_reserved_mem();
 646
 647 #ifndef CONFIG_NUMA
 648         memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0);
 649 #endif
 650         bootmem_init();
 651
 652         /*
 653          * Prevent memblock from allocating high memory.
 654          * This cannot be done before max_low_pfn is detected, so up
 655          * to this point is possible to only reserve physical memory
 656          * with memblock_reserve; memblock_alloc* can be used
 657          * only after this point
 658          */
 659         memblock_set_current_limit(PFN_PHYS(max_low_pfn));
 660
 661         mips_reserve_vmcore();
 662
 663         mips_parse_crashkernel();
 664         device_tree_init();
 665
 666         /*
 667          * In order to reduce the possibility of kernel panic when failed to
 668          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
 669          * low memory as small as possible before plat_swiotlb_setup(), so
 670          * make sparse_init() using top-down allocation.
 671          */
 672         memblock_set_bottom_up(false);
 673         sparse_init();
 674         memblock_set_bottom_up(true);
 675
 676         plat_swiotlb_setup();
 677
 678         dma_contiguous_reserve(PFN_PHYS(max_low_pfn));
 679
 680         /* Reserve for hibernation. */
 681         memblock_reserve(__pa_symbol(&__nosave_begin),
 682                 __pa_symbol(&__nosave_end) - __pa_symbol(&__nosave_begin));
 683
 684         early_memtest(PFN_PHYS(ARCH_PFN_OFFSET), PFN_PHYS(max_low_pfn));
 685 }
 686
 687 static void __init resource_init(void)
 688 {
 689         phys_addr_t start, end;
 690         u64 i;
 691
 692         if (UNCAC_BASE != IO_BASE)
 693                 return;
 694
 695         code_resource.start = __pa_symbol(&_text);
 696         code_resource.end = __pa_symbol(&_etext) - 1;
 697         data_resource.start = __pa_symbol(&_etext);
 698         data_resource.end = __pa_symbol(&_edata) - 1;
 699         bss_resource.start = __pa_symbol(&__bss_start);
 700         bss_resource.end = __pa_symbol(&__bss_stop) - 1;
 701
 702         for_each_mem_range(i, &start, &end) {
 703                 struct resource *res;
 704
 705                 res = memblock_alloc(sizeof(struct resource), SMP_CACHE_BYTES);
 706                 if (!res)
 707                         panic("%s: Failed to allocate %zu bytes\n", __func__,
 708                               sizeof(struct resource));
 709
 710                 res->start = start;
 711                 /*
 712                  * In memblock, end points to the first byte after the
 713                  * range while in resourses, end points to the last byte in
 714                  * the range.
 715                  */
 716                 res->end = end - 1;
 717                 res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 718                 res->name = "System RAM";
 719
 720                 request_resource(&iomem_resource, res);
 721
 722                 /*
 723                  *  We don't know which RAM region contains kernel data,
 724                  *  so we try it repeatedly and let the resource manager
 725                  *  test it.
 726                  */
 727                 request_resource(res, &code_resource);
 728                 request_resource(res, &data_resource);
 729                 request_resource(res, &bss_resource);
 730                 request_crashkernel(res);
 731         }
 732 }
 733
 734 #ifdef CONFIG_SMP
 735 static void __init prefill_possible_map(void)
 736 {
 737         int i, possible = num_possible_cpus();
 738
 739         if (possible > nr_cpu_ids)
 740                 possible = nr_cpu_ids;
 741
 742         for (i = 0; i < possible; i++)
 743                 set_cpu_possible(i, true);
 744         for (; i < NR_CPUS; i++)
 745                 set_cpu_possible(i, false);
 746
 747         nr_cpu_ids = possible;
 748 }
 749 #else
 750 static inline void prefill_possible_map(void) {}
 751 #endif
 752
 753 void __init setup_arch(char **cmdline_p)
 754 {
 755         cpu_probe();
 756         mips_cm_probe();
 757         prom_init();
 758
 759         setup_early_fdc_console();
 760 #ifdef CONFIG_EARLY_PRINTK
 761         setup_early_printk();
 762 #endif
 763         cpu_report();
 764         check_bugs_early();
 765
 766 #if defined(CONFIG_VT)
 767 #if defined(CONFIG_VGA_CONSOLE)
 768         conswitchp = &vga_con;
 769 #endif
 770 #endif
 771
 772         arch_mem_init(cmdline_p);
 773         dmi_setup();
 774
 775         resource_init();
 776         plat_smp_setup();
 777         prefill_possible_map();
 778
 779         cpu_cache_init();
 780         paging_init();
 781
 782         memblock_dump_all();
 783 }
 784
 785 unsigned long kernelsp[NR_CPUS];
 786 unsigned long fw_arg0, fw_arg1, fw_arg2, fw_arg3;
 787
 788 #ifdef CONFIG_DEBUG_FS
 789 struct dentry *mips_debugfs_dir;
 790 static int __init debugfs_mips(void)
 791 {
 792         mips_debugfs_dir = debugfs_create_dir("mips", NULL);
 793         return 0;
 794 }
 795 arch_initcall(debugfs_mips);
 796 #endif
 797
 798 #ifdef CONFIG_DMA_NONCOHERENT
 799 static int __init setcoherentio(char *str)
 800 {
 801         dma_default_coherent = true;
 802         pr_info("Hardware DMA cache coherency (command line)\n");
 803         return 0;
 804 }
 805 early_param("coherentio", setcoherentio);
 806
 807 static int __init setnocoherentio(char *str)
 808 {
 809         dma_default_coherent = false;
 810         pr_info("Software DMA cache coherency (command line)\n");
 811         return 0;
 812 }
 813 early_param("nocoherentio", setnocoherentio);
 814 #endif
 815
 816 void __init arch_cpu_finalize_init(void)
 817 {
 818         unsigned int cpu = smp_processor_id();
 819
 820         cpu_data[cpu].udelay_val = loops_per_jiffy;
 821         check_bugs32();
 822
 823         if (IS_ENABLED(CONFIG_CPU_R4X00_BUGS64))
 824                 check_bugs64();
 825 }