setup.c 22.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1995 Linus Torvalds
 * Copyright (C) 1995 Waldorf Electronics
 * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 03  Ralf Baechle
 * Copyright (C) 1996 Stoned Elipot
 * Copyright (C) 1999 Silicon Graphics, Inc.
Ralf Baechle's avatar
Ralf Baechle committed
11
 * Copyright (C) 2000, 2001, 2002, 2007	 Maciej W. Rozycki
Linus Torvalds's avatar
Linus Torvalds committed
12
13
14
 */
#include <linux/init.h>
#include <linux/ioport.h>
15
#include <linux/export.h>
16
#include <linux/screen_info.h>
Tejun Heo's avatar
Tejun Heo committed
17
#include <linux/memblock.h>
Linus Torvalds's avatar
Linus Torvalds committed
18
19
20
21
22
#include <linux/bootmem.h>
#include <linux/initrd.h>
#include <linux/root_dev.h>
#include <linux/highmem.h>
#include <linux/console.h>
Dave Hansen's avatar
Dave Hansen committed
23
#include <linux/pfn.h>
24
#include <linux/debugfs.h>
Ralf Baechle's avatar
Ralf Baechle committed
25
#include <linux/kexec.h>
26
#include <linux/sizes.h>
27
28
#include <linux/device.h>
#include <linux/dma-contiguous.h>
29
#include <linux/decompress/generic.h>
Linus Torvalds's avatar
Linus Torvalds committed
30
31
32

#include <asm/addrspace.h>
#include <asm/bootinfo.h>
33
#include <asm/bugs.h>
34
#include <asm/cache.h>
35
#include <asm/cdmm.h>
Linus Torvalds's avatar
Linus Torvalds committed
36
#include <asm/cpu.h>
37
#include <asm/debug.h>
Linus Torvalds's avatar
Linus Torvalds committed
38
39
#include <asm/sections.h>
#include <asm/setup.h>
40
#include <asm/smp-ops.h>
41
#include <asm/prom.h>
Linus Torvalds's avatar
Linus Torvalds committed
42

43
44
45
46
#ifdef CONFIG_MIPS_ELF_APPENDED_DTB
const char __section(.appended_dtb) __appended_dtb[0x100000];
#endif /* CONFIG_MIPS_ELF_APPENDED_DTB */

47
struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
48
49
50
51
52
53
54
55
56
57
58
59

EXPORT_SYMBOL(cpu_data);

#ifdef CONFIG_VT
struct screen_info screen_info;
#endif

/*
 * Setup information
 *
 * These are initialized so they are in the .data section
 */
60
unsigned long mips_machtype __read_mostly = MACH_UNKNOWN;
Linus Torvalds's avatar
Linus Torvalds committed
61
62
63
64
65

EXPORT_SYMBOL(mips_machtype);

struct boot_mem_map boot_mem_map;

66
67
68
69
70
71
static char __initdata command_line[COMMAND_LINE_SIZE];
char __initdata arcs_cmdline[COMMAND_LINE_SIZE];

#ifdef CONFIG_CMDLINE_BOOL
static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
72
73
74
75
76

/*
 * mips_io_port_base is the begin of the address space to which x86 style
 * I/O ports are mapped.
 */
David Daney's avatar
David Daney committed
77
const unsigned long mips_io_port_base = -1;
Linus Torvalds's avatar
Linus Torvalds committed
78
79
80
81
82
EXPORT_SYMBOL(mips_io_port_base);

static struct resource code_resource = { .name = "Kernel code", };
static struct resource data_resource = { .name = "Kernel data", };

83
84
static void *detect_magic __initdata = detect_memory_region;

