prom.c 25.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * Procedures for creating, accessing and interpreting the device tree.
 *
 * Paul Mackerras	August 1996.
 * Copyright (C) 1996-2005 Paul Mackerras.
 * 
 *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
 *    {engebret|bergner}@us.ibm.com 
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#undef DEBUG

#include <stdarg.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/threads.h>
#include <linux/spinlock.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/stringify.h>
#include <linux/delay.h>
#include <linux/initrd.h>
#include <linux/bitops.h>
30
#include <linux/export.h>
31
#include <linux/kexec.h>
32
#include <linux/debugfs.h>
33
#include <linux/irq.h>
Y
Yinghai Lu 已提交
34
#include <linux/memblock.h>
35 36 37 38 39 40 41

#include <asm/prom.h>
#include <asm/rtas.h>
#include <asm/page.h>
#include <asm/processor.h>
#include <asm/irq.h>
#include <asm/io.h>
42
#include <asm/kdump.h>
43 44 45
#include <asm/smp.h>
#include <asm/system.h>
#include <asm/mmu.h>
46
#include <asm/paca.h>
47 48 49 50 51 52 53
#include <asm/pgtable.h>
#include <asm/pci.h>
#include <asm/iommu.h>
#include <asm/btext.h>
#include <asm/sections.h>
#include <asm/machdep.h>
#include <asm/pSeries_reconfig.h>
54
#include <asm/pci-bridge.h>
55
#include <asm/phyp_dump.h>
56
#include <asm/kexec.h>
57 58
#include <asm/opal.h>

59
#include <mm/mmu_decl.h>
60 61 62 63 64 65 66 67

#ifdef DEBUG
#define DBG(fmt...) printk(KERN_ERR fmt)
#else
#define DBG(fmt...)
#endif

#ifdef CONFIG_PPC64
68
int __initdata iommu_is_off;
69
int __initdata iommu_force_on;
70
unsigned long tce_alloc_start, tce_alloc_end;
71
u64 ppc64_rma_size;
72
#endif
73
static phys_addr_t first_memblock_size;
74
static int __initdata boot_cpu_count;
75

76 77 78 79 80 81
static int __init early_parse_mem(char *p)
{
	if (!p)
		return 1;

	memory_limit = PAGE_ALIGN(memparse(p, &p));
82
	DBG("memory limit = 0x%llx\n", (unsigned long long)memory_limit);
83 84 85 86 87

	return 0;
}
early_param("mem", early_parse_mem);

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
/*
 * overlaps_initrd - check for overlap with page aligned extension of
 * initrd.
 */
static inline int overlaps_initrd(unsigned long start, unsigned long size)
{
#ifdef CONFIG_BLK_DEV_INITRD
	if (!initrd_start)
		return 0;

	return	(start + size) > _ALIGN_DOWN(initrd_start, PAGE_SIZE) &&
			start <= _ALIGN_UP(initrd_end, PAGE_SIZE);
#else
	return 0;
#endif
}

105 106 107 108
/**
 * move_device_tree - move tree to an unused area, if needed.
 *
 * The device tree may be allocated beyond our memory limit, or inside the
109 110
 * crash kernel region for kdump, or within the page aligned range of initrd.
 * If so, move it out of the way.
111
 */
112
static void __init move_device_tree(void)
113 114 115 116 117 118 119
{
	unsigned long start, size;
	void *p;

	DBG("-> move_device_tree\n");

	start = __pa(initial_boot_params);
120
	size = be32_to_cpu(initial_boot_params->totalsize);
121

122
	if ((memory_limit && (start + size) > PHYSICAL_START + memory_limit) ||
123 124
			overlaps_crashkernel(start, size) ||
			overlaps_initrd(start, size)) {
125
		p = __va(memblock_alloc(size, PAGE_SIZE));
126 127 128 129 130 131 132
		memcpy(p, initial_boot_params, size);
		initial_boot_params = (struct boot_param_header *)p;
		DBG("Moved device tree to 0x%p\n", p);
	}

	DBG("<- move_device_tree\n");
}
133

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
/*
 * ibm,pa-features is a per-cpu property that contains a string of
 * attribute descriptors, each of which has a 2 byte header plus up
 * to 254 bytes worth of processor attribute bits.  First header
 * byte specifies the number of bytes following the header.
 * Second header byte is an "attribute-specifier" type, of which
 * zero is the only currently-defined value.
 * Implementation:  Pass in the byte and bit offset for the feature
 * that we are interested in.  The function will return -1 if the
 * pa-features property is missing, or a 1/0 to indicate if the feature
 * is supported/not supported.  Note that the bit numbers are
 * big-endian to match the definition in PAPR.
 */
