[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/memblock.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/cpu.h>
#include <linux/mm.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
cfbddd0d	18	#include <linux/memblock.h>
372b07bb	19	#include <linux/kernel.h>
372b07bb	20	#include <linux/string.h>
cfbddd0d SR	21	#include <linux/types.h>
cfbddd0d SR	22	#include <linux/cpu.h>
372b07bb	23	#include <linux/mm.h>
035ebefc	24	#include <linux/of.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	40	if (!paddr) {
5da444aa	41	prom_printf("prom_early_alloc(%lu) failed\n", size);
ad072004 DM	42	prom_halt();
ad072004 DM	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;
035ebefc	84	if (!of_node_is_root(dp->parent)) {
372b07bb DM	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;
035ebefc	124	if (!of_node_is_root(dp->parent)) {
372b07bb DM	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
d1cb9d1a DM	377	bool 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
9bab5414	430	static void of_iterate_over_cpus(void (func)(struct device_node , int, int), int arg)
5cbc3073 DM	431	{
5cbc3073 DM	432	struct device_node *dp;
23dc758e DM	433	const char *mid_prop;
23dc758e DM	434
23dc758e	435	mid_prop = get_mid_prop();
5cbc3073 DM	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;
9bab5414	439	void *ret;
5cbc3073	440
5cbc3073 DM	441	if (cpuid < 0) {
	442	this_mid_prop = "cpuid";
	443	cpuid = of_getintprop_default(dp, this_mid_prop, -1);
5cbc3073	444	}
5cbc3073 DM	445	if (cpuid < 0) {
	446	prom_printf("OF: Serious problem, cpu lacks "
	447	"%s property", this_mid_prop);
	448	prom_halt();
	449	}
5cbc3073	450	#ifdef CONFIG_SMP
8a177c4f DM	451	if (cpuid >= NR_CPUS) {
	452	printk(KERN_WARNING "Ignoring CPU %d which is "
	453	">= NR_CPUS (%d)\n",
	454	cpuid, NR_CPUS);
5cbc3073	455	continue;
8a177c4f	456	}
5cbc3073	457	#endif
9bab5414 DM	458	ret = func(dp, cpuid, arg);
	459	if (ret)
	460	return ret;
	461	}
	462	return NULL;
	463	}
5cbc3073	464
9bab5414 DM	465	static 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
	472	struct device_node *of_find_node_by_cpuid(int cpuid)
	473	{
	474	return of_iterate_over_cpus(check_cpu_node, cpuid);
	475	}
	476
	477	static void record_one_cpu(struct device_node dp, int cpuid, int arg)
	478	{
	479	ncpus_probed++;
a2f9f6bb	480	#ifdef CONFIG_SMP
9bab5414 DM	481	set_cpu_present(cpuid, true);
9bab5414 DM	482	set_cpu_possible(cpuid, true);
a2f9f6bb	483	#endif
9bab5414 DM	484	return NULL;
9bab5414 DM	485	}
5cbc3073	486
9bab5414 DM	487	void __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	}
5cbc3073	495
9bab5414 DM	496	static 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) {
5cbc3073	548	cpu_data(cpuid).ecache_size =
9bab5414 DM	549	of_getintprop_default(portid_parent,
9bab5414 DM	550	"l2-cache-size",
5cbc3073 DM	551	(4 * 1024 * 1024));
5cbc3073 DM	552	cpu_data(cpuid).ecache_line_size =
9bab5414 DM	553	of_getintprop_default(portid_parent,
9bab5414 DM	554	"l2-cache-line-size", 64);
5cbc3073 DM	555	}
5cbc3073 DM	556
9bab5414 DM	557	cpu_data(cpuid).core_id = portid + 1;
9bab5414 DM	558	cpu_data(cpuid).proc_id = portid;
9bab5414 DM	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;
5cbc3073 DM	578	}
5cbc3073 DM	579
9bab5414 DM	580	return NULL;
	581	}
	582
	583	void __init of_fill_in_cpu_data(void)
	584	{
	585	if (tlb_type == hypervisor)
	586	return;
	587
9bab5414 DM	588	of_iterate_over_cpus(fill_in_one_cpu, 0);
9bab5414 DM	589
5cbc3073 DM	590	smp_fill_in_sib_core_maps();
	591	}
	592
23dc758e	593	void __init of_console_init(void)
c73fcc84 DM	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
c73fcc84 DM	634	printk(msg, of_console_path);
c73fcc84 DM	635	}