[deliverable/linux.git] / arch / sparc / kernel / prom_64.c

/*
 * 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 
 *
 *  Adapted for sparc64 by David S. Miller davem@davemloft.net
 *
 *      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.
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/lmb.h>
#include <linux/of_device.h>

#include <asm/prom.h>
#include <asm/oplib.h>
#include <asm/irq.h>
#include <asm/asi.h>
#include <asm/upa.h>
#include <asm/smp.h>

#include "prom.h"

void * __init prom_early_alloc(unsigned long size)
{
	unsigned long paddr = lmb_alloc(size, SMP_CACHE_BYTES);
	void *ret;

	if (!paddr) {
		prom_printf("prom_early_alloc(%lu) failed\n");
		prom_halt();
	}

	ret = __va(paddr);
	memset(ret, 0, size);
	prom_early_allocated += size;

	return ret;
}

/* The following routines deal with the black magic of fully naming a
 * node.
 *
 * Certain well known named nodes are just the simple name string.
 *
 * Actual devices have an address specifier appended to the base name
 * string, like this "foo@addr".  The "addr" can be in any number of
 * formats, and the platform plus the type of the node determine the
 * format and how it is constructed.
 *
 * For children of the ROOT node, the naming convention is fixed and
 * determined by whether this is a sun4u or sun4v system.
 *
 * For children of other nodes, it is bus type specific.  So
 * we walk up the tree until we discover a "device_type" property
 * we recognize and we go from there.
 *
 * As an example, the boot device on my workstation has a full path:
 *
 *	/pci@1e,600000/ide@d/disk@0,0:c
 */
static void __init sun4v_path_component(struct device_node *dp, char *tmp_buf)
{
	struct linux_prom64_registers *regs;
	struct property *rprop;
	u32 high_bits, low_bits, type;

	rprop = of_find_property(dp, "reg", NULL);
	if (!rprop)
		return;

	regs = rprop->value;
	if (!is_root_node(dp->parent)) {
		sprintf(tmp_buf, "%s@%x,%x",
			dp->name,
			(unsigned int) (regs->phys_addr >> 32UL),
			(unsigned int) (regs->phys_addr & 0xffffffffUL));
		return;
	}

	type = regs->phys_addr >> 60UL;
	high_bits = (regs->phys_addr >> 32UL) & 0x0fffffffUL;
	low_bits = (regs->phys_addr & 0xffffffffUL);

	if (type == 0 || type == 8) {
		const char *prefix = (type == 0) ? "m" : "i";

		if (low_bits)
			sprintf(tmp_buf, "%s@%s%x,%x",
				dp->name, prefix,
				high_bits, low_bits);
		else
			sprintf(tmp_buf, "%s@%s%x",
				dp->name,
				prefix,
				high_bits);
	} else if (type == 12) {
		sprintf(tmp_buf, "%s@%x",
			dp->name, high_bits);
	}
}

static void __init sun4u_path_component(struct device_node *dp, char *tmp_buf)
{
	struct linux_prom64_registers *regs;
	struct property *prop;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;
	if (!is_root_node(dp->parent)) {
		sprintf(tmp_buf, "%s@%x,%x",
			dp->name,
			(unsigned int) (regs->phys_addr >> 32UL),
			(unsigned int) (regs->phys_addr & 0xffffffffUL));
		return;
	}

	prop = of_find_property(dp, "upa-portid", NULL);
	if (!prop)
		prop = of_find_property(dp, "portid", NULL);
	if (prop) {
		unsigned long mask = 0xffffffffUL;

		if (tlb_type >= cheetah)
			mask = 0x7fffff;

		sprintf(tmp_buf, "%s@%x,%x",
			dp->name,
			*(u32 *)prop->value,
			(unsigned int) (regs->phys_addr & mask));
	}
}

/* "name@slot,offset"  */
static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
{
	struct linux_prom_registers *regs;
	struct property *prop;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;
	sprintf(tmp_buf, "%s@%x,%x",
		dp->name,
		regs->which_io,
		regs->phys_addr);
}