static struct ibm_pa_feature {
	unsigned long	cpu_features;	/* CPU_FTR_xxx bit */
149
	unsigned long	mmu_features;	/* MMU_FTR_xxx bit */
150 151 152 153 154
	unsigned int	cpu_user_ftrs;	/* PPC_FEATURE_xxx bit */
	unsigned char	pabyte;		/* byte number in ibm,pa-features */
	unsigned char	pabit;		/* bit number (big-endian) */
	unsigned char	invert;		/* if 1, pa bit set => clear feature */
} ibm_pa_features[] __initdata = {
155 156 157 158 159 160 161
	{0, 0, PPC_FEATURE_HAS_MMU,	0, 0, 0},
	{0, 0, PPC_FEATURE_HAS_FPU,	0, 1, 0},
	{0, MMU_FTR_SLB, 0,		0, 2, 0},
	{CPU_FTR_CTRL, 0, 0,		0, 3, 0},
	{CPU_FTR_NOEXECUTE, 0, 0,	0, 6, 0},
	{CPU_FTR_NODSISRALIGN, 0, 0,	1, 1, 1},
	{0, MMU_FTR_CI_LARGE_PAGE, 0,	1, 2, 0},
162
	{CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0},
163 164
};

165 166 167 168
static void __init scan_features(unsigned long node, unsigned char *ftrs,
				 unsigned long tablelen,
				 struct ibm_pa_feature *fp,
				 unsigned long ft_size)
169
{
170
	unsigned long i, len, bit;
171 172 173 174 175

	/* find descriptor with type == 0 */
	for (;;) {
		if (tablelen < 3)
			return;
176
		len = 2 + ftrs[0];
177 178
		if (tablelen < len)
			return;		/* descriptor 0 not found */
179
		if (ftrs[1] == 0)
180 181
			break;
		tablelen -= len;
182
		ftrs += len;
183 184 185
	}

	/* loop over bits we know about */
186 187
	for (i = 0; i < ft_size; ++i, ++fp) {
		if (fp->pabyte >= ftrs[0])
188
			continue;
189
		bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1;
190 191 192
		if (bit ^ fp->invert) {
			cur_cpu_spec->cpu_features |= fp->cpu_features;
			cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs;
193
			cur_cpu_spec->mmu_features |= fp->mmu_features;
194 195 196
		} else {
			cur_cpu_spec->cpu_features &= ~fp->cpu_features;
			cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs;
197
			cur_cpu_spec->mmu_features &= ~fp->mmu_features;
198 199 200 201
		}
	}
}

202 203 204 205 206 207 208 209 210 211 212 213 214
static void __init check_cpu_pa_features(unsigned long node)
{
	unsigned char *pa_ftrs;
	unsigned long tablelen;

	pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen);
	if (pa_ftrs == NULL)
		return;

	scan_features(node, pa_ftrs, tablelen,
		      ibm_pa_features, ARRAY_SIZE(ibm_pa_features));
}

215
#ifdef CONFIG_PPC_STD_MMU_64
216 217 218 219
static void __init check_cpu_slb_size(unsigned long node)
{
	u32 *slb_size_ptr;

220 221 222 223 224
	slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL);
	if (slb_size_ptr != NULL) {
		mmu_slb_size = *slb_size_ptr;
		return;
	}
225 226 227 228 229 230 231 232 233
	slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL);
	if (slb_size_ptr != NULL) {
		mmu_slb_size = *slb_size_ptr;
	}
}
#else
#define check_cpu_slb_size(node) do { } while(0)
#endif

