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
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
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-map-ops.h>
28 #include <linux/decompress/generic.h>
29 #include <linux/of_fdt.h>
30 #include <linux/dmi.h>
31 #include <linux/crash_dump.h>
33 #include <asm/addrspace.h>
34 #include <asm/bootinfo.h>
36 #include <asm/cache.h>
39 #include <asm/debug.h>
40 #include <asm/mmzone.h>
41 #include <asm/sections.h>
42 #include <asm/setup.h>
43 #include <asm/smp-ops.h>
45 #include <asm/fw/fw.h>
47 #ifdef CONFIG_MIPS_ELF_APPENDED_DTB
48 char __section(".appended_dtb") __appended_dtb
[0x100000];
49 #endif /* CONFIG_MIPS_ELF_APPENDED_DTB */
51 struct cpuinfo_mips cpu_data
[NR_CPUS
] __read_mostly
;
53 EXPORT_SYMBOL(cpu_data
);
56 struct screen_info screen_info
;
62 * These are initialized so they are in the .data section
64 unsigned long mips_machtype __read_mostly
= MACH_UNKNOWN
;
66 EXPORT_SYMBOL(mips_machtype
);
68 static char __initdata command_line
[COMMAND_LINE_SIZE
];
69 char __initdata arcs_cmdline
[COMMAND_LINE_SIZE
];
71 #ifdef CONFIG_CMDLINE_BOOL
72 static const char builtin_cmdline
[] __initconst
= CONFIG_CMDLINE
;
74 static const char builtin_cmdline
[] __initconst
= "";
78 * mips_io_port_base is the begin of the address space to which x86 style
79 * I/O ports are mapped.
81 unsigned long mips_io_port_base
= -1;
82 EXPORT_SYMBOL(mips_io_port_base
);
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", };
88 unsigned long __kaslr_offset __ro_after_init
;
89 EXPORT_SYMBOL(__kaslr_offset
);
91 static void *detect_magic __initdata
= detect_memory_region
;
93 #ifdef CONFIG_MIPS_AUTO_PFN_OFFSET
94 unsigned long ARCH_PFN_OFFSET
;
95 EXPORT_SYMBOL(ARCH_PFN_OFFSET
);
98 void __init
detect_memory_region(phys_addr_t start
, phys_addr_t sz_min
, phys_addr_t sz_max
)
100 void *dm
= &detect_magic
;
103 for (size
= sz_min
; size
< sz_max
; size
<<= 1) {
104 if (!memcmp(dm
, dm
+ size
, sizeof(detect_magic
)))
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
);
114 memblock_add(start
, size
);
120 #ifdef CONFIG_BLK_DEV_INITRD
122 static int __init
rd_start_early(char *p
)
124 unsigned long start
= memparse(p
, &p
);
127 /* Guess if the sign extension was forgotten by bootloader */
131 initrd_start
= start
;
135 early_param("rd_start", rd_start_early
);
137 static int __init
rd_size_early(char *p
)
139 initrd_end
+= memparse(p
, &p
);
142 early_param("rd_size", rd_size_early
);
144 /* it returns the next free pfn after initrd */
145 static unsigned long __init
init_initrd(void)
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.
154 if (!initrd_start
|| initrd_end
<= initrd_start
)
157 if (initrd_start
& ~PAGE_MASK
) {
158 pr_err("initrd start must be page aligned\n");
161 if (initrd_start
< PAGE_OFFSET
) {
162 pr_err("initrd start < PAGE_OFFSET\n");
167 * Sanitize initrd addresses. For example firmware
168 * can't guess if they need to pass them through
169 * 64-bits values if the kernel has been built in pure
170 * 32-bit. We need also to switch from KSEG0 to XKPHYS
171 * addresses now, so the code can now safely use __pa().
173 end
= __pa(initrd_end
);
174 initrd_end
= (unsigned long)__va(end
);
175 initrd_start
= (unsigned long)__va(__pa(initrd_start
));
177 ROOT_DEV
= Root_RAM0
;
185 /* In some conditions (e.g. big endian bootloader with a little endian
186 kernel), the initrd might appear byte swapped. Try to detect this and
187 byte swap it if needed. */
188 static void __init
maybe_bswap_initrd(void)
190 #if defined(CONFIG_CPU_CAVIUM_OCTEON)
193 /* Check for CPIO signature */
194 if (!memcmp((void *)initrd_start
, "070701", 6))
197 /* Check for compressed initrd */
198 if (decompress_method((unsigned char *)initrd_start
, 8, NULL
))
201 /* Try again with a byte swapped header */
202 buf
= swab64p((u64
*)initrd_start
);
203 if (!memcmp(&buf
, "070701", 6) ||
204 decompress_method((unsigned char *)(&buf
), 8, NULL
)) {
207 pr_info("Byteswapped initrd detected\n");
208 for (i
= initrd_start
; i
< ALIGN(initrd_end
, 8); i
+= 8)
214 static void __init
finalize_initrd(void)
216 unsigned long size
= initrd_end
- initrd_start
;
219 printk(KERN_INFO
"Initrd not found or empty");
222 if (__pa(initrd_end
) > PFN_PHYS(max_low_pfn
)) {
223 printk(KERN_ERR
"Initrd extends beyond end of memory");
227 maybe_bswap_initrd();
229 memblock_reserve(__pa(initrd_start
), size
);
230 initrd_below_start_ok
= 1;
232 pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n",
236 printk(KERN_CONT
" - disabling initrd\n");
241 #else /* !CONFIG_BLK_DEV_INITRD */
243 static unsigned long __init
init_initrd(void)
248 #define finalize_initrd() do {} while (0)
253 * Initialize the bootmem allocator. It also setup initrd related data
256 #if defined(CONFIG_SGI_IP27) || (defined(CONFIG_CPU_LOONGSON64) && defined(CONFIG_NUMA))
258 static void __init
bootmem_init(void)
264 #else /* !CONFIG_SGI_IP27 */
266 static void __init
bootmem_init(void)
268 phys_addr_t ramstart
, ramend
;
269 unsigned long start
, end
;
272 ramstart
= memblock_start_of_DRAM();
273 ramend
= memblock_end_of_DRAM();
276 * Sanity check any INITRD first. We don't take it into account
277 * for bootmem setup initially, rely on the end-of-kernel-code
278 * as our memory range starting point. Once bootmem is inited we
279 * will reserve the area used for the initrd.
283 /* Reserve memory occupied by kernel. */
284 memblock_reserve(__pa_symbol(&_text
),
285 __pa_symbol(&_end
) - __pa_symbol(&_text
));
287 /* max_low_pfn is not a number of pages but the end pfn of low mem */
289 #ifdef CONFIG_MIPS_AUTO_PFN_OFFSET
290 ARCH_PFN_OFFSET
= PFN_UP(ramstart
);
293 * Reserve any memory between the start of RAM and PHYS_OFFSET
295 if (ramstart
> PHYS_OFFSET
)
296 memblock_reserve(PHYS_OFFSET
, ramstart
- PHYS_OFFSET
);
298 if (PFN_UP(ramstart
) > ARCH_PFN_OFFSET
) {
299 pr_info("Wasting %lu bytes for tracking %lu unused pages\n",
300 (unsigned long)((PFN_UP(ramstart
) - ARCH_PFN_OFFSET
) * sizeof(struct page
)),
301 (unsigned long)(PFN_UP(ramstart
) - ARCH_PFN_OFFSET
));
305 min_low_pfn
= ARCH_PFN_OFFSET
;
306 max_pfn
= PFN_DOWN(ramend
);
307 for_each_mem_pfn_range(i
, MAX_NUMNODES
, &start
, &end
, NULL
) {
309 * Skip highmem here so we get an accurate max_low_pfn if low
310 * memory stops short of high memory.
311 * If the region overlaps HIGHMEM_START, end is clipped so
312 * max_pfn excludes the highmem portion.
314 if (start
>= PFN_DOWN(HIGHMEM_START
))
316 if (end
> PFN_DOWN(HIGHMEM_START
))
317 end
= PFN_DOWN(HIGHMEM_START
);
318 if (end
> max_low_pfn
)
322 if (min_low_pfn
>= max_low_pfn
)
323 panic("Incorrect memory mapping !!!");
325 if (max_pfn
> PFN_DOWN(HIGHMEM_START
)) {
326 #ifdef CONFIG_HIGHMEM
327 highstart_pfn
= PFN_DOWN(HIGHMEM_START
);
328 highend_pfn
= max_pfn
;
330 max_low_pfn
= PFN_DOWN(HIGHMEM_START
);
331 max_pfn
= max_low_pfn
;
336 * Reserve initrd memory if needed.
341 #endif /* CONFIG_SGI_IP27 */
343 static int usermem __initdata
;
345 static int __init
early_parse_mem(char *p
)
347 phys_addr_t start
, size
;
350 pr_err("mem parameter is empty, do nothing\n");
355 * If a user specifies memory size, we
356 * blow away any automatically generated
361 memblock_remove(memblock_start_of_DRAM(),
362 memblock_end_of_DRAM() - memblock_start_of_DRAM());
365 size
= memparse(p
, &p
);
367 start
= memparse(p
+ 1, &p
);
369 if (IS_ENABLED(CONFIG_NUMA
))
370 memblock_add_node(start
, size
, pa_to_nid(start
), MEMBLOCK_NONE
);
372 memblock_add(start
, size
);
376 early_param("mem", early_parse_mem
);
378 static int __init
early_parse_memmap(char *p
)
381 u64 start_at
, mem_size
;
386 if (!strncmp(p
, "exactmap", 8)) {
387 pr_err("\"memmap=exactmap\" invalid on MIPS\n");
392 mem_size
= memparse(p
, &p
);
397 start_at
= memparse(p
+1, &p
);
398 memblock_add(start_at
, mem_size
);
399 } else if (*p
== '#') {
400 pr_err("\"memmap=nn#ss\" (force ACPI data) invalid on MIPS\n");
402 } else if (*p
== '$') {
403 start_at
= memparse(p
+1, &p
);
404 memblock_add(start_at
, mem_size
);
405 memblock_reserve(start_at
, mem_size
);
407 pr_err("\"memmap\" invalid format!\n");
417 early_param("memmap", early_parse_memmap
);
419 static void __init
mips_reserve_vmcore(void)
421 #ifdef CONFIG_PROC_VMCORE
422 phys_addr_t start
, end
;
425 if (!elfcorehdr_size
) {
426 for_each_mem_range(i
, &start
, &end
) {
427 if (elfcorehdr_addr
>= start
&& elfcorehdr_addr
< end
) {
429 * Reserve from the elf core header to the end of
430 * the memory segment, that should all be kdump
433 elfcorehdr_size
= end
- elfcorehdr_addr
;
439 pr_info("Reserving %ldKB of memory at %ldKB for kdump\n",
440 (unsigned long)elfcorehdr_size
>> 10, (unsigned long)elfcorehdr_addr
>> 10);
442 memblock_reserve(elfcorehdr_addr
, elfcorehdr_size
);
448 /* 64M alignment for crash kernel regions */
449 #define CRASH_ALIGN SZ_64M
450 #define CRASH_ADDR_MAX SZ_512M
452 static void __init
mips_parse_crashkernel(void)
454 unsigned long long total_mem
;
455 unsigned long long crash_size
, crash_base
;
458 total_mem
= memblock_phys_mem_size();
459 ret
= parse_crashkernel(boot_command_line
, total_mem
,
460 &crash_size
, &crash_base
);
461 if (ret
!= 0 || crash_size
<= 0)
464 if (crash_base
<= 0) {
465 crash_base
= memblock_phys_alloc_range(crash_size
, CRASH_ALIGN
,
469 pr_warn("crashkernel reservation failed - No suitable area found.\n");
473 unsigned long long start
;
475 start
= memblock_phys_alloc_range(crash_size
, 1,
477 crash_base
+ crash_size
);
478 if (start
!= crash_base
) {
479 pr_warn("Invalid memory region reserved for crash kernel\n");
484 crashk_res
.start
= crash_base
;
485 crashk_res
.end
= crash_base
+ crash_size
- 1;
488 static void __init
request_crashkernel(struct resource
*res
)
492 if (crashk_res
.start
== crashk_res
.end
)
495 ret
= request_resource(res
, &crashk_res
);
497 pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
498 (unsigned long)(resource_size(&crashk_res
) >> 20),
499 (unsigned long)(crashk_res
.start
>> 20));
501 #else /* !defined(CONFIG_KEXEC) */
502 static void __init
mips_parse_crashkernel(void)
506 static void __init
request_crashkernel(struct resource
*res
)
509 #endif /* !defined(CONFIG_KEXEC) */
511 static void __init
check_kernel_sections_mem(void)
513 phys_addr_t start
= __pa_symbol(&_text
);
514 phys_addr_t size
= __pa_symbol(&_end
) - start
;
516 if (!memblock_is_region_memory(start
, size
)) {
517 pr_info("Kernel sections are not in the memory maps\n");
518 memblock_add(start
, size
);
522 static void __init
bootcmdline_append(const char *s
, size_t max
)
527 if (boot_command_line
[0])
528 strlcat(boot_command_line
, " ", COMMAND_LINE_SIZE
);
530 strlcat(boot_command_line
, s
, max
);
533 #ifdef CONFIG_OF_EARLY_FLATTREE
535 static int __init
bootcmdline_scan_chosen(unsigned long node
, const char *uname
,
536 int depth
, void *data
)
538 bool *dt_bootargs
= data
;
542 if (depth
!= 1 || !data
||
543 (strcmp(uname
, "chosen") != 0 && strcmp(uname
, "chosen@0") != 0))
546 p
= of_get_flat_dt_prop(node
, "bootargs", &l
);
547 if (p
!= NULL
&& l
> 0) {
548 bootcmdline_append(p
, min(l
, COMMAND_LINE_SIZE
));
555 #endif /* CONFIG_OF_EARLY_FLATTREE */
557 static void __init
bootcmdline_init(void)
559 bool dt_bootargs
= false;
562 * If CMDLINE_OVERRIDE is enabled then initializing the command line is
563 * trivial - we simply use the built-in command line unconditionally &
566 if (IS_ENABLED(CONFIG_CMDLINE_OVERRIDE
)) {
567 strscpy(boot_command_line
, builtin_cmdline
, COMMAND_LINE_SIZE
);
572 * If the user specified a built-in command line &
573 * MIPS_CMDLINE_BUILTIN_EXTEND, then the built-in command line is
574 * prepended to arguments from the bootloader or DT so we'll copy them
575 * to the start of boot_command_line here. Otherwise, empty
576 * boot_command_line to undo anything early_init_dt_scan_chosen() did.
578 if (IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND
))
579 strscpy(boot_command_line
, builtin_cmdline
, COMMAND_LINE_SIZE
);
581 boot_command_line
[0] = 0;
583 #ifdef CONFIG_OF_EARLY_FLATTREE
585 * If we're configured to take boot arguments from DT, look for those
588 if (IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB
) ||
589 IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND
))
590 of_scan_flat_dt(bootcmdline_scan_chosen
, &dt_bootargs
);
594 * If we didn't get any arguments from DT (regardless of whether that's
595 * because we weren't configured to look for them, or because we looked
596 * & found none) then we'll take arguments from the bootloader.
597 * plat_mem_setup() should have filled arcs_cmdline with arguments from
600 if (IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND
) || !dt_bootargs
)
601 bootcmdline_append(arcs_cmdline
, COMMAND_LINE_SIZE
);
604 * If the user specified a built-in command line & we didn't already
605 * prepend it, we append it to boot_command_line here.
607 if (IS_ENABLED(CONFIG_CMDLINE_BOOL
) &&
608 !IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND
))
609 bootcmdline_append(builtin_cmdline
, COMMAND_LINE_SIZE
);
613 * arch_mem_init - initialize memory management subsystem
615 * o plat_mem_setup() detects the memory configuration and will record detected
616 * memory areas using memblock_add.
618 * At this stage the memory configuration of the system is known to the
619 * kernel but generic memory management system is still entirely uninitialized.
624 * o dma_contiguous_reserve()
626 * At this stage the bootmem allocator is ready to use.
628 * NOTE: historically plat_mem_setup did the entire platform initialization.
629 * This was rather impractical because it meant plat_mem_setup had to
630 * get away without any kind of memory allocator. To keep old code from
631 * breaking plat_setup was just renamed to plat_mem_setup and a second platform
632 * initialization hook for anything else was introduced.
634 static void __init
arch_mem_init(char **cmdline_p
)
636 /* call board setup routine */
638 memblock_set_bottom_up(true);
641 strscpy(command_line
, boot_command_line
, COMMAND_LINE_SIZE
);
642 *cmdline_p
= command_line
;
647 pr_info("User-defined physical RAM map overwrite\n");
649 check_kernel_sections_mem();
651 early_init_fdt_reserve_self();
652 early_init_fdt_scan_reserved_mem();
655 memblock_set_node(0, PHYS_ADDR_MAX
, &memblock
.memory
, 0);
660 * Prevent memblock from allocating high memory.
661 * This cannot be done before max_low_pfn is detected, so up
662 * to this point is possible to only reserve physical memory
663 * with memblock_reserve; memblock_alloc* can be used
664 * only after this point
666 memblock_set_current_limit(PFN_PHYS(max_low_pfn
));
668 mips_reserve_vmcore();
670 mips_parse_crashkernel();
674 * In order to reduce the possibility of kernel panic when failed to
675 * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
676 * low memory as small as possible before plat_swiotlb_setup(), so
677 * make sparse_init() using top-down allocation.
679 memblock_set_bottom_up(false);
681 memblock_set_bottom_up(true);
683 plat_swiotlb_setup();
685 dma_contiguous_reserve(PFN_PHYS(max_low_pfn
));
687 /* Reserve for hibernation. */
688 memblock_reserve(__pa_symbol(&__nosave_begin
),
689 __pa_symbol(&__nosave_end
) - __pa_symbol(&__nosave_begin
));
691 early_memtest(PFN_PHYS(ARCH_PFN_OFFSET
), PFN_PHYS(max_low_pfn
));
694 static void __init
resource_init(void)
696 phys_addr_t start
, end
;
699 if (UNCAC_BASE
!= IO_BASE
)
702 code_resource
.start
= __pa_symbol(&_text
);
703 code_resource
.end
= __pa_symbol(&_etext
) - 1;
704 data_resource
.start
= __pa_symbol(&_etext
);
705 data_resource
.end
= __pa_symbol(&_edata
) - 1;
706 bss_resource
.start
= __pa_symbol(&__bss_start
);
707 bss_resource
.end
= __pa_symbol(&__bss_stop
) - 1;
709 for_each_mem_range(i
, &start
, &end
) {
710 struct resource
*res
;
712 res
= memblock_alloc(sizeof(struct resource
), SMP_CACHE_BYTES
);
714 panic("%s: Failed to allocate %zu bytes\n", __func__
,
715 sizeof(struct resource
));
719 * In memblock, end points to the first byte after the
720 * range while in resourses, end points to the last byte in
724 res
->flags
= IORESOURCE_SYSTEM_RAM
| IORESOURCE_BUSY
;
725 res
->name
= "System RAM";
727 request_resource(&iomem_resource
, res
);
730 * We don't know which RAM region contains kernel data,
731 * so we try it repeatedly and let the resource manager
734 request_resource(res
, &code_resource
);
735 request_resource(res
, &data_resource
);
736 request_resource(res
, &bss_resource
);
737 request_crashkernel(res
);
742 static void __init
prefill_possible_map(void)
744 int i
, possible
= num_possible_cpus();
746 if (possible
> nr_cpu_ids
)
747 possible
= nr_cpu_ids
;
749 for (i
= 0; i
< possible
; i
++)
750 set_cpu_possible(i
, true);
751 for (; i
< NR_CPUS
; i
++)
752 set_cpu_possible(i
, false);
754 set_nr_cpu_ids(possible
);
757 static inline void prefill_possible_map(void) {}
760 static void __init
setup_rng_seed(void)
762 char *rng_seed_hex
= fw_getenv("rngseed");
769 len
= min(sizeof(rng_seed
), strlen(rng_seed_hex
) / 2);
770 if (hex2bin(rng_seed
, rng_seed_hex
, len
))
773 add_bootloader_randomness(rng_seed
, len
);
774 memzero_explicit(rng_seed
, len
);
775 memzero_explicit(rng_seed_hex
, len
* 2);
778 void __init
setup_arch(char **cmdline_p
)
784 setup_early_fdc_console();
785 #ifdef CONFIG_EARLY_PRINTK
786 setup_early_printk();
791 #if defined(CONFIG_VT)
792 #if defined(CONFIG_VGA_CONSOLE)
793 conswitchp
= &vga_con
;
797 arch_mem_init(cmdline_p
);
802 prefill_possible_map();
812 unsigned long kernelsp
[NR_CPUS
];
813 unsigned long fw_arg0
, fw_arg1
, fw_arg2
, fw_arg3
;
815 #ifdef CONFIG_DEBUG_FS
816 struct dentry
*mips_debugfs_dir
;
817 static int __init
debugfs_mips(void)
819 mips_debugfs_dir
= debugfs_create_dir("mips", NULL
);
822 arch_initcall(debugfs_mips
);
825 #ifdef CONFIG_DMA_NONCOHERENT
826 static int __init
setcoherentio(char *str
)
828 dma_default_coherent
= true;
829 pr_info("Hardware DMA cache coherency (command line)\n");
832 early_param("coherentio", setcoherentio
);
834 static int __init
setnocoherentio(char *str
)
836 dma_default_coherent
= false;
837 pr_info("Software DMA cache coherency (command line)\n");
840 early_param("nocoherentio", setnocoherentio
);