85
void __init add_memory_region(phys_addr_t start, phys_addr_t size, long type)
Linus Torvalds's avatar
Linus Torvalds committed
86
87
{
	int x = boot_mem_map.nr_map;
88
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
89

90
91
92
93
94
95
96
	/*
	 * If the region reaches the top of the physical address space, adjust
	 * the size slightly so that (start + size) doesn't overflow
	 */
	if (start + size - 1 == (phys_addr_t)ULLONG_MAX)
		--size;

97
98
	/* Sanity check */
	if (start + size < start) {
99
		pr_warn("Trying to add an invalid memory region, skipped\n");
100
101
102
		return;
	}

Linus Torvalds's avatar
Linus Torvalds committed
103
	/*
104
	 * Try to merge with existing entry, if any.
Linus Torvalds's avatar
Linus Torvalds committed
105
	 */
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
	for (i = 0; i < boot_mem_map.nr_map; i++) {
		struct boot_mem_map_entry *entry = boot_mem_map.map + i;
		unsigned long top;

		if (entry->type != type)
			continue;

		if (start + size < entry->addr)
			continue;			/* no overlap */

		if (entry->addr + entry->size < start)
			continue;			/* no overlap */

		top = max(entry->addr + entry->size, start + size);
		entry->addr = min(entry->addr, start);
		entry->size = top - entry->addr;

Linus Torvalds's avatar
Linus Torvalds committed
123
124
125
		return;
	}

126
	if (boot_mem_map.nr_map == BOOT_MEM_MAP_MAX) {
127
		pr_err("Ooops! Too many entries in the memory map!\n");
Linus Torvalds's avatar
Linus Torvalds committed
128
129
130
131
132
133
134
135
136
		return;
	}

	boot_mem_map.map[x].addr = start;
	boot_mem_map.map[x].size = size;
	boot_mem_map.map[x].type = type;
	boot_mem_map.nr_map++;
}

137
void __init detect_memory_region(phys_addr_t start, phys_addr_t sz_min, phys_addr_t sz_max)
138
139
{
	void *dm = &detect_magic;
140
	phys_addr_t size;
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

	for (size = sz_min; size < sz_max; size <<= 1) {
		if (!memcmp(dm, dm + size, sizeof(detect_magic)))
			break;
	}

	pr_debug("Memory: %lluMB of RAM detected at 0x%llx (min: %lluMB, max: %lluMB)\n",
		((unsigned long long) size) / SZ_1M,
		(unsigned long long) start,
		((unsigned long long) sz_min) / SZ_1M,
		((unsigned long long) sz_max) / SZ_1M);

	add_memory_region(start, size, BOOT_MEM_RAM);
}

Linus Torvalds's avatar
Linus Torvalds committed
156
157
158
159
160
161
static void __init print_memory_map(void)
{
	int i;
	const int field = 2 * sizeof(unsigned long);

	for (i = 0; i < boot_mem_map.nr_map; i++) {
162
		printk(KERN_INFO " memory: %0*Lx @ %0*Lx ",
Linus Torvalds's avatar
Linus Torvalds committed
163
164
165
166
167
		       field, (unsigned long long) boot_mem_map.map[i].size,
		       field, (unsigned long long) boot_mem_map.map[i].addr);

		switch (boot_mem_map.map[i].type) {
		case BOOT_MEM_RAM:
168
			printk(KERN_CONT "(usable)\n");
Linus Torvalds's avatar
Linus Torvalds committed
169
			break;
170
171
172
		case BOOT_MEM_INIT_RAM:
			printk(KERN_CONT "(usable after init)\n");
			break;
Linus Torvalds's avatar
Linus Torvalds committed
173
		case BOOT_MEM_ROM_DATA:
174
			printk(KERN_CONT "(ROM data)\n");
Linus Torvalds's avatar
Linus Torvalds committed
175
176
			break;
		case BOOT_MEM_RESERVED:
177
			printk(KERN_CONT "(reserved)\n");
Linus Torvalds's avatar
Linus Torvalds committed
178
179
			break;
		default:
180
			printk(KERN_CONT "type %lu\n", boot_mem_map.map[i].type);
Linus Torvalds's avatar
Linus Torvalds committed
181
182
183
184
185
			break;
		}
	}
}

186
187
188
189
190
/*
 * Manage initrd
 */
#ifdef CONFIG_BLK_DEV_INITRD

191
static int __init rd_start_early(char *p)
Linus Torvalds's avatar
Linus Torvalds committed
192
{
193
	unsigned long start = memparse(p, &p);
Linus Torvalds's avatar
Linus Torvalds committed
194

195
#ifdef CONFIG_64BIT
196
197
198
	/* Guess if the sign extension was forgotten by bootloader */
	if (start < XKPHYS)
		start = (int)start;
Linus Torvalds's avatar
Linus Torvalds committed
199
#endif
200
201
202
203
204
205
206
207
208
	initrd_start = start;
	initrd_end += start;
	return 0;
}
early_param("rd_start", rd_start_early);

static int __init rd_size_early(char *p)
{
	initrd_end += memparse(p, &p);
Linus Torvalds's avatar
Linus Torvalds committed
209
210
	return 0;
}
211
early_param("rd_size", rd_size_early);
Linus Torvalds's avatar
Linus Torvalds committed
212