234 235 236 237 238 239 240 241 242 243
static struct feature_property {
	const char *name;
	u32 min_value;
	unsigned long cpu_feature;
	unsigned long cpu_user_ftr;
} feature_properties[] __initdata = {
#ifdef CONFIG_ALTIVEC
	{"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
	{"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
#endif /* CONFIG_ALTIVEC */
M
Michael Neuling 已提交
244 245 246 247
#ifdef CONFIG_VSX
	/* Yes, this _really_ is ibm,vmx == 2 to enable VSX */
	{"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX},
#endif /* CONFIG_VSX */
248 249 250 251 252 253 254
#ifdef CONFIG_PPC64
	{"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP},
	{"ibm,purr", 1, CPU_FTR_PURR, 0},
	{"ibm,spurr", 1, CPU_FTR_SPURR, 0},
#endif /* CONFIG_PPC64 */
};

255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
#if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU)
static inline void identical_pvr_fixup(unsigned long node)
{
	unsigned int pvr;
	char *model = of_get_flat_dt_prop(node, "model", NULL);

	/*
	 * Since 440GR(x)/440EP(x) processors have the same pvr,
	 * we check the node path and set bit 28 in the cur_cpu_spec
	 * pvr for EP(x) processor version. This bit is always 0 in
	 * the "real" pvr. Then we call identify_cpu again with
	 * the new logical pvr to enable FPU support.
	 */
	if (model && strstr(model, "440EP")) {
		pvr = cur_cpu_spec->pvr_value | 0x8;
		identify_cpu(0, pvr);
		DBG("Using logical pvr %x for %s\n", pvr, model);
	}
}
#else
#define identical_pvr_fixup(node) do { } while(0)
#endif

278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
static void __init check_cpu_feature_properties(unsigned long node)
{
	unsigned long i;
	struct feature_property *fp = feature_properties;
	const u32 *prop;

	for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) {
		prop = of_get_flat_dt_prop(node, fp->name, NULL);
		if (prop && *prop >= fp->min_value) {
			cur_cpu_spec->cpu_features |= fp->cpu_feature;
			cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr;
		}
	}
}

293
static int __init early_init_dt_scan_cpus(unsigned long node,
294 295
					  const char *uname, int depth,
					  void *data)
296
{
297
	char *type = of_get_flat_dt_prop(node, "device_type", NULL);
298 299
	const u32 *prop;
	const u32 *intserv;
300 301
	int i, nthreads;
	unsigned long len;
302
	int found = -1;
303
	int found_thread = 0;
304 305 306 307 308

	/* We are scanning "cpu" nodes only */
	if (type == NULL || strcmp(type, "cpu") != 0)
		return 0;

309 310 311 312
	/* Get physical cpuid */
	intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len);
	if (intserv) {
		nthreads = len / sizeof(int);
313
	} else {
314 315 316 317 318 319 320 321 322 323 324 325 326
		intserv = of_get_flat_dt_prop(node, "reg", NULL);
		nthreads = 1;
	}

	/*
	 * Now see if any of these threads match our boot cpu.
	 * NOTE: This must match the parsing done in smp_setup_cpu_maps.
	 */
	for (i = 0; i < nthreads; i++) {
		/*
		 * version 2 of the kexec param format adds the phys cpuid of
		 * booted proc.
		 */
327 328
		if (initial_boot_params->version >= 2) {
			if (intserv[i] == initial_boot_params->boot_cpuid_phys) {
329
				found = boot_cpu_count;
330 331
				found_thread = i;
			}
332 333 334 335 336 337 338
		} else {
			/*
			 * Check if it's the boot-cpu, set it's hw index now,
			 * unfortunately this format did not support booting
			 * off secondary threads.
			 */
			if (of_get_flat_dt_prop(node,
339 340
					"linux,boot-cpu", NULL) != NULL)
				found = boot_cpu_count;
341
		}
342 343
#ifdef CONFIG_SMP
		/* logical cpu id is always 0 on UP kernels */
344
		boot_cpu_count++;
345 346 347
#endif
	}

348 349
	if (found >= 0) {
		DBG("boot cpu: logical %d physical %d\n", found,
350
			intserv[found_thread]);
351
		boot_cpuid = found;
352
		set_hard_smp_processor_id(found, intserv[found_thread]);
353

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
		/*
		 * PAPR defines "logical" PVR values for cpus that
		 * meet various levels of the architecture:
		 * 0x0f000001	Architecture version 2.04
		 * 0x0f000002	Architecture version 2.05
		 * If the cpu-version property in the cpu node contains
		 * such a value, we call identify_cpu again with the
		 * logical PVR value in order to use the cpu feature
		 * bits appropriate for the architecture level.
		 *
		 * A POWER6 partition in "POWER6 architected" mode
		 * uses the 0x0f000002 PVR value; in POWER5+ mode
		 * it uses 0x0f000001.
		 */
		prop = of_get_flat_dt_prop(node, "cpu-version", NULL);
		if (prop && (*prop & 0xff000000) == 0x0f000000)
			identify_cpu(0, *prop);
371 372

		identical_pvr_fixup(node);
373 374
	}

375
	check_cpu_feature_properties(node);
376
	check_cpu_pa_features(node);
377
	check_cpu_slb_size(node);
378

379
#ifdef CONFIG_PPC_PSERIES
380
	if (nthreads > 1)
381
		cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
382 383
	else
		cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
384 385 386 387 388
#endif

	return 0;
}

389 390
int __init early_init_dt_scan_chosen_ppc(unsigned long node, const char *uname,
					 int depth, void *data)
391 392 393
{
	unsigned long *lprop;

394 395 396 397
	/* Use common scan routine to determine if this is the chosen node */
	if (early_init_dt_scan_chosen(node, uname, depth, data) == 0)
		return 0;

398 399
#ifdef CONFIG_PPC64
	/* check if iommu is forced on or off */
400
	if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
401
		iommu_is_off = 1;
402
	if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
403 404 405
		iommu_force_on = 1;
#endif

406
	/* mem=x on the command line is the preferred mechanism */
407 408 409
	lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
	if (lprop)
		memory_limit = *lprop;
410 411

#ifdef CONFIG_PPC64
412 413 414 415 416 417
	lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
	if (lprop)
		tce_alloc_start = *lprop;
	lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
	if (lprop)
		tce_alloc_end = *lprop;
418 419
#endif

420
#ifdef CONFIG_KEXEC
421
	lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
422 423
	if (lprop)
		crashk_res.start = *lprop;
424

425
	lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
426 427
	if (lprop)
		crashk_res.end = crashk_res.start + *lprop - 1;
428
#endif
429 430 431

	/* break now */
	return 1;
432 433
}

434 435 436 437 438 439 440 441 442
#ifdef CONFIG_PPC_PSERIES
/*
 * Interpret the ibm,dynamic-memory property in the
 * /ibm,dynamic-reconfiguration-memory node.
 * This contains a list of memory blocks along with NUMA affinity
 * information.
 */
static int __init early_init_dt_scan_drconf_memory(unsigned long node)
{
443
	__be32 *dm, *ls, *usm;
444
	unsigned long l, n, flags;
Y
Yinghai Lu 已提交
445
	u64 base, size, memblock_size;
446
	unsigned int is_kexec_kdump = 0, rngs;
447

448
	ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
449
	if (ls == NULL || l < dt_root_size_cells * sizeof(__be32))
450
		return 0;
Y
Yinghai Lu 已提交
451
	memblock_size = dt_mem_next_cell(dt_root_size_cells, &ls);
452

453
	dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
454
	if (dm == NULL || l < sizeof(__be32))
455 456 457
		return 0;

	n = *dm++;	/* number of entries */
458
	if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(__be32))
459 460
		return 0;

461
	/* check if this is a kexec/kdump kernel. */
462
	usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory",
463 464 465 466
						 &l);
	if (usm != NULL)
		is_kexec_kdump = 1;

467 468 469 470 471 472 473 474 475
	for (; n != 0; --n) {
		base = dt_mem_next_cell(dt_root_addr_cells, &dm);
		flags = dm[3];
		/* skip DRC index, pad, assoc. list index, flags */
		dm += 4;
		/* skip this block if the reserved bit is set in flags (0x80)
		   or if the block is not assigned to this partition (0x8) */
		if ((flags & 0x80) || !(flags & 0x8))
			continue;
Y
Yinghai Lu 已提交
476
		size = memblock_size;
477 478 479
		rngs = 1;
		if (is_kexec_kdump) {
			/*
Y
Yinghai Lu 已提交
480
			 * For each memblock in ibm,dynamic-memory, a corresponding
481 482 483 484 485 486 487
			 * entry in linux,drconf-usable-memory property contains
			 * a counter 'p' followed by 'p' (base, size) duple.
			 * Now read the counter from
			 * linux,drconf-usable-memory property
			 */
			rngs = dt_mem_next_cell(dt_root_size_cells, &usm);
			if (!rngs) /* there are no (base, size) duple */
488 489
				continue;
		}
490 491 492 493 494 495 496 497 498 499 500 501 502
		do {
			if (is_kexec_kdump) {
				base = dt_mem_next_cell(dt_root_addr_cells,
							 &usm);
				size = dt_mem_next_cell(dt_root_size_cells,
							 &usm);
			}
			if (iommu_is_off) {
				if (base >= 0x80000000ul)
					continue;
				if ((base + size) > 0x80000000ul)
					size = 0x80000000ul - base;
			}
Y
Yinghai Lu 已提交
503
			memblock_add(base, size);
504
		} while (--rngs);
505
	}
Y
Yinghai Lu 已提交
506
	memblock_dump_all();
507 508 509 510 511
	return 0;
}
#else
#define early_init_dt_scan_drconf_memory(node)	0
#endif /* CONFIG_PPC_PSERIES */
512

