[linux-2.6-block.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/memblock.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 = memblock_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");
}

static void *of_iterate_over_cpus(void *(*func)(struct device_node *, int, int), int arg)
{
	struct device_node *dp;
	const char *mid_prop;

	mid_prop = get_mid_prop();
	for_each_node_by_type(dp, "cpu") {
		int cpuid = of_getintprop_default(dp, mid_prop, -1);
		const char *this_mid_prop = mid_prop;
		void *ret;

		if (cpuid < 0) {
			this_mid_prop = "cpuid";
			cpuid = of_getintprop_default(dp, this_mid_prop, -1);
		}
		if (cpuid < 0) {
			prom_printf("OF: Serious problem, cpu lacks "
				    "%s property", this_mid_prop);
			prom_halt();
		}
#ifdef CONFIG_SMP
		if (cpuid >= NR_CPUS) {
			printk(KERN_WARNING "Ignoring CPU %d which is "
			       ">= NR_CPUS (%d)\n",
			       cpuid, NR_CPUS);
			continue;
		}
#endif
		ret = func(dp, cpuid, arg);
		if (ret)
			return ret;
	}
	return NULL;
}

static void *check_cpu_node(struct device_node *dp, int cpuid, int id)
{
	if (id == cpuid)
		return dp;
	return NULL;
}

struct device_node *of_find_node_by_cpuid(int cpuid)
{
	return of_iterate_over_cpus(check_cpu_node, cpuid);
}

static void *record_one_cpu(struct device_node *dp, int cpuid, int arg)
{
	ncpus_probed++;
#ifdef CONFIG_SMP
	set_cpu_present(cpuid, true);
	set_cpu_possible(cpuid, true);
#endif
	return NULL;
}

void __init of_populate_present_mask(void)
{
	if (tlb_type == hypervisor)
		return;

	ncpus_probed = 0;
	of_iterate_over_cpus(record_one_cpu, 0);
}

static void *fill_in_one_cpu(struct device_node *dp, int cpuid, int arg)
{
	struct device_node *portid_parent = NULL;
	int portid = -1;

	if (of_find_property(dp, "cpuid", NULL)) {
		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;
		}
	}