213
/* it returns the next free pfn after initrd */
214
215
static unsigned long __init init_initrd(void)
{
216
	unsigned long end;
217
218

	/*
219
220
221
	 * Board specific code or command line parser should have
	 * already set up initrd_start and initrd_end. In these cases
	 * perfom sanity checks and use them if all looks good.
222
	 */
223
	if (!initrd_start || initrd_end <= initrd_start)
224
225
226
		goto disable;

	if (initrd_start & ~PAGE_MASK) {
227
		pr_err("initrd start must be page aligned\n");
228
		goto disable;
229
	}
230
	if (initrd_start < PAGE_OFFSET) {
231
		pr_err("initrd start < PAGE_OFFSET\n");
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
		goto disable;
	}

	/*
	 * Sanitize initrd addresses. For example firmware
	 * can't guess if they need to pass them through
	 * 64-bits values if the kernel has been built in pure
	 * 32-bit. We need also to switch from KSEG0 to XKPHYS
	 * addresses now, so the code can now safely use __pa().
	 */
	end = __pa(initrd_end);
	initrd_end = (unsigned long)__va(end);
	initrd_start = (unsigned long)__va(__pa(initrd_start));

	ROOT_DEV = Root_RAM0;
	return PFN_UP(end);
disable:
	initrd_start = 0;
	initrd_end = 0;
	return 0;
252
253
}

254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
/* In some conditions (e.g. big endian bootloader with a little endian
   kernel), the initrd might appear byte swapped.  Try to detect this and
   byte swap it if needed.  */
static void __init maybe_bswap_initrd(void)
{
#if defined(CONFIG_CPU_CAVIUM_OCTEON)
	u64 buf;

	/* Check for CPIO signature */
	if (!memcmp((void *)initrd_start, "070701", 6))
		return;

	/* Check for compressed initrd */
	if (decompress_method((unsigned char *)initrd_start, 8, NULL))
		return;

	/* Try again with a byte swapped header */
	buf = swab64p((u64 *)initrd_start);
	if (!memcmp(&buf, "070701", 6) ||
	    decompress_method((unsigned char *)(&buf), 8, NULL)) {
		unsigned long i;

		pr_info("Byteswapped initrd detected\n");
		for (i = initrd_start; i < ALIGN(initrd_end, 8); i += 8)
			swab64s((u64 *)i);
	}
#endif
}

283
284
285
286
287
288
289
290
static void __init finalize_initrd(void)
{
	unsigned long size = initrd_end - initrd_start;

	if (size == 0) {
		printk(KERN_INFO "Initrd not found or empty");
		goto disable;
	}
291
	if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) {
292
		printk(KERN_ERR "Initrd extends beyond end of memory");
293
294
295
		goto disable;
	}

296
297
	maybe_bswap_initrd();

298
	reserve_bootmem(__pa(initrd_start), size, BOOTMEM_DEFAULT);
299
300
	initrd_below_start_ok = 1;

301
302
	pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n",
		initrd_start, size);
303
304
	return;
disable:
305
	printk(KERN_CONT " - disabling initrd\n");
306
307
308
309
310
311
	initrd_start = 0;
	initrd_end = 0;
}

#else  /* !CONFIG_BLK_DEV_INITRD */

312
313
314
315
316
static unsigned long __init init_initrd(void)
{
	return 0;
}

317
318
319
320
#define finalize_initrd()	do {} while (0)

#endif

321
322
323
324
/*
 * Initialize the bootmem allocator. It also setup initrd related data
 * if needed.
 */
325
#if defined(CONFIG_SGI_IP27) || (defined(CONFIG_CPU_LOONGSON3) && defined(CONFIG_NUMA))
326

327
static void __init bootmem_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
328
{
329
330
331
332
333
334
335
336
	init_initrd();
	finalize_initrd();
}

#else  /* !CONFIG_SGI_IP27 */