513 514 515
static int __init early_init_dt_scan_memory_ppc(unsigned long node,
						const char *uname,
						int depth, void *data)
516
{
517 518 519
	if (depth == 1 &&
	    strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0)
		return early_init_dt_scan_drconf_memory(node);
520 521 522
	
	return early_init_dt_scan_memory(node, uname, depth, data);
}
523

524 525
void __init early_init_dt_add_memory_arch(u64 base, u64 size)
{
526
#ifdef CONFIG_PPC64
527 528 529 530 531 532
	if (iommu_is_off) {
		if (base >= 0x80000000ul)
			return;
		if ((base + size) > 0x80000000ul)
			size = 0x80000000ul - base;
	}
533
#endif
534 535 536 537 538 539 540 541
	/* Keep track of the beginning of memory -and- the size of
	 * the very first block in the device-tree as it represents
	 * the RMA on ppc64 server
	 */
	if (base < memstart_addr) {
		memstart_addr = base;
		first_memblock_size = size;
	}
542 543 544

	/* Add the chunk to the MEMBLOCK list */
	memblock_add(base, size);
545 546
}

547
void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
J
Jeremy Kerr 已提交
548
{
549
	return __va(memblock_alloc(size, align));
J
Jeremy Kerr 已提交
550 551
}

552 553 554 555 556 557 558 559 560 561
#ifdef CONFIG_BLK_DEV_INITRD
void __init early_init_dt_setup_initrd_arch(unsigned long start,
		unsigned long end)
{
	initrd_start = (unsigned long)__va(start);
	initrd_end = (unsigned long)__va(end);
	initrd_below_start_ok = 1;
}
#endif

