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