/* "name@devnum[,func]" */
static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
{
	struct linux_prom_pci_registers *regs;
	struct property *prop;
	unsigned int devfn;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;
	devfn = (regs->phys_hi >> 8) & 0xff;
	if (devfn & 0x07) {
		sprintf(tmp_buf, "%s@%x,%x",
			dp->name,
			devfn >> 3,
			devfn & 0x07);
	} else {
		sprintf(tmp_buf, "%s@%x",
			dp->name,
			devfn >> 3);
	}
}

/* "name@UPA_PORTID,offset" */
static void __init upa_path_component(struct device_node *dp, char *tmp_buf)
{
	struct linux_prom64_registers *regs;
	struct property *prop;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;

	prop = of_find_property(dp, "upa-portid", NULL);
	if (!prop)
		return;

	sprintf(tmp_buf, "%s@%x,%x",
		dp->name,
		*(u32 *) prop->value,
		(unsigned int) (regs->phys_addr & 0xffffffffUL));
}

/* "name@reg" */
static void __init vdev_path_component(struct device_node *dp, char *tmp_buf)
{
	struct property *prop;
	u32 *regs;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;

	sprintf(tmp_buf, "%s@%x", dp->name, *regs);
}

/* "name@addrhi,addrlo" */
static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
{
	struct linux_prom64_registers *regs;
	struct property *prop;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;

	sprintf(tmp_buf, "%s@%x,%x",
		dp->name,
		(unsigned int) (regs->phys_addr >> 32UL),
		(unsigned int) (regs->phys_addr & 0xffffffffUL));
}

/* "name@bus,addr" */
static void __init i2c_path_component(struct device_node *dp, char *tmp_buf)
{
	struct property *prop;
	u32 *regs;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;

	/* This actually isn't right... should look at the #address-cells
	 * property of the i2c bus node etc. etc.
	 */
	sprintf(tmp_buf, "%s@%x,%x",
		dp->name, regs[0], regs[1]);
}

/* "name@reg0[,reg1]" */
static void __init usb_path_component(struct device_node *dp, char *tmp_buf)
{
	struct property *prop;
	u32 *regs;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;

	if (prop->length == sizeof(u32) || regs[1] == 1) {
		sprintf(tmp_buf, "%s@%x",
			dp->name, regs[0]);
	} else {
		sprintf(tmp_buf, "%s@%x,%x",
			dp->name, regs[0], regs[1]);
	}
}

/* "name@reg0reg1[,reg2reg3]" */
static void __init ieee1394_path_component(struct device_node *dp, char *tmp_buf)
{
	struct property *prop;
	u32 *regs;

	prop = of_find_property(dp, "reg", NULL);
	if (!prop)
		return;

	regs = prop->value;

	if (regs[2] || regs[3]) {
		sprintf(tmp_buf, "%s@%08x%08x,%04x%08x",
			dp->name, regs[0], regs[1], regs[2], regs[3]);
	} else {
		sprintf(tmp_buf, "%s@%08x%08x",
			dp->name, regs[0], regs[1]);
	}
}

static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
{
	struct device_node *parent = dp->parent;

	if (parent != NULL) {
		if (!strcmp(parent->type, "pci") ||
		    !strcmp(parent->type, "pciex")) {
			pci_path_component(dp, tmp_buf);
			return;
		}
		if (!strcmp(parent->type, "sbus")) {
			sbus_path_component(dp, tmp_buf);
			return;
		}
		if (!strcmp(parent->type, "upa")) {
			upa_path_component(dp, tmp_buf);
			return;
		}
		if (!strcmp(parent->type, "ebus")) {
			ebus_path_component(dp, tmp_buf);
			return;
		}
		if (!strcmp(parent->name, "usb") ||
		    !strcmp(parent->name, "hub")) {
			usb_path_component(dp, tmp_buf);
			return;
		}
		if (!strcmp(parent->type, "i2c")) {
			i2c_path_component(dp, tmp_buf);
			return;
		}
		if (!strcmp(parent->type, "firewire")) {
			ieee1394_path_component(dp, tmp_buf);
			return;
		}
		if (!strcmp(parent->type, "virtual-devices")) {
			vdev_path_component(dp, tmp_buf);
			return;
		}
		/* "isa" is handled with platform naming */
	}

	/* Use platform naming convention.  */
	if (tlb_type == hypervisor) {
		sun4v_path_component(dp, tmp_buf);
		return;
	} else {
		sun4u_path_component(dp, tmp_buf);
	}
}