562 563
static void __init early_reserve_mem(void)
{
564 565
	u64 base, size;
	u64 *reserve_map;
566 567
	unsigned long self_base;
	unsigned long self_size;
568

569
	reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
570
					initial_boot_params->off_mem_rsvmap);
571 572

	/* before we do anything, lets reserve the dt blob */
573 574
	self_base = __pa((unsigned long)initial_boot_params);
	self_size = initial_boot_params->totalsize;
Y
Yinghai Lu 已提交
575
	memblock_reserve(self_base, self_size);
576

577 578 579
#ifdef CONFIG_BLK_DEV_INITRD
	/* then reserve the initrd, if any */
	if (initrd_start && (initrd_end > initrd_start))
580 581 582
		memblock_reserve(_ALIGN_DOWN(__pa(initrd_start), PAGE_SIZE),
			_ALIGN_UP(initrd_end, PAGE_SIZE) -
			_ALIGN_DOWN(initrd_start, PAGE_SIZE));
583 584
#endif /* CONFIG_BLK_DEV_INITRD */

585 586 587 588 589 590 591 592 593 594 595 596 597 598
#ifdef CONFIG_PPC32
	/* 
	 * Handle the case where we might be booting from an old kexec
	 * image that setup the mem_rsvmap as pairs of 32-bit values
	 */
	if (*reserve_map > 0xffffffffull) {
		u32 base_32, size_32;
		u32 *reserve_map_32 = (u32 *)reserve_map;

		while (1) {
			base_32 = *(reserve_map_32++);
			size_32 = *(reserve_map_32++);
			if (size_32 == 0)
				break;
599 600 601
			/* skip if the reservation is for the blob */
			if (base_32 == self_base && size_32 == self_size)
				continue;
602
			DBG("reserving: %x -> %x\n", base_32, size_32);
Y
Yinghai Lu 已提交
603
			memblock_reserve(base_32, size_32);
604 605 606 607
		}
		return;
	}