#ifndef CONFIG_SMP
	/* 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())
		return NULL;
	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;
	}

	return NULL;
}

void __init of_fill_in_cpu_data(void)
{
	if (tlb_type == hypervisor)
		return;

	of_iterate_over_cpus(fill_in_one_cpu, 0);

	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>
95f72d1e	23	#include <linux/memblock.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	{
95f72d1e	37	unsigned long paddr = memblock_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
9bab5414	377	static void of_iterate_over_cpus(void (func)(struct device_node , int, int), int arg)
5cbc3073 DM	378	{
5cbc3073 DM	379	struct device_node *dp;
23dc758e DM	380	const char *mid_prop;
23dc758e DM	381
23dc758e	382	mid_prop = get_mid_prop();
5cbc3073 DM	383	for_each_node_by_type(dp, "cpu") {
	384	int cpuid = of_getintprop_default(dp, mid_prop, -1);
	385	const char *this_mid_prop = mid_prop;
9bab5414	386	void *ret;
5cbc3073	387
5cbc3073 DM	388	if (cpuid < 0) {
	389	this_mid_prop = "cpuid";
	390	cpuid = of_getintprop_default(dp, this_mid_prop, -1);
5cbc3073	391	}
5cbc3073 DM	392	if (cpuid < 0) {
	393	prom_printf("OF: Serious problem, cpu lacks "
	394	"%s property", this_mid_prop);
	395	prom_halt();
	396	}
5cbc3073	397	#ifdef CONFIG_SMP
8a177c4f DM	398	if (cpuid >= NR_CPUS) {
	399	printk(KERN_WARNING "Ignoring CPU %d which is "
	400	">= NR_CPUS (%d)\n",
	401	cpuid, NR_CPUS);
5cbc3073	402	continue;
8a177c4f	403	}
5cbc3073	404	#endif
9bab5414 DM	405	ret = func(dp, cpuid, arg);
	406	if (ret)
	407	return ret;
	408	}
	409	return NULL;
	410	}
5cbc3073	411
9bab5414 DM	412	static void check_cpu_node(struct device_node dp, int cpuid, int id)
	413	{
	414	if (id == cpuid)
	415	return dp;
	416	return NULL;
	417	}
	418
	419	struct device_node *of_find_node_by_cpuid(int cpuid)
	420	{
	421	return of_iterate_over_cpus(check_cpu_node, cpuid);
	422	}
	423
	424	static void record_one_cpu(struct device_node dp, int cpuid, int arg)
	425	{
	426	ncpus_probed++;
a2f9f6bb	427	#ifdef CONFIG_SMP
9bab5414 DM	428	set_cpu_present(cpuid, true);
9bab5414 DM	429	set_cpu_possible(cpuid, true);
a2f9f6bb	430	#endif
9bab5414 DM	431	return NULL;
9bab5414 DM	432	}
5cbc3073	433
9bab5414 DM	434	void __init of_populate_present_mask(void)
	435	{
	436	if (tlb_type == hypervisor)
	437	return;
	438
	439	ncpus_probed = 0;
	440	of_iterate_over_cpus(record_one_cpu, 0);
	441	}
5cbc3073	442
9bab5414 DM	443	static void fill_in_one_cpu(struct device_node dp, int cpuid, int arg)
	444	{
	445	struct device_node *portid_parent = NULL;
	446	int portid = -1;
	447
	448	if (of_find_property(dp, "cpuid", NULL)) {
	449	int limit = 2;
	450
	451	portid_parent = dp;
	452	while (limit--) {
	453	portid_parent = portid_parent->parent;
	454	if (!portid_parent)
	455	break;
	456	portid = of_getintprop_default(portid_parent,
	457	"portid", -1);
	458	if (portid >= 0)
	459	break;
	460	}
	461	}
	462
	463	#ifndef CONFIG_SMP
	464	/* On uniprocessor we only want the values for the
	465	* real physical cpu the kernel booted onto, however
	466	* cpu_data() only has one entry at index 0.
	467	*/
	468	if (cpuid != real_hard_smp_processor_id())
	469	return NULL;
	470	cpuid = 0;
	471	#endif
	472
	473	cpu_data(cpuid).clock_tick =
	474	of_getintprop_default(dp, "clock-frequency", 0);
	475
	476	if (portid_parent) {
	477	cpu_data(cpuid).dcache_size =
	478	of_getintprop_default(dp, "l1-dcache-size",
	479	16 * 1024);
	480	cpu_data(cpuid).dcache_line_size =
	481	of_getintprop_default(dp, "l1-dcache-line-size",
	482	32);
	483	cpu_data(cpuid).icache_size =
	484	of_getintprop_default(dp, "l1-icache-size",
	485	8 * 1024);
	486	cpu_data(cpuid).icache_line_size =
	487	of_getintprop_default(dp, "l1-icache-line-size",
	488	32);
	489	cpu_data(cpuid).ecache_size =
	490	of_getintprop_default(dp, "l2-cache-size", 0);
	491	cpu_data(cpuid).ecache_line_size =
	492	of_getintprop_default(dp, "l2-cache-line-size", 0);
	493	if (!cpu_data(cpuid).ecache_size \|\|
	494	!cpu_data(cpuid).ecache_line_size) {
5cbc3073	495	cpu_data(cpuid).ecache_size =
9bab5414 DM	496	of_getintprop_default(portid_parent,
9bab5414 DM	497	"l2-cache-size",
5cbc3073 DM	498	(4 * 1024 * 1024));
5cbc3073 DM	499	cpu_data(cpuid).ecache_line_size =
9bab5414 DM	500	of_getintprop_default(portid_parent,
9bab5414 DM	501	"l2-cache-line-size", 64);
5cbc3073 DM	502	}
5cbc3073 DM	503
9bab5414 DM	504	cpu_data(cpuid).core_id = portid + 1;
9bab5414 DM	505	cpu_data(cpuid).proc_id = portid;
5cbc3073	506	#ifdef CONFIG_SMP
9bab5414	507	sparc64_multi_core = 1;
5cbc3073	508	#endif
9bab5414 DM	509	} else {
	510	cpu_data(cpuid).dcache_size =
	511	of_getintprop_default(dp, "dcache-size", 16 * 1024);
	512	cpu_data(cpuid).dcache_line_size =
	513	of_getintprop_default(dp, "dcache-line-size", 32);
	514
	515	cpu_data(cpuid).icache_size =
	516	of_getintprop_default(dp, "icache-size", 16 * 1024);
	517	cpu_data(cpuid).icache_line_size =
	518	of_getintprop_default(dp, "icache-line-size", 32);
	519
	520	cpu_data(cpuid).ecache_size =
	521	of_getintprop_default(dp, "ecache-size",
	522	(4 * 1024 * 1024));
	523	cpu_data(cpuid).ecache_line_size =
	524	of_getintprop_default(dp, "ecache-line-size", 64);
	525
	526	cpu_data(cpuid).core_id = 0;
	527	cpu_data(cpuid).proc_id = -1;
5cbc3073 DM	528	}
5cbc3073 DM	529
9bab5414 DM	530	return NULL;
	531	}
	532
	533	void __init of_fill_in_cpu_data(void)
	534	{
	535	if (tlb_type == hypervisor)
	536	return;
	537
9bab5414 DM	538	of_iterate_over_cpus(fill_in_one_cpu, 0);
9bab5414 DM	539
5cbc3073 DM	540	smp_fill_in_sib_core_maps();
	541	}
	542
23dc758e	543	void __init of_console_init(void)
c73fcc84 DM	544	{
	545	char *msg = "OF stdout device is: %s\n";
	546	struct device_node *dp;
	547	const char *type;
	548	phandle node;
	549
	550	of_console_path = prom_early_alloc(256);
	551	if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
	552	prom_printf("Cannot obtain path of stdout.\n");
	553	prom_halt();
	554	}
	555	of_console_options = strrchr(of_console_path, ':');
	556	if (of_console_options) {
	557	of_console_options++;
	558	if (*of_console_options == '\0')
	559	of_console_options = NULL;
	560	}
	561
	562	node = prom_inst2pkg(prom_stdout);
	563	if (!node) {
	564	prom_printf("Cannot resolve stdout node from "
	565	"instance %08x.\n", prom_stdout);
	566	prom_halt();
	567	}
	568
	569	dp = of_find_node_by_phandle(node);
	570	type = of_get_property(dp, "device_type", NULL);
	571	if (!type) {
	572	prom_printf("Console stdout lacks device_type property.\n");
	573	prom_halt();
	574	}
	575
	576	if (strcmp(type, "display") && strcmp(type, "serial")) {
	577	prom_printf("Console device_type is neither display "
	578	"nor serial.\n");
	579	prom_halt();
	580	}
	581
	582	of_console_device = dp;
	583
c73fcc84 DM	584	printk(msg, of_console_path);
c73fcc84 DM	585	}