char * __init build_path_component(struct device_node *dp)
{
	char tmp_buf[64], *n;

	tmp_buf[0] = '\0';
	__build_path_component(dp, tmp_buf);
	if (tmp_buf[0] == '\0')
		strcpy(tmp_buf, dp->name);

	n = prom_early_alloc(strlen(tmp_buf) + 1);
	strcpy(n, tmp_buf);

	return n;
}

static const char *get_mid_prop(void)
{
	return (tlb_type == spitfire ? "upa-portid" : "portid");
}

struct device_node *of_find_node_by_cpuid(int cpuid)
{
	struct device_node *dp;
	const char *mid_prop = get_mid_prop();

	for_each_node_by_type(dp, "cpu") {
		int id = of_getintprop_default(dp, mid_prop, -1);
		const char *this_mid_prop = mid_prop;

		if (id < 0) {
			this_mid_prop = "cpuid";
			id = of_getintprop_default(dp, this_mid_prop, -1);
		}

		if (id < 0) {
			prom_printf("OF: Serious problem, cpu lacks "
				    "%s property", this_mid_prop);
			prom_halt();
		}
		if (cpuid == id)
			return dp;
	}
	return NULL;
}

void __init of_fill_in_cpu_data(void)
{
	struct device_node *dp;
	const char *mid_prop;

	if (tlb_type == hypervisor)
		return;

	mid_prop = get_mid_prop();
	ncpus_probed = 0;
	for_each_node_by_type(dp, "cpu") {
		int cpuid = of_getintprop_default(dp, mid_prop, -1);
		const char *this_mid_prop = mid_prop;
		struct device_node *portid_parent;
		int portid = -1;

		portid_parent = NULL;
		if (cpuid < 0) {
			this_mid_prop = "cpuid";
			cpuid = of_getintprop_default(dp, this_mid_prop, -1);
			if (cpuid >= 0) {
				int limit = 2;

				portid_parent = dp;
				while (limit--) {
					portid_parent = portid_parent->parent;
					if (!portid_parent)
						break;
					portid = of_getintprop_default(portid_parent,
								       "portid", -1);
					if (portid >= 0)
						break;
				}
			}
		}

		if (cpuid < 0) {
			prom_printf("OF: Serious problem, cpu lacks "
				    "%s property", this_mid_prop);
			prom_halt();
		}

		ncpus_probed++;

#ifdef CONFIG_SMP
		if (cpuid >= NR_CPUS) {
			printk(KERN_WARNING "Ignoring CPU %d which is "
			       ">= NR_CPUS (%d)\n",
			       cpuid, NR_CPUS);
			continue;
		}
#else
		/* On uniprocessor we only want the values for the
		 * real physical cpu the kernel booted onto, however
		 * cpu_data() only has one entry at index 0.
		 */
		if (cpuid != real_hard_smp_processor_id())
			continue;
		cpuid = 0;
#endif

		cpu_data(cpuid).clock_tick =
			of_getintprop_default(dp, "clock-frequency", 0);

		if (portid_parent) {
			cpu_data(cpuid).dcache_size =
				of_getintprop_default(dp, "l1-dcache-size",
						      16 * 1024);
			cpu_data(cpuid).dcache_line_size =
				of_getintprop_default(dp, "l1-dcache-line-size",
						      32);
			cpu_data(cpuid).icache_size =
				of_getintprop_default(dp, "l1-icache-size",
						      8 * 1024);
			cpu_data(cpuid).icache_line_size =
				of_getintprop_default(dp, "l1-icache-line-size",
						      32);
			cpu_data(cpuid).ecache_size =
				of_getintprop_default(dp, "l2-cache-size", 0);
			cpu_data(cpuid).ecache_line_size =
				of_getintprop_default(dp, "l2-cache-line-size", 0);
			if (!cpu_data(cpuid).ecache_size ||
			    !cpu_data(cpuid).ecache_line_size) {
				cpu_data(cpuid).ecache_size =
					of_getintprop_default(portid_parent,
							      "l2-cache-size",
							      (4 * 1024 * 1024));
				cpu_data(cpuid).ecache_line_size =
					of_getintprop_default(portid_parent,
							      "l2-cache-line-size", 64);
			}

			cpu_data(cpuid).core_id = portid + 1;
			cpu_data(cpuid).proc_id = portid;
#ifdef CONFIG_SMP
			sparc64_multi_core = 1;
#endif
		} else {
			cpu_data(cpuid).dcache_size =
				of_getintprop_default(dp, "dcache-size", 16 * 1024);
			cpu_data(cpuid).dcache_line_size =
				of_getintprop_default(dp, "dcache-line-size", 32);

			cpu_data(cpuid).icache_size =
				of_getintprop_default(dp, "icache-size", 16 * 1024);
			cpu_data(cpuid).icache_line_size =
				of_getintprop_default(dp, "icache-line-size", 32);

			cpu_data(cpuid).ecache_size =
				of_getintprop_default(dp, "ecache-size",
						      (4 * 1024 * 1024));
			cpu_data(cpuid).ecache_line_size =
				of_getintprop_default(dp, "ecache-line-size", 64);

			cpu_data(cpuid).core_id = 0;
			cpu_data(cpuid).proc_id = -1;
		}

#ifdef CONFIG_SMP
		cpu_set(cpuid, cpu_present_map);
		cpu_set(cpuid, cpu_possible_map);
#endif
	}

	smp_fill_in_sib_core_maps();
}