static void __init bootmem_init(void)
{
337
	unsigned long reserved_end;
338
	unsigned long mapstart = ~0UL;
Linus Torvalds's avatar
Linus Torvalds committed
339
340
341
342
	unsigned long bootmap_size;
	int i;

	/*
343
344
345
346
	 * Sanity check any INITRD first. We don't take it into account
	 * for bootmem setup initially, rely on the end-of-kernel-code
	 * as our memory range starting point. Once bootmem is inited we
	 * will reserve the area used for the initrd.
Linus Torvalds's avatar
Linus Torvalds committed
347
	 */
348
349
	init_initrd();
	reserved_end = (unsigned long) PFN_UP(__pa_symbol(&_end));
Linus Torvalds's avatar
Linus Torvalds committed
350

351
352
353
354
355
356
357
	/*
	 * max_low_pfn is not a number of pages. The number of pages
	 * of the system is given by 'max_low_pfn - min_low_pfn'.
	 */
	min_low_pfn = ~0UL;
	max_low_pfn = 0;

358
359
360
	/*
	 * Find the highest page frame number we have available.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
361
362
363
364
365
366
367
368
	for (i = 0; i < boot_mem_map.nr_map; i++) {
		unsigned long start, end;

		if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
			continue;

		start = PFN_UP(boot_mem_map.map[i].addr);
		end = PFN_DOWN(boot_mem_map.map[i].addr
369
				+ boot_mem_map.map[i].size);
Linus Torvalds's avatar
Linus Torvalds committed
370

371
372
373
374
375
376
377
378
379
380
381
382
383
#ifndef CONFIG_HIGHMEM
		/*
		 * Skip highmem here so we get an accurate max_low_pfn if low
		 * memory stops short of high memory.
		 * If the region overlaps HIGHMEM_START, end is clipped so
		 * max_pfn excludes the highmem portion.
		 */
		if (start >= PFN_DOWN(HIGHMEM_START))
			continue;
		if (end > PFN_DOWN(HIGHMEM_START))
			end = PFN_DOWN(HIGHMEM_START);
#endif

384
385
386
387
		if (end > max_low_pfn)
			max_low_pfn = end;
		if (start < min_low_pfn)
			min_low_pfn = start;
388
		if (end <= reserved_end)
Linus Torvalds's avatar
Linus Torvalds committed
389
			continue;
390
#ifdef CONFIG_BLK_DEV_INITRD
391
		/* Skip zones before initrd and initrd itself */
392
393
394
		if (initrd_end && end <= (unsigned long)PFN_UP(__pa(initrd_end)))
			continue;
#endif
395
396
397
		if (start >= mapstart)
			continue;
		mapstart = max(reserved_end, start);
Linus Torvalds's avatar
Linus Torvalds committed
398
399
	}

400
401
	if (min_low_pfn >= max_low_pfn)
		panic("Incorrect memory mapping !!!");
402
	if (min_low_pfn > ARCH_PFN_OFFSET) {
403
404
405
		pr_info("Wasting %lu bytes for tracking %lu unused pages\n",
			(min_low_pfn - ARCH_PFN_OFFSET) * sizeof(struct page),
			min_low_pfn - ARCH_PFN_OFFSET);
406
	} else if (min_low_pfn < ARCH_PFN_OFFSET) {
407
408
		pr_info("%lu free pages won't be used\n",
			ARCH_PFN_OFFSET - min_low_pfn);
409
	}
410
	min_low_pfn = ARCH_PFN_OFFSET;
411

Linus Torvalds's avatar
Linus Torvalds committed
412
413
414
	/*
	 * Determine low and high memory ranges
	 */
415
	max_pfn = max_low_pfn;
416
	if (max_low_pfn > PFN_DOWN(HIGHMEM_START)) {
417
418
#ifdef CONFIG_HIGHMEM
		highstart_pfn = PFN_DOWN(HIGHMEM_START);
419
		highend_pfn = max_low_pfn;
Linus Torvalds's avatar
Linus Torvalds committed
420
#endif
421
		max_low_pfn = PFN_DOWN(HIGHMEM_START);
Linus Torvalds's avatar
Linus Torvalds committed
422
423
	}

424
425
426
427
428
429
430
431
#ifdef CONFIG_BLK_DEV_INITRD
	/*
	 * mapstart should be after initrd_end
	 */
	if (initrd_end)
		mapstart = max(mapstart, (unsigned long)PFN_UP(__pa(initrd_end)));
#endif

Linus Torvalds's avatar
Linus Torvalds committed
432
	/*
433
	 * Initialize the boot-time allocator with low memory only.
Linus Torvalds's avatar
Linus Torvalds committed
434
	 */
435
436
	bootmap_size = init_bootmem_node(NODE_DATA(0), mapstart,
					 min_low_pfn, max_low_pfn);