#endif
608 609 610 611 612
	while (1) {
		base = *(reserve_map++);
		size = *(reserve_map++);
		if (size == 0)
			break;
613
		DBG("reserving: %llx -> %llx\n", base, size);
Y
Yinghai Lu 已提交
614
		memblock_reserve(base, size);
615 616 617
	}
}

618
#ifdef CONFIG_PHYP_DUMP
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
/**
 * phyp_dump_calculate_reserve_size() - reserve variable boot area 5% or arg
 *
 * Function to find the largest size we need to reserve
 * during early boot process.
 *
 * It either looks for boot param and returns that OR
 * returns larger of 256 or 5% rounded down to multiples of 256MB.
 *
 */
static inline unsigned long phyp_dump_calculate_reserve_size(void)
{
	unsigned long tmp;

	if (phyp_dump_info->reserve_bootvar)
		return phyp_dump_info->reserve_bootvar;

	/* divide by 20 to get 5% of value */
Y
Yinghai Lu 已提交
637
	tmp = memblock_end_of_DRAM();
638 639 640 641 642 643 644 645
	do_div(tmp, 20);

	/* round it down in multiples of 256 */
	tmp = tmp & ~0x0FFFFFFFUL;

	return (tmp > PHYP_DUMP_RMR_END ? tmp : PHYP_DUMP_RMR_END);
}

646 647 648 649 650 651 652 653 654 655 656 657 658
/**
 * phyp_dump_reserve_mem() - reserve all not-yet-dumped mmemory
 *
 * This routine may reserve memory regions in the kernel only
 * if the system is supported and a dump was taken in last
 * boot instance or if the hardware is supported and the
 * scratch area needs to be setup. In other instances it returns
 * without reserving anything. The memory in case of dump being
 * active is freed when the dump is collected (by userland tools).
 */
static void __init phyp_dump_reserve_mem(void)
{
	unsigned long base, size;
659 660
	unsigned long variable_reserve_size;

661 662 663 664 665
	if (!phyp_dump_info->phyp_dump_configured) {
		printk(KERN_ERR "Phyp-dump not supported on this hardware\n");
		return;
	}

666 667 668 669 670
	if (!phyp_dump_info->phyp_dump_at_boot) {
		printk(KERN_INFO "Phyp-dump disabled at boot time\n");
		return;
	}

671 672
	variable_reserve_size = phyp_dump_calculate_reserve_size();

673 674
	if (phyp_dump_info->phyp_dump_is_active) {
		/* Reserve *everything* above RMR.Area freed by userland tools*/
675
		base = variable_reserve_size;
Y
Yinghai Lu 已提交
676
		size = memblock_end_of_DRAM() - base;
677 678 679

		/* XXX crashed_ram_end is wrong, since it may be beyond
		 * the memory_limit, it will need to be adjusted. */
Y
Yinghai Lu 已提交
680
		memblock_reserve(base, size);
681 682 683 684 685 686

		phyp_dump_info->init_reserve_start = base;
		phyp_dump_info->init_reserve_size = size;
	} else {
		size = phyp_dump_info->cpu_state_size +
			phyp_dump_info->hpte_region_size +
687
			variable_reserve_size;
Y
Yinghai Lu 已提交
688 689
		base = memblock_end_of_DRAM() - size;
		memblock_reserve(base, size);
690 691 692 693 694 695 696 697
		phyp_dump_info->init_reserve_start = base;
		phyp_dump_info->init_reserve_size = size;
	}
}
#else
static inline void __init phyp_dump_reserve_mem(void) {}
#endif /* CONFIG_PHYP_DUMP  && CONFIG_PPC_RTAS */