void __init of_console_init(void)
{
	char *msg = "OF stdout device is: %s\n";
	struct device_node *dp;
	const char *type;
	phandle node;

	of_console_path = prom_early_alloc(256);
	if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
		prom_printf("Cannot obtain path of stdout.\n");
		prom_halt();
	}
	of_console_options = strrchr(of_console_path, ':');
	if (of_console_options) {
		of_console_options++;
		if (*of_console_options == '\0')
			of_console_options = NULL;
	}

	node = prom_inst2pkg(prom_stdout);
	if (!node) {
		prom_printf("Cannot resolve stdout node from "
			    "instance %08x.\n", prom_stdout);
		prom_halt();
	}

	dp = of_find_node_by_phandle(node);
	type = of_get_property(dp, "device_type", NULL);
	if (!type) {
		prom_printf("Console stdout lacks device_type property.\n");
		prom_halt();
	}

	if (strcmp(type, "display") && strcmp(type, "serial")) {
		prom_printf("Console device_type is neither display "
			    "nor serial.\n");
		prom_halt();
	}

	of_console_device = dp;

	printk(msg, of_console_path);
}
Commit	Line	Data
372b07bb DM	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/kernel.h>
	19	#include <linux/types.h>
	20	#include <linux/string.h>
	21	#include <linux/mm.h>
de8d28b1	22	#include <linux/module.h>
ad072004	23	#include <linux/lmb.h>
764f2579	24	#include <linux/of_device.h>
372b07bb DM	25
	26	#include <asm/prom.h>
	27	#include <asm/oplib.h>
2b1e5978 DM	28	#include <asm/irq.h>
	29	#include <asm/asi.h>
	30	#include <asm/upa.h>
5cbc3073	31	#include <asm/smp.h>
372b07bb	32
657f201d	33	#include "prom.h"
fb7cd9d9	34
efeac2f8	35	void * __init prom_early_alloc(unsigned long size)
372b07bb	36	{
ad072004	37	unsigned long paddr = lmb_alloc(size, SMP_CACHE_BYTES);
372b07bb DM	38	void *ret;
372b07bb DM	39
ad072004 DM	40	if (!paddr) {
	41	prom_printf("prom_early_alloc(%lu) failed\n");
	42	prom_halt();
	43	}
372b07bb	44
ad072004 DM	45	ret = __va(paddr);
ad072004 DM	46	memset(ret, 0, size);
372b07bb DM	47	prom_early_allocated += size;
	48
	49	return ret;
	50	}
	51