437
438
439
440
441
442
443
444
445


	for (i = 0; i < boot_mem_map.nr_map; i++) {
		unsigned long start, end;

		start = PFN_UP(boot_mem_map.map[i].addr);
		end = PFN_DOWN(boot_mem_map.map[i].addr
				+ boot_mem_map.map[i].size);

446
447
		if (start <= min_low_pfn)
			start = min_low_pfn;
448
449
450
451
452
453
454
455
456
457
458
459
460
461
		if (start >= end)
			continue;

#ifndef CONFIG_HIGHMEM
		if (end > max_low_pfn)
			end = max_low_pfn;

		/*
		 * ... finally, is the area going away?
		 */
		if (end <= start)
			continue;
#endif

Tejun Heo's avatar
Tejun Heo committed
462
		memblock_add_node(PFN_PHYS(start), PFN_PHYS(end - start), 0);
463
464
	}

Linus Torvalds's avatar
Linus Torvalds committed
465
466
467
468
	/*
	 * Register fully available low RAM pages with the bootmem allocator.
	 */
	for (i = 0; i < boot_mem_map.nr_map; i++) {
469
		unsigned long start, end, size;
Linus Torvalds's avatar
Linus Torvalds committed
470

471
472
473
474
		start = PFN_UP(boot_mem_map.map[i].addr);
		end   = PFN_DOWN(boot_mem_map.map[i].addr
				    + boot_mem_map.map[i].size);

Linus Torvalds's avatar
Linus Torvalds committed
475
476
477
		/*
		 * Reserve usable memory.
		 */
478
479
480
481
482
		switch (boot_mem_map.map[i].type) {
		case BOOT_MEM_RAM:
			break;
		case BOOT_MEM_INIT_RAM:
			memory_present(0, start, end);
Linus Torvalds's avatar
Linus Torvalds committed
483
			continue;
484
485
486
487
		default:
			/* Not usable memory */
			continue;
		}
Linus Torvalds's avatar
Linus Torvalds committed
488
489

		/*
490
491
		 * We are rounding up the start address of usable memory
		 * and at the end of the usable range downwards.
Linus Torvalds's avatar
Linus Torvalds committed
492
		 */
493
		if (start >= max_low_pfn)
Linus Torvalds's avatar
Linus Torvalds committed
494
			continue;
495
496
497
498
		if (start < reserved_end)
			start = reserved_end;
		if (end > max_low_pfn)
			end = max_low_pfn;
Linus Torvalds's avatar
Linus Torvalds committed
499
500

		/*
501
		 * ... finally, is the area going away?
Linus Torvalds's avatar
Linus Torvalds committed
502
		 */
503
		if (end <= start)
Linus Torvalds's avatar
Linus Torvalds committed
504
			continue;
505
		size = end - start;
Linus Torvalds's avatar
Linus Torvalds committed
506
507

		/* Register lowmem ranges */
508
509
		free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT);
		memory_present(0, start, end);
Linus Torvalds's avatar
Linus Torvalds committed
510
511
	}

512
513
514
	/*
	 * Reserve the bootmap memory.
	 */
515
	reserve_bootmem(PFN_PHYS(mapstart), bootmap_size, BOOTMEM_DEFAULT);
516

517
518
519
520
521
522
523
524
#ifdef CONFIG_RELOCATABLE
	/*
	 * The kernel reserves all memory below its _end symbol as bootmem,
	 * but the kernel may now be at a much higher address. The memory
	 * between the original and new locations may be returned to the system.
	 */
	if (__pa_symbol(_text) > __pa_symbol(VMLINUX_LOAD_ADDRESS)) {
		unsigned long offset;
525
		extern void show_kernel_relocation(const char *level);
526
527
528

		offset = __pa_symbol(_text) - __pa_symbol(VMLINUX_LOAD_ADDRESS);
		free_bootmem(__pa_symbol(VMLINUX_LOAD_ADDRESS), offset);
529
530
531
532
533
534
535
536

#if defined(CONFIG_DEBUG_KERNEL) && defined(CONFIG_DEBUG_INFO)
		/*
		 * This information is necessary when debugging the kernel
		 * But is a security vulnerability otherwise!
		 */
		show_kernel_relocation(KERN_INFO);
#endif
537
538
539
	}
#endif

540
541
542
543
	/*
	 * Reserve initrd memory if needed.
	 */
	finalize_initrd();
Linus Torvalds's avatar
Linus Torvalds committed
544
545
}

546
547
#endif	/* CONFIG_SGI_IP27 */

