1/*
2 * Procedures for creating, accessing and interpreting the device tree.
3 *
4 * Paul Mackerras	August 1996.
5 * Copyright (C) 1996-2005 Paul Mackerras.
6 *
7 *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8 *    {engebret|bergner}@us.ibm.com
9 *
10 *  Adapted for sparc64 by David S. Miller davem@davemloft.net
11 *
12 *      This program is free software; you can redistribute it and/or
13 *      modify it under the terms of the GNU General Public License
14 *      as published by the Free Software Foundation; either version
15 *      2 of the License, or (at your option) any later version.
16 */
17
18#include <linux/memblock.h>
19#include <linux/kernel.h>
20#include <linux/string.h>
21#include <linux/types.h>
22#include <linux/cpu.h>
23#include <linux/mm.h>
24#include <linux/of.h>
25
26#include <asm/prom.h>
27#include <asm/oplib.h>
28#include <asm/irq.h>
29#include <asm/asi.h>
30#include <asm/upa.h>
31#include <asm/smp.h>
32
33#include "prom.h"
34
35void * __init prom_early_alloc(unsigned long size)
36{
37	unsigned long paddr = memblock_alloc(size, SMP_CACHE_BYTES);
38	void *ret;
39
40	if (!paddr) {
41		prom_printf("prom_early_alloc(%lu) failed\n", size);
42		prom_halt();
43	}
44
45	ret = __va(paddr);
46	memset(ret, 0, size);
47	prom_early_allocated += size;
48
49	return ret;
50}
51
52/* The following routines deal with the black magic of fully naming a
53 * node.
54 *
55 * Certain well known named nodes are just the simple name string.
56 *
57 * Actual devices have an address specifier appended to the base name
58 * string, like this "foo@addr".  The "addr" can be in any number of
59 * formats, and the platform plus the type of the node determine the
60 * format and how it is constructed.
61 *
62 * For children of the ROOT node, the naming convention is fixed and
63 * determined by whether this is a sun4u or sun4v system.
64 *
65 * For children of other nodes, it is bus type specific.  So
66 * we walk up the tree until we discover a "device_type" property
67 * we recognize and we go from there.
68 *
69 * As an example, the boot device on my workstation has a full path:
70 *
71 *	/pci@1e,600000/ide@d/disk@0,0:c
72 */
73static void __init sun4v_path_component(struct device_node *dp, char *tmp_buf)
74{
75	struct linux_prom64_registers *regs;
76	struct property *rprop;
77	u32 high_bits, low_bits, type;
78
79	rprop = of_find_property(dp, "reg", NULL);
80	if (!rprop)
81		return;
82
83	regs = rprop->value;
84	if (!of_node_is_root(dp->parent)) {
85		sprintf(tmp_buf, "%s@%x,%x",
86			dp->name,
87			(unsigned int) (regs->phys_addr >> 32UL),
88			(unsigned int) (regs->phys_addr & 0xffffffffUL));
89		return;
90	}
91
92	type = regs->phys_addr >> 60UL;
93	high_bits = (regs->phys_addr >> 32UL) & 0x0fffffffUL;
94	low_bits = (regs->phys_addr & 0xffffffffUL);
95
96	if (type == 0 || type == 8) {
97		const char *prefix = (type == 0) ? "m" : "i";
98
99		if (low_bits)
100			sprintf(tmp_buf, "%s@%s%x,%x",
101				dp->name, prefix,
102				high_bits, low_bits);
103		else
104			sprintf(tmp_buf, "%s@%s%x",
105				dp->name,
106				prefix,
107				high_bits);
108	} else if (type == 12) {
109		sprintf(tmp_buf, "%s@%x",
110			dp->name, high_bits);
111	}
112}
113
114static void __init sun4u_path_component(struct device_node *dp, char *tmp_buf)
115{
116	struct linux_prom64_registers *regs;
117	struct property *prop;
118
119	prop = of_find_property(dp, "reg", NULL);
120	if (!prop)
121		return;
122
123	regs = prop->value;
124	if (!of_node_is_root(dp->parent)) {
125		sprintf(tmp_buf, "%s@%x,%x",
126			dp->name,
127			(unsigned int) (regs->phys_addr >> 32UL),
128			(unsigned int) (regs->phys_addr & 0xffffffffUL));
129		return;
130	}
131
132	prop = of_find_property(dp, "upa-portid", NULL);
133	if (!prop)
134		prop = of_find_property(dp, "portid", NULL);
135	if (prop) {
136		unsigned long mask = 0xffffffffUL;
137
138		if (tlb_type >= cheetah)
139			mask = 0x7fffff;
140
141		sprintf(tmp_buf, "%s@%x,%x",
142			dp->name,
143			*(u32 *)prop->value,
144			(unsigned int) (regs->phys_addr & mask));
145	}
146}
147
148/* "name@slot,offset"  */
149static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
150{
151	struct linux_prom_registers *regs;
152	struct property *prop;
153
154	prop = of_find_property(dp, "reg", NULL);
155	if (!prop)
156		return;
157
158	regs = prop->value;
159	sprintf(tmp_buf, "%s@%x,%x",
160		dp->name,
161		regs->which_io,
162		regs->phys_addr);
163}
164
165/* "name@devnum[,func]" */
166static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
167{
168	struct linux_prom_pci_registers *regs;
169	struct property *prop;
170	unsigned int devfn;
171
172	prop = of_find_property(dp, "reg", NULL);
173	if (!prop)
174		return;
175
176	regs = prop->value;
177	devfn = (regs->phys_hi >> 8) & 0xff;
178	if (devfn & 0x07) {
179		sprintf(tmp_buf, "%s@%x,%x",
180			dp->name,
181			devfn >> 3,
182			devfn & 0x07);
183	} else {
184		sprintf(tmp_buf, "%s@%x",
185			dp->name,
186			devfn >> 3);
187	}
188}
189
190/* "name@UPA_PORTID,offset" */
191static void __init upa_path_component(struct device_node *dp, char *tmp_buf)
192{
193	struct linux_prom64_registers *regs;
194	struct property *prop;
195
196	prop = of_find_property(dp, "reg", NULL);
197	if (!prop)
198		return;
199
200	regs = prop->value;
201
202	prop = of_find_property(dp, "upa-portid", NULL);
203	if (!prop)
204		return;
205
206	sprintf(tmp_buf, "%s@%x,%x",
207		dp->name,
208		*(u32 *) prop->value,
209		(unsigned int) (regs->phys_addr & 0xffffffffUL));
210}
211
212/* "name@reg" */
213static void __init vdev_path_component(struct device_node *dp, char *tmp_buf)
214{
215	struct property *prop;
216	u32 *regs;
217
218	prop = of_find_property(dp, "reg", NULL);
219	if (!prop)
220		return;
221
222	regs = prop->value;
223
224	sprintf(tmp_buf, "%s@%x", dp->name, *regs);
225}
226
227/* "name@addrhi,addrlo" */
228static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
229{
230	struct linux_prom64_registers *regs;
231	struct property *prop;
232
233	prop = of_find_property(dp, "reg", NULL);
234	if (!prop)
235		return;
236
237	regs = prop->value;
238
239	sprintf(tmp_buf, "%s@%x,%x",
240		dp->name,
241		(unsigned int) (regs->phys_addr >> 32UL),
242		(unsigned int) (regs->phys_addr & 0xffffffffUL));
243}
244
245/* "name@bus,addr" */
246static void __init i2c_path_component(struct device_node *dp, char *tmp_buf)
247{
248	struct property *prop;
249	u32 *regs;
250
251	prop = of_find_property(dp, "reg", NULL);
252	if (!prop)
253		return;
254
255	regs = prop->value;
256
257	/* This actually isn't right... should look at the #address-cells
258	 * property of the i2c bus node etc. etc.
259	 */
260	sprintf(tmp_buf, "%s@%x,%x",
261		dp->name, regs[0], regs[1]);
262}
263
264/* "name@reg0[,reg1]" */
265static void __init usb_path_component(struct device_node *dp, char *tmp_buf)
266{
267	struct property *prop;
268	u32 *regs;
269
270	prop = of_find_property(dp, "reg", NULL);
271	if (!prop)
272		return;
273
274	regs = prop->value;
275
276	if (prop->length == sizeof(u32) || regs[1] == 1) {
277		sprintf(tmp_buf, "%s@%x",
278			dp->name, regs[0]);
279	} else {
280		sprintf(tmp_buf, "%s@%x,%x",
281			dp->name, regs[0], regs[1]);
282	}
283}
284
285/* "name@reg0reg1[,reg2reg3]" */
286static void __init ieee1394_path_component(struct device_node *dp, char *tmp_buf)
287{
288	struct property *prop;
289	u32 *regs;
290
291	prop = of_find_property(dp, "reg", NULL);
292	if (!prop)
293		return;
294
295	regs = prop->value;
296
297	if (regs[2] || regs[3]) {
298		sprintf(tmp_buf, "%s@%08x%08x,%04x%08x",
299			dp->name, regs[0], regs[1], regs[2], regs[3]);
300	} else {
301		sprintf(tmp_buf, "%s@%08x%08x",
302			dp->name, regs[0], regs[1]);
303	}
304}
305
306static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
307{
308	struct device_node *parent = dp->parent;
309
310	if (parent != NULL) {
311		if (!strcmp(parent->type, "pci") ||
312		    !strcmp(parent->type, "pciex")) {
313			pci_path_component(dp, tmp_buf);
314			return;
315		}
316		if (!strcmp(parent->type, "sbus")) {
317			sbus_path_component(dp, tmp_buf);
318			return;
319		}
320		if (!strcmp(parent->type, "upa")) {
321			upa_path_component(dp, tmp_buf);
322			return;
323		}
324		if (!strcmp(parent->type, "ebus")) {
325			ebus_path_component(dp, tmp_buf);
326			return;
327		}
328		if (!strcmp(parent->name, "usb") ||
329		    !strcmp(parent->name, "hub")) {
330			usb_path_component(dp, tmp_buf);
331			return;
332		}
333		if (!strcmp(parent->type, "i2c")) {
334			i2c_path_component(dp, tmp_buf);
335			return;
336		}
337		if (!strcmp(parent->type, "firewire")) {
338			ieee1394_path_component(dp, tmp_buf);
339			return;
340		}
341		if (!strcmp(parent->type, "virtual-devices")) {
342			vdev_path_component(dp, tmp_buf);
343			return;
344		}
345		/* "isa" is handled with platform naming */
346	}
347
348	/* Use platform naming convention.  */
349	if (tlb_type == hypervisor) {
350		sun4v_path_component(dp, tmp_buf);
351		return;
352	} else {
353		sun4u_path_component(dp, tmp_buf);
354	}
355}
356
357char * __init build_path_component(struct device_node *dp)
358{
359	char tmp_buf[64], *n;
360
361	tmp_buf[0] = '\0';
362	__build_path_component(dp, tmp_buf);
363	if (tmp_buf[0] == '\0')
364		strcpy(tmp_buf, dp->name);
365
366	n = prom_early_alloc(strlen(tmp_buf) + 1);
367	strcpy(n, tmp_buf);
368
369	return n;
370}
371
372static const char *get_mid_prop(void)
373{
374	return (tlb_type == spitfire ? "upa-portid" : "portid");
375}
376
377bool arch_find_n_match_cpu_physical_id(struct device_node *cpun,
378				       int cpu, unsigned int *thread)
379{
380	const char *mid_prop = get_mid_prop();
381	int this_cpu_id;
382
383	/* On hypervisor based platforms we interrogate the 'reg'
384	 * property.  On everything else we look for a 'upa-portis',
385	 * 'portid', or 'cpuid' property.
386	 */
387
388	if (tlb_type == hypervisor) {
389		struct property *prop = of_find_property(cpun, "reg", NULL);
390		u32 *regs;
391
392		if (!prop) {
393			pr_warn("CPU node missing reg property\n");
394			return false;
395		}
396		regs = prop->value;
397		this_cpu_id = regs[0] & 0x0fffffff;
398	} else {
399		this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
400
401		if (this_cpu_id < 0) {
402			mid_prop = "cpuid";
403			this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
404		}
405		if (this_cpu_id < 0) {
406			pr_warn("CPU node missing cpu ID property\n");
407			return false;
408		}
409	}
410	if (this_cpu_id == cpu) {
411		if (thread) {
412			int proc_id = cpu_data(cpu).proc_id;
413
414			/* On sparc64, the cpu thread information is obtained
415			 * either from OBP or the machine description.  We've
416			 * actually probed this information already long before
417			 * this interface gets called so instead of interrogating
418			 * both the OF node and the MDESC again, just use what
419			 * we discovered already.
420			 */
421			if (proc_id < 0)
422				proc_id = 0;
423			*thread = proc_id;
424		}
425		return true;
426	}
427	return false;
428}
429
430static void *of_iterate_over_cpus(void *(*func)(struct device_node *, int, int), int arg)
431{
432	struct device_node *dp;
433	const char *mid_prop;
434
435	mid_prop = get_mid_prop();
436	for_each_node_by_type(dp, "cpu") {
437		int cpuid = of_getintprop_default(dp, mid_prop, -1);
438		const char *this_mid_prop = mid_prop;
439		void *ret;
440
441		if (cpuid < 0) {
442			this_mid_prop = "cpuid";
443			cpuid = of_getintprop_default(dp, this_mid_prop, -1);
444		}
445		if (cpuid < 0) {
446			prom_printf("OF: Serious problem, cpu lacks "
447				    "%s property", this_mid_prop);
448			prom_halt();
449		}
450#ifdef CONFIG_SMP
451		if (cpuid >= NR_CPUS) {
452			printk(KERN_WARNING "Ignoring CPU %d which is "
453			       ">= NR_CPUS (%d)\n",
454			       cpuid, NR_CPUS);
455			continue;
456		}
457#endif
458		ret = func(dp, cpuid, arg);
459		if (ret)
460			return ret;
461	}
462	return NULL;
463}
464
465static void *check_cpu_node(struct device_node *dp, int cpuid, int id)
466{
467	if (id == cpuid)
468		return dp;
469	return NULL;
470}
471
472struct device_node *of_find_node_by_cpuid(int cpuid)
473{
474	return of_iterate_over_cpus(check_cpu_node, cpuid);
475}
476
477static void *record_one_cpu(struct device_node *dp, int cpuid, int arg)
478{
479	ncpus_probed++;
480#ifdef CONFIG_SMP
481	set_cpu_present(cpuid, true);
482	set_cpu_possible(cpuid, true);
483#endif
484	return NULL;
485}
486
487void __init of_populate_present_mask(void)
488{
489	if (tlb_type == hypervisor)
490		return;
491
492	ncpus_probed = 0;
493	of_iterate_over_cpus(record_one_cpu, 0);
494}
495
496static void *fill_in_one_cpu(struct device_node *dp, int cpuid, int arg)
497{
498	struct device_node *portid_parent = NULL;
499	int portid = -1;
500
501	if (of_find_property(dp, "cpuid", NULL)) {
502		int limit = 2;
503
504		portid_parent = dp;
505		while (limit--) {
506			portid_parent = portid_parent->parent;
507			if (!portid_parent)
508				break;
509			portid = of_getintprop_default(portid_parent,
510						       "portid", -1);
511			if (portid >= 0)
512				break;
513		}
514	}
515
516#ifndef CONFIG_SMP
517	/* On uniprocessor we only want the values for the
518	 * real physical cpu the kernel booted onto, however
519	 * cpu_data() only has one entry at index 0.
520	 */
521	if (cpuid != real_hard_smp_processor_id())
522		return NULL;
523	cpuid = 0;
524#endif
525
526	cpu_data(cpuid).clock_tick =
527		of_getintprop_default(dp, "clock-frequency", 0);
528
529	if (portid_parent) {
530		cpu_data(cpuid).dcache_size =
531			of_getintprop_default(dp, "l1-dcache-size",
532					      16 * 1024);
533		cpu_data(cpuid).dcache_line_size =
534			of_getintprop_default(dp, "l1-dcache-line-size",
535					      32);
536		cpu_data(cpuid).icache_size =
537			of_getintprop_default(dp, "l1-icache-size",
538					      8 * 1024);
539		cpu_data(cpuid).icache_line_size =
540			of_getintprop_default(dp, "l1-icache-line-size",
541					      32);
542		cpu_data(cpuid).ecache_size =
543			of_getintprop_default(dp, "l2-cache-size", 0);
544		cpu_data(cpuid).ecache_line_size =
545			of_getintprop_default(dp, "l2-cache-line-size", 0);
546		if (!cpu_data(cpuid).ecache_size ||
547		    !cpu_data(cpuid).ecache_line_size) {
548			cpu_data(cpuid).ecache_size =
549				of_getintprop_default(portid_parent,
550						      "l2-cache-size",
551						      (4 * 1024 * 1024));
552			cpu_data(cpuid).ecache_line_size =
553				of_getintprop_default(portid_parent,
554						      "l2-cache-line-size", 64);
555		}
556
557		cpu_data(cpuid).core_id = portid + 1;
558		cpu_data(cpuid).proc_id = portid;
559	} else {
560		cpu_data(cpuid).dcache_size =
561			of_getintprop_default(dp, "dcache-size", 16 * 1024);
562		cpu_data(cpuid).dcache_line_size =
563			of_getintprop_default(dp, "dcache-line-size", 32);
564
565		cpu_data(cpuid).icache_size =
566			of_getintprop_default(dp, "icache-size", 16 * 1024);
567		cpu_data(cpuid).icache_line_size =
568			of_getintprop_default(dp, "icache-line-size", 32);
569
570		cpu_data(cpuid).ecache_size =
571			of_getintprop_default(dp, "ecache-size",
572					      (4 * 1024 * 1024));
573		cpu_data(cpuid).ecache_line_size =
574			of_getintprop_default(dp, "ecache-line-size", 64);
575
576		cpu_data(cpuid).core_id = 0;
577		cpu_data(cpuid).proc_id = -1;
578	}
579
580	return NULL;
581}
582
583void __init of_fill_in_cpu_data(void)
584{
585	if (tlb_type == hypervisor)
586		return;
587
588	of_iterate_over_cpus(fill_in_one_cpu, 0);
589
590	smp_fill_in_sib_core_maps();
591}
592
593void __init of_console_init(void)
594{
595	char *msg = "OF stdout device is: %s\n";
596	struct device_node *dp;
597	const char *type;
598	phandle node;
599
600	of_console_path = prom_early_alloc(256);
601	if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
602		prom_printf("Cannot obtain path of stdout.\n");
603		prom_halt();
604	}
605	of_console_options = strrchr(of_console_path, ':');
606	if (of_console_options) {
607		of_console_options++;
608		if (*of_console_options == '\0')
609			of_console_options = NULL;
610	}
611
612	node = prom_inst2pkg(prom_stdout);
613	if (!node) {
614		prom_printf("Cannot resolve stdout node from "
615			    "instance %08x.\n", prom_stdout);
616		prom_halt();
617	}
618
619	dp = of_find_node_by_phandle(node);
620	type = of_get_property(dp, "device_type", NULL);
621	if (!type) {
622		prom_printf("Console stdout lacks device_type property.\n");
623		prom_halt();
624	}
625
626	if (strcmp(type, "display") && strcmp(type, "serial")) {
627		prom_printf("Console device_type is neither display "
628			    "nor serial.\n");
629		prom_halt();
630	}
631
632	of_console_device = dp;
633
634	printk(msg, of_console_path);
635}
636