372b07bb DM	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	*/
	73	static 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 (!is_root_node(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
	114	static 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 (!is_root_node(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" */
149	static 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]" */
166	static 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" */
191	static 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" */
213	static 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" */
228	static 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" */
246	static 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]" */
265	static 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]" */
286	static 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
306	static 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") \|\|
c91e2eca DM	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	}
372b07bb	328	if (!strcmp(parent->name, "usb") \|\|
c91e2eca DM	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	}
372b07bb DM	345	/* "isa" is handled with platform naming */
	346	}
	347
	348	/* Use platform naming convention. */
c91e2eca DM	349	if (tlb_type == hypervisor) {
	350	sun4v_path_component(dp, tmp_buf);
	351	return;
	352	} else {
	353	sun4u_path_component(dp, tmp_buf);
	354	}
372b07bb DM	355	}
372b07bb DM	356
6524036a	357	char * __init build_path_component(struct device_node *dp)
372b07bb DM	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
5cbc3073 DM	372	static const char *get_mid_prop(void)
	373	{
	374	return (tlb_type == spitfire ? "upa-portid" : "portid");
	375	}
	376
	377	struct device_node *of_find_node_by_cpuid(int cpuid)
	378	{
	379	struct device_node *dp;
	380	const char *mid_prop = get_mid_prop();
	381
	382	for_each_node_by_type(dp, "cpu") {
	383	int id = of_getintprop_default(dp, mid_prop, -1);
	384	const char *this_mid_prop = mid_prop;
	385
	386	if (id < 0) {
	387	this_mid_prop = "cpuid";
	388	id = of_getintprop_default(dp, this_mid_prop, -1);
	389	}
	390
	391	if (id < 0) {
	392	prom_printf("OF: Serious problem, cpu lacks "
	393	"%s property", this_mid_prop);
	394	prom_halt();
	395	}
	396	if (cpuid == id)
	397	return dp;
	398	}
	399	return NULL;
	400	}
	401