548
/*
Joe Perches's avatar
Joe Perches committed
549
 * arch_mem_init - initialize memory management subsystem
550
551
552
553
554
 *
 *  o plat_mem_setup() detects the memory configuration and will record detected
 *    memory areas using add_memory_region.
 *
 * At this stage the memory configuration of the system is known to the
Joe Perches's avatar
Joe Perches committed
555
 * kernel but generic memory management system is still entirely uninitialized.
556
557
558
559
 *
 *  o bootmem_init()
 *  o sparse_init()
 *  o paging_init()
560
 *  o dma_contiguous_reserve()
561
562
563
564
 *
 * At this stage the bootmem allocator is ready to use.
 *
 * NOTE: historically plat_mem_setup did the entire platform initialization.
Ralf Baechle's avatar
Ralf Baechle committed
565
 *	 This was rather impractical because it meant plat_mem_setup had to
566
 * get away without any kind of memory allocator.  To keep old code from
567
 * breaking plat_setup was just renamed to plat_mem_setup and a second platform
568
569
570
 * initialization hook for anything else was introduced.
 */

571
static int usermem __initdata;
572
573
574

static int __init early_parse_mem(char *p)
{
575
	phys_addr_t start, size;
576
577
578
579
580
581
582
583
584

	/*
	 * If a user specifies memory size, we
	 * blow away any automatically generated
	 * size.
	 */
	if (usermem == 0) {
		boot_mem_map.nr_map = 0;
		usermem = 1;
Ralf Baechle's avatar
Ralf Baechle committed
585
	}
586
587
588
589
590
591
592
593
594
	start = 0;
	size = memparse(p, &p);
	if (*p == '@')
		start = memparse(p + 1, &p);

	add_memory_region(start, size, BOOT_MEM_RAM);
	return 0;
}
early_param("mem", early_parse_mem);
595

Corey Minyard's avatar
Corey Minyard committed
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
#ifdef CONFIG_PROC_VMCORE
unsigned long setup_elfcorehdr, setup_elfcorehdr_size;
static int __init early_parse_elfcorehdr(char *p)
{
	int i;

	setup_elfcorehdr = memparse(p, &p);

	for (i = 0; i < boot_mem_map.nr_map; i++) {
		unsigned long start = boot_mem_map.map[i].addr;
		unsigned long end = (boot_mem_map.map[i].addr +
				     boot_mem_map.map[i].size);
		if (setup_elfcorehdr >= start && setup_elfcorehdr < end) {
			/*
			 * Reserve from the elf core header to the end of
			 * the memory segment, that should all be kdump
			 * reserved memory.
			 */
			setup_elfcorehdr_size = end - setup_elfcorehdr;
			break;
		}
	}
	/*
	 * If we don't find it in the memory map, then we shouldn't
	 * have to worry about it, as the new kernel won't use it.
	 */
	return 0;
}
early_param("elfcorehdr", early_parse_elfcorehdr);
#endif

627
static void __init arch_mem_addpart(phys_addr_t mem, phys_addr_t end, int type)
628
{
629
	phys_addr_t size;
630
	int i;
631

632
633
634
635
636
637
638
639
640
641
642
643
644
	size = end - mem;
	if (!size)
		return;

	/* Make sure it is in the boot_mem_map */
	for (i = 0; i < boot_mem_map.nr_map; i++) {
		if (mem >= boot_mem_map.map[i].addr &&
		    mem < (boot_mem_map.map[i].addr +
			   boot_mem_map.map[i].size))
			return;
	}
	add_memory_region(mem, size, type);
}
645

646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
#ifdef CONFIG_KEXEC
static inline unsigned long long get_total_mem(void)
{
	unsigned long long total;

	total = max_pfn - min_low_pfn;
	return total << PAGE_SHIFT;
}

static void __init mips_parse_crashkernel(void)
{
	unsigned long long total_mem;
	unsigned long long crash_size, crash_base;
	int ret;

	total_mem = get_total_mem();
	ret = parse_crashkernel(boot_command_line, total_mem,
				&crash_size, &crash_base);
	if (ret != 0 || crash_size <= 0)
		return;

	crashk_res.start = crash_base;
	crashk_res.end	 = crash_base + crash_size - 1;
}

static void __init request_crashkernel(struct resource *res)
{
	int ret;

675
676
677
	if (crashk_res.start == crashk_res.end)
		return;

678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
	ret = request_resource(res, &crashk_res);
	if (!ret)
		pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
			(unsigned long)((crashk_res.end -
					 crashk_res.start + 1) >> 20),
			(unsigned long)(crashk_res.start  >> 20));
}
#else /* !defined(CONFIG_KEXEC)		*/
static void __init mips_parse_crashkernel(void)
{
}

static void __init request_crashkernel(struct resource *res)
{
}
#endif /* !defined(CONFIG_KEXEC)  */

