[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/memblock.h>
#include <linux/of.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", size);
		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 (!of_node_is_root(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 (!of_node_is_root(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");
}

bool arch_find_n_match_cpu_physical_id(struct device_node *cpun,
				       int cpu, unsigned int *thread)
{
	const char *mid_prop = get_mid_prop();
	int this_cpu_id;

	/* On hypervisor based platforms we interrogate the 'reg'
	 * property.  On everything else we look for a 'upa-portis',
	 * 'portid', or 'cpuid' property.
	 */

	if (tlb_type == hypervisor) {
		struct property *prop = of_find_property(cpun, "reg", NULL);
		u32 *regs;

		if (!prop) {
			pr_warn("CPU node missing reg property\n");
			return false;
		}
		regs = prop->value;
		this_cpu_id = regs[0] & 0x0fffffff;
	} else {
		this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);

		if (this_cpu_id < 0) {
			mid_prop = "cpuid";
			this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
		}
		if (this_cpu_id < 0) {
			pr_warn("CPU node missing cpu ID property\n");
			return false;
		}
	}
	if (this_cpu_id == cpu) {
		if (thread) {
			int proc_id = cpu_data(cpu).proc_id;

			/* On sparc64, the cpu thread information is obtained
			 * either from OBP or the machine description.  We've
			 * actually probed this information already long before
			 * this interface gets called so instead of interrogating
			 * both the OF node and the MDESC again, just use what
			 * we discovered already.
			 */
			if (proc_id < 0)
				proc_id = 0;
			*thread = proc_id;
		}
		return true;
	}
	return false;
}

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