23dc758e	402	void __init of_fill_in_cpu_data(void)
5cbc3073 DM	403	{
5cbc3073 DM	404	struct device_node *dp;
23dc758e DM	405	const char *mid_prop;
	406
	407	if (tlb_type == hypervisor)
	408	return;
5cbc3073	409
23dc758e	410	mid_prop = get_mid_prop();
5cbc3073 DM	411	ncpus_probed = 0;
	412	for_each_node_by_type(dp, "cpu") {
	413	int cpuid = of_getintprop_default(dp, mid_prop, -1);
	414	const char *this_mid_prop = mid_prop;
	415	struct device_node *portid_parent;
	416	int portid = -1;
	417
	418	portid_parent = NULL;
	419	if (cpuid < 0) {
	420	this_mid_prop = "cpuid";
	421	cpuid = of_getintprop_default(dp, this_mid_prop, -1);
	422	if (cpuid >= 0) {
	423	int limit = 2;
	424
	425	portid_parent = dp;
	426	while (limit--) {
	427	portid_parent = portid_parent->parent;
	428	if (!portid_parent)
	429	break;
	430	portid = of_getintprop_default(portid_parent,
	431	"portid", -1);
	432	if (portid >= 0)
	433	break;
	434	}
	435	}
	436	}
	437
	438	if (cpuid < 0) {
	439	prom_printf("OF: Serious problem, cpu lacks "
	440	"%s property", this_mid_prop);
	441	prom_halt();
	442	}
	443
	444	ncpus_probed++;
	445
	446	#ifdef CONFIG_SMP
8a177c4f DM	447	if (cpuid >= NR_CPUS) {
	448	printk(KERN_WARNING "Ignoring CPU %d which is "
	449	">= NR_CPUS (%d)\n",
	450	cpuid, NR_CPUS);
5cbc3073	451	continue;
8a177c4f	452	}
5cbc3073 DM	453	#else
	454	/* On uniprocessor we only want the values for the
	455	* real physical cpu the kernel booted onto, however
	456	* cpu_data() only has one entry at index 0.
	457	*/
	458	if (cpuid != real_hard_smp_processor_id())
	459	continue;
	460	cpuid = 0;
	461	#endif
	462
	463	cpu_data(cpuid).clock_tick =
	464	of_getintprop_default(dp, "clock-frequency", 0);
	465
	466	if (portid_parent) {
	467	cpu_data(cpuid).dcache_size =
	468	of_getintprop_default(dp, "l1-dcache-size",
	469	16 * 1024);
	470	cpu_data(cpuid).dcache_line_size =
	471	of_getintprop_default(dp, "l1-dcache-line-size",
	472	32);
	473	cpu_data(cpuid).icache_size =
	474	of_getintprop_default(dp, "l1-icache-size",
	475	8 * 1024);
	476	cpu_data(cpuid).icache_line_size =
	477	of_getintprop_default(dp, "l1-icache-line-size",
	478	32);
	479	cpu_data(cpuid).ecache_size =
	480	of_getintprop_default(dp, "l2-cache-size", 0);
	481	cpu_data(cpuid).ecache_line_size =
	482	of_getintprop_default(dp, "l2-cache-line-size", 0);
	483	if (!cpu_data(cpuid).ecache_size \|\|
	484	!cpu_data(cpuid).ecache_line_size) {
	485	cpu_data(cpuid).ecache_size =
	486	of_getintprop_default(portid_parent,
	487	"l2-cache-size",
	488	(4 * 1024 * 1024));
	489	cpu_data(cpuid).ecache_line_size =
	490	of_getintprop_default(portid_parent,
	491	"l2-cache-line-size", 64);
	492	}
	493
	494	cpu_data(cpuid).core_id = portid + 1;
5cd342df	495	cpu_data(cpuid).proc_id = portid;
a2f9f6bb DM	496	#ifdef CONFIG_SMP
	497	sparc64_multi_core = 1;
	498	#endif
5cbc3073 DM	499	} else {
	500	cpu_data(cpuid).dcache_size =
	501	of_getintprop_default(dp, "dcache-size", 16 * 1024);
	502	cpu_data(cpuid).dcache_line_size =
	503	of_getintprop_default(dp, "dcache-line-size", 32);
	504
	505	cpu_data(cpuid).icache_size =
	506	of_getintprop_default(dp, "icache-size", 16 * 1024);
	507	cpu_data(cpuid).icache_line_size =
	508	of_getintprop_default(dp, "icache-line-size", 32);
	509
	510	cpu_data(cpuid).ecache_size =
	511	of_getintprop_default(dp, "ecache-size",
	512	(4 * 1024 * 1024));
	513	cpu_data(cpuid).ecache_line_size =
	514	of_getintprop_default(dp, "ecache-line-size", 64);
	515
	516	cpu_data(cpuid).core_id = 0;
5cd342df	517	cpu_data(cpuid).proc_id = -1;
5cbc3073 DM	518	}
	519
	520	#ifdef CONFIG_SMP
	521	cpu_set(cpuid, cpu_present_map);
4f0234f4	522	cpu_set(cpuid, cpu_possible_map);
5cbc3073 DM	523	#endif
	524	}
	525
	526	smp_fill_in_sib_core_maps();
	527	}
	528
23dc758e	529	void __init of_console_init(void)
c73fcc84 DM	530	{
	531	char *msg = "OF stdout device is: %s\n";
	532	struct device_node *dp;
	533	const char *type;
	534	phandle node;
	535
	536	of_console_path = prom_early_alloc(256);
	537	if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
	538	prom_printf("Cannot obtain path of stdout.\n");
	539	prom_halt();
	540	}
	541	of_console_options = strrchr(of_console_path, ':');
	542	if (of_console_options) {
	543	of_console_options++;
	544	if (*of_console_options == '\0')
	545	of_console_options = NULL;
	546	}
	547
	548	node = prom_inst2pkg(prom_stdout);
	549	if (!node) {
	550	prom_printf("Cannot resolve stdout node from "
	551	"instance %08x.\n", prom_stdout);
	552	prom_halt();
	553	}
	554
	555	dp = of_find_node_by_phandle(node);
	556	type = of_get_property(dp, "device_type", NULL);
	557	if (!type) {
	558	prom_printf("Console stdout lacks device_type property.\n");
	559	prom_halt();
	560	}
	561
	562	if (strcmp(type, "display") && strcmp(type, "serial")) {
	563	prom_printf("Console device_type is neither display "
	564	"nor serial.\n");
	565	prom_halt();
	566	}
	567
	568	of_console_device = dp;
	569
c73fcc84 DM	570	printk(msg, of_console_path);
c73fcc84 DM	571	}