695
696
#define USE_PROM_CMDLINE	IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_BOOTLOADER)
#define USE_DTB_CMDLINE		IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB)
Jaedon Shin's avatar
Jaedon Shin committed
697
#define EXTEND_WITH_PROM	IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND)
698
699
#define BUILTIN_EXTEND_WITH_PROM	\
	IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND)
700

701
702
static void __init arch_mem_init(char **cmdline_p)
{
703
	struct memblock_region *reg;
704
705
	extern void plat_mem_setup(void);

706
707
708
	/* call board setup routine */
	plat_mem_setup();

709
710
711
712
713
714
715
716
717
718
719
720
	/*
	 * Make sure all kernel memory is in the maps.  The "UP" and
	 * "DOWN" are opposite for initdata since if it crosses over
	 * into another memory section you don't want that to be
	 * freed when the initdata is freed.
	 */
	arch_mem_addpart(PFN_DOWN(__pa_symbol(&_text)) << PAGE_SHIFT,
			 PFN_UP(__pa_symbol(&_edata)) << PAGE_SHIFT,
			 BOOT_MEM_RAM);
	arch_mem_addpart(PFN_UP(__pa_symbol(&__init_begin)) << PAGE_SHIFT,
			 PFN_DOWN(__pa_symbol(&__init_end)) << PAGE_SHIFT,
			 BOOT_MEM_INIT_RAM);
721

722
	pr_info("Determined physical RAM map:\n");
723
724
	print_memory_map();

725
#if defined(CONFIG_CMDLINE_BOOL) && defined(CONFIG_CMDLINE_OVERRIDE)
726
727
	strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
#else
728
729
730
731
732
	if ((USE_PROM_CMDLINE && arcs_cmdline[0]) ||
	    (USE_DTB_CMDLINE && !boot_command_line[0]))
		strlcpy(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE);

	if (EXTEND_WITH_PROM && arcs_cmdline[0]) {
733
734
		if (boot_command_line[0])
			strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
735
736
737
738
		strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE);
	}

#if defined(CONFIG_CMDLINE_BOOL)
739
	if (builtin_cmdline[0]) {
740
741
		if (boot_command_line[0])
			strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
742
		strlcat(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
743
	}
744
745
746
747
748
749

	if (BUILTIN_EXTEND_WITH_PROM && arcs_cmdline[0]) {
		if (boot_command_line[0])
			strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
		strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE);
	}
750
751
752
#endif
#endif
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
753
754
755

	*cmdline_p = command_line;

756
757
758
	parse_early_param();

	if (usermem) {
759
		pr_info("User-defined physical RAM map:\n");
760
761
762
		print_memory_map();
	}

763
	bootmem_init();
Corey Minyard's avatar
Corey Minyard committed
764
765
766
767
768
769
770
771
#ifdef CONFIG_PROC_VMCORE
	if (setup_elfcorehdr && setup_elfcorehdr_size) {
		printk(KERN_INFO "kdump reserved memory at %lx-%lx\n",
		       setup_elfcorehdr, setup_elfcorehdr_size);
		reserve_bootmem(setup_elfcorehdr, setup_elfcorehdr_size,
				BOOTMEM_DEFAULT);
	}
#endif
772
773

	mips_parse_crashkernel();
Ralf Baechle's avatar
Ralf Baechle committed
774
775
776
777
778
779
#ifdef CONFIG_KEXEC
	if (crashk_res.start != crashk_res.end)
		reserve_bootmem(crashk_res.start,
				crashk_res.end - crashk_res.start + 1,
				BOOTMEM_DEFAULT);
#endif
780
	device_tree_init();
781
	sparse_init();
782
	plat_swiotlb_setup();
783
784
785
786

	dma_contiguous_reserve(PFN_PHYS(max_low_pfn));
	/* Tell bootmem about cma reserved memblock section */
	for_each_memblock(reserved, reg)
787
788
		if (reg->size != 0)
			reserve_bootmem(reg->base, reg->size, BOOTMEM_DEFAULT);
789
790
791

	reserve_bootmem_region(__pa_symbol(&__nosave_begin),
			__pa_symbol(&__nosave_end)); /* Reserve for hibernation */
792
793
}