698 699
void __init early_init_devtree(void *params)
{
700
	phys_addr_t limit;
701

702
	DBG(" -> early_init_devtree(%p)\n", params);
703 704 705 706

	/* Setup flat device-tree pointer */
	initial_boot_params = params;

707 708 709 710 711
#ifdef CONFIG_PPC_RTAS
	/* Some machines might need RTAS info for debugging, grab it now. */
	of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
#endif

712 713 714 715 716
#ifdef CONFIG_PPC_POWERNV
	/* Some machines might need OPAL info for debugging, grab it now. */
	of_scan_flat_dt(early_init_dt_scan_opal, NULL);
#endif

717
#ifdef CONFIG_PHYP_DUMP
L
Lucas De Marchi 已提交
718
	/* scan tree to see if dump occurred during last boot */
719 720 721
	of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL);
#endif

722 723 724 725 726 727 728
	/* Pre-initialize the cmd_line with the content of boot_commmand_line,
	 * which will be empty except when the content of the variable has
	 * been overriden by a bootloading mechanism. This happens typically
	 * with HAL takeover
	 */
	strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);

729 730 731 732
	/* Retrieve various informations from the /chosen node of the
	 * device-tree, including the platform type, initrd location and
	 * size, TCE reserve, and more ...
	 */
733
	of_scan_flat_dt(early_init_dt_scan_chosen_ppc, cmd_line);
734

Y
Yinghai Lu 已提交
735
	/* Scan memory nodes and rebuild MEMBLOCKs */
736
	of_scan_flat_dt(early_init_dt_scan_root, NULL);
737
	of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL);
738 739

	/* Save command line for /proc/cmdline and then parse parameters */
740
	strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
741 742
	parse_early_param();

743 744 745 746
	/* make sure we've parsed cmdline for mem= before this */
	if (memory_limit)
		first_memblock_size = min(first_memblock_size, memory_limit);
	setup_initial_memory_limit(memstart_addr, first_memblock_size);
Y
Yinghai Lu 已提交
747 748
	/* Reserve MEMBLOCK regions used by kernel, initrd, dt, etc... */
	memblock_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
749 750
	/* If relocatable, reserve first 32k for interrupt vectors etc. */
	if (PHYSICAL_START > MEMORY_START)
Y
Yinghai Lu 已提交
751
		memblock_reserve(MEMORY_START, 0x8000);
752
	reserve_kdump_trampoline();
753
	reserve_crashkernel();
754
	early_reserve_mem();
755
	phyp_dump_reserve_mem();
756

T
Tejun Heo 已提交
757 758 759 760 761 762
	/*
	 * Ensure that total memory size is page-aligned, because otherwise
	 * mark_bootmem() gets upset.
	 */
	memblock_analyze();
	limit = ALIGN(memory_limit ?: memblock_phys_mem_size(), PAGE_SIZE);
Y
Yinghai Lu 已提交
763
	memblock_enforce_memory_limit(limit);
764

Y
Yinghai Lu 已提交
765 766
	memblock_analyze();
	memblock_dump_all();
767

Y
Yinghai Lu 已提交
768
	DBG("Phys. mem: %llx\n", memblock_phys_mem_size());
769 770 771 772 773

	/* We may need to relocate the flat tree, do it now.
	 * FIXME .. and the initrd too? */
	move_device_tree();

774 775
	allocate_pacas();

776 777
	DBG("Scanning CPUs ...\n");

L
Lucas De Marchi 已提交
778
	/* Retrieve CPU related informations from the flat tree
779
	 * (altivec support, boot CPU ID, ...)
780
	 */
781
	of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
782

783 784 785 786 787 788 789
#if defined(CONFIG_SMP) && defined(CONFIG_PPC64)
	/* We'll later wait for secondaries to check in; there are
	 * NCPUS-1 non-boot CPUs  :-)
	 */
	spinning_secondaries = boot_cpu_count - 1;
#endif

790 791 792 793 794 795 796 797 798 799 800 801 802 803
	DBG(" <- early_init_devtree()\n");
}

/*******
 *
 * New implementation of the OF "find" APIs, return a refcounted
 * object, call of_node_put() when done.  The device tree and list
 * are protected by a rw_lock.
 *
 * Note that property management will need some locking as well,
 * this isn't dealt with yet.
 *
 *******/

804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
/**
 *	of_find_next_cache_node - Find a node's subsidiary cache
 *	@np:	node of type "cpu" or "cache"
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.  Caller should hold a reference
 *	to np.
 */
