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