794
static void __init resource_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
795
796
797
{
	int i;

798
799
800
	if (UNCAC_BASE != IO_BASE)
		return;

801
802
803
804
	code_resource.start = __pa_symbol(&_text);
	code_resource.end = __pa_symbol(&_etext) - 1;
	data_resource.start = __pa_symbol(&_etext);
	data_resource.end = __pa_symbol(&_edata) - 1;
Linus Torvalds's avatar
Linus Torvalds committed
805
806
807
808
809
810
811

	for (i = 0; i < boot_mem_map.nr_map; i++) {
		struct resource *res;
		unsigned long start, end;

		start = boot_mem_map.map[i].addr;
		end = boot_mem_map.map[i].addr + boot_mem_map.map[i].size - 1;
812
		if (start >= HIGHMEM_START)
Linus Torvalds's avatar
Linus Torvalds committed
813
			continue;
814
815
		if (end >= HIGHMEM_START)
			end = HIGHMEM_START - 1;
Linus Torvalds's avatar
Linus Torvalds committed
816
817

		res = alloc_bootmem(sizeof(struct resource));
818
819
820
821
822

		res->start = start;
		res->end = end;
		res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;

Linus Torvalds's avatar
Linus Torvalds committed
823
824
		switch (boot_mem_map.map[i].type) {
		case BOOT_MEM_RAM:
825
		case BOOT_MEM_INIT_RAM:
Linus Torvalds's avatar
Linus Torvalds committed
826
827
		case BOOT_MEM_ROM_DATA:
			res->name = "System RAM";
828
			res->flags |= IORESOURCE_SYSRAM;
Linus Torvalds's avatar
Linus Torvalds committed
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
			break;
		case BOOT_MEM_RESERVED:
		default:
			res->name = "reserved";
		}

		request_resource(&iomem_resource, res);

		/*
		 *  We don't know which RAM region contains kernel data,
		 *  so we try it repeatedly and let the resource manager
		 *  test it.
		 */
		request_resource(res, &code_resource);
		request_resource(res, &data_resource);
Ralf Baechle's avatar
Ralf Baechle committed
844
		request_crashkernel(res);
Linus Torvalds's avatar
Linus Torvalds committed
845
846
847
	}
}

848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
#ifdef CONFIG_SMP
static void __init prefill_possible_map(void)
{
	int i, possible = num_possible_cpus();

	if (possible > nr_cpu_ids)
		possible = nr_cpu_ids;

	for (i = 0; i < possible; i++)
		set_cpu_possible(i, true);
	for (; i < NR_CPUS; i++)
		set_cpu_possible(i, false);

	nr_cpu_ids = possible;
}
#else
static inline void prefill_possible_map(void) {}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
867
868
869
void __init setup_arch(char **cmdline_p)
{
	cpu_probe();
Paul Burton's avatar
Paul Burton committed
870
	mips_cm_probe();
Linus Torvalds's avatar
Linus Torvalds committed
871
	prom_init();
872

873
	setup_early_fdc_console();
874
#ifdef CONFIG_EARLY_PRINTK
875
	setup_early_printk();
876
#endif
Linus Torvalds's avatar
Linus Torvalds committed
877
	cpu_report();
878
	check_bugs_early();
Linus Torvalds's avatar
Linus Torvalds committed
879
880
881

#if defined(CONFIG_VT)
#if defined(CONFIG_VGA_CONSOLE)
Ralf Baechle's avatar
Ralf Baechle committed
882
	conswitchp = &vga_con;
Linus Torvalds's avatar
Linus Torvalds committed
883
#elif defined(CONFIG_DUMMY_CONSOLE)
Ralf Baechle's avatar
Ralf Baechle committed
884
	conswitchp = &dummy_con;
Linus Torvalds's avatar
Linus Torvalds committed
885
886
887
#endif
#endif

888
	arch_mem_init(cmdline_p);
Linus Torvalds's avatar
Linus Torvalds committed
889
890

	resource_init();
891
	plat_smp_setup();
892
	prefill_possible_map();
893
894

	cpu_cache_init();
895
	paging_init();
Linus Torvalds's avatar
Linus Torvalds committed
896
897
}

898
899
unsigned long kernelsp[NR_CPUS];
unsigned long fw_arg0, fw_arg1, fw_arg2, fw_arg3;
900

901
902
903
904
#ifdef CONFIG_USE_OF
unsigned long fw_passed_dtb;
#endif

905
906
907
908
909
910
911
#ifdef CONFIG_DEBUG_FS
struct dentry *mips_debugfs_dir;
static int __init debugfs_mips(void)
{
	struct dentry *d;

	d = debugfs_create_dir("mips", NULL);
912
913
	if (!d)
		return -ENOMEM;
914
915
916
917
918
	mips_debugfs_dir = d;
	return 0;
}
arch_initcall(debugfs_mips);
#endif