struct device_node *of_find_next_cache_node(struct device_node *np)
{
	struct device_node *child;
	const phandle *handle;

	handle = of_get_property(np, "l2-cache", NULL);
	if (!handle)
		handle = of_get_property(np, "next-level-cache", NULL);

	if (handle)
		return of_find_node_by_phandle(*handle);

	/* OF on pmac has nodes instead of properties named "l2-cache"
	 * beneath CPU nodes.
	 */
	if (!strcmp(np->type, "cpu"))
		for_each_child_of_node(np, child)
			if (!strcmp(child->type, "cache"))
				return child;

	return NULL;
}

835 836 837
#ifdef CONFIG_PPC_PSERIES
/*
 * Fix up the uninitialized fields in a new device node:
838
 * name, type and pci-specific fields
839 840
 */

841
static int of_finish_dynamic_node(struct device_node *node)
842 843 844
{
	struct device_node *parent = of_get_parent(node);
	int err = 0;
845
	const phandle *ibm_phandle;
846

847 848
	node->name = of_get_property(node, "name", NULL);
	node->type = of_get_property(node, "device_type", NULL);
849

850 851 852 853 854
	if (!node->name)
		node->name = "<NULL>";
	if (!node->type)
		node->type = "<NULL>";

855 856 857 858 859 860 861 862
	if (!parent) {
		err = -ENODEV;
		goto out;
	}

	/* We don't support that function on PowerMac, at least
	 * not yet
	 */
863
	if (machine_is(powermac))
864 865
		return -ENODEV;

866
	/* fix up new node's phandle field */
867
	if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
868
		node->phandle = *ibm_phandle;
869 870 871 872 873 874 875 876 877 878 879 880 881

out:
	of_node_put(parent);
	return err;
}

static int prom_reconfig_notifier(struct notifier_block *nb,
				  unsigned long action, void *node)
{
	int err;

	switch (action) {
	case PSERIES_RECONFIG_ADD:
882
		err = of_finish_dynamic_node(node);
883
		if (err < 0)
884 885 886
			printk(KERN_ERR "finish_node returned %d\n", err);
		break;
	default:
887
		err = 0;
888 889
		break;
	}
890
	return notifier_from_errno(err);
891 892 893 894 895 896 897 898 899 900 901 902 903 904
}

static struct notifier_block prom_reconfig_nb = {
	.notifier_call = prom_reconfig_notifier,
	.priority = 10, /* This one needs to run first */
};

static int __init prom_reconfig_setup(void)
{
	return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
}
__initcall(prom_reconfig_setup);
#endif

905 906 907 908 909 910 911 912 913 914 915 916
/* Find the device node for a given logical cpu number, also returns the cpu
 * local thread number (index in ibm,interrupt-server#s) if relevant and
 * asked for (non NULL)
 */
struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
{
	int hardid;
	struct device_node *np;

	hardid = get_hard_smp_processor_id(cpu);

	for_each_node_by_type(np, "cpu") {
917
		const u32 *intserv;
918 919 920 921 922
		unsigned int plen, t;

		/* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
		 * fallback to "reg" property and assume no threads
		 */
923
		intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
924
				&plen);
925
		if (intserv == NULL) {
926
			const u32 *reg = of_get_property(np, "reg", NULL);
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
			if (reg == NULL)
				continue;
			if (*reg == hardid) {
				if (thread)
					*thread = 0;
				return np;
			}
		} else {
			plen /= sizeof(u32);
			for (t = 0; t < plen; t++) {
				if (hardid == intserv[t]) {
					if (thread)
						*thread = t;
					return np;
				}
			}
		}
	}
	return NULL;
}
947
EXPORT_SYMBOL(of_get_cpu_node);
948

949
#if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
950 951 952 953 954 955 956 957 958 959
static struct debugfs_blob_wrapper flat_dt_blob;

static int __init export_flat_device_tree(void)
{
	struct dentry *d;

	flat_dt_blob.data = initial_boot_params;
	flat_dt_blob.size = initial_boot_params->totalsize;

	d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
960
				powerpc_debugfs_root, &flat_dt_blob);
961 962 963 964 965 966 967
	if (!d)
		return 1;

	return 0;
}
__initcall(export_flat_device_tree);
#endif