[deliverable/linux.git] / arch / sparc64 / kernel / mdesc.c

/* mdesc.c: Sun4V machine description handling.
 *
 * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
 */
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/bootmem.h>
#include <linux/log2.h>
#include <linux/list.h>
#include <linux/slab.h>

#include <asm/hypervisor.h>
#include <asm/mdesc.h>
#include <asm/prom.h>
#include <asm/oplib.h>
#include <asm/smp.h>

/* Unlike the OBP device tree, the machine description is a full-on
 * DAG.  An arbitrary number of ARCs are possible from one
 * node to other nodes and thus we can't use the OBP device_node
 * data structure to represent these nodes inside of the kernel.
 *
 * Actually, it isn't even a DAG, because there are back pointers
 * which create cycles in the graph.
 *
 * mdesc_hdr and mdesc_elem describe the layout of the data structure
 * we get from the Hypervisor.
 */
struct mdesc_hdr {
	u32	version; /* Transport version */
	u32	node_sz; /* node block size */
	u32	name_sz; /* name block size */
	u32	data_sz; /* data block size */
} __attribute__((aligned(16)));

struct mdesc_elem {
	u8	tag;
#define MD_LIST_END	0x00
#define MD_NODE		0x4e
#define MD_NODE_END	0x45
#define MD_NOOP		0x20
#define MD_PROP_ARC	0x61
#define MD_PROP_VAL	0x76
#define MD_PROP_STR	0x73
#define MD_PROP_DATA	0x64
	u8	name_len;
	u16	resv;
	u32	name_offset;
	union {
		struct {
			u32	data_len;
			u32	data_offset;
		} data;
		u64	val;
	} d;
};

struct mdesc_mem_ops {
	struct mdesc_handle *(*alloc)(unsigned int mdesc_size);
	void (*free)(struct mdesc_handle *handle);
};

struct mdesc_handle {
	struct list_head	list;
	struct mdesc_mem_ops	*mops;
	void			*self_base;
	atomic_t		refcnt;
	unsigned int		handle_size;
	struct mdesc_hdr	mdesc;
};

static void mdesc_handle_init(struct mdesc_handle *hp,
			      unsigned int handle_size,
			      void *base)
{
	BUG_ON(((unsigned long)&hp->mdesc) & (16UL - 1));

	memset(hp, 0, handle_size);
	INIT_LIST_HEAD(&hp->list);
	hp->self_base = base;
	atomic_set(&hp->refcnt, 1);
	hp->handle_size = handle_size;
}

static struct mdesc_handle *mdesc_bootmem_alloc(unsigned int mdesc_size)
{
	struct mdesc_handle *hp;
	unsigned int handle_size, alloc_size;

	handle_size = (sizeof(struct mdesc_handle) -
		       sizeof(struct mdesc_hdr) +
		       mdesc_size);
	alloc_size = PAGE_ALIGN(handle_size);

	hp = __alloc_bootmem(alloc_size, PAGE_SIZE, 0UL);
	if (hp)
		mdesc_handle_init(hp, handle_size, hp);

	return hp;
}

static void mdesc_bootmem_free(struct mdesc_handle *hp)
{
	unsigned int alloc_size, handle_size = hp->handle_size;
	unsigned long start, end;

	BUG_ON(atomic_read(&hp->refcnt) != 0);
	BUG_ON(!list_empty(&hp->list));

	alloc_size = PAGE_ALIGN(handle_size);

	start = (unsigned long) hp;
	end = start + alloc_size;

	while (start < end) {
		struct page *p;

		p = virt_to_page(start);
		ClearPageReserved(p);
		__free_page(p);
		start += PAGE_SIZE;
	}
}

static struct mdesc_mem_ops bootmem_mdesc_memops = {
	.alloc = mdesc_bootmem_alloc,
	.free  = mdesc_bootmem_free,
};

static struct mdesc_handle *mdesc_kmalloc(unsigned int mdesc_size)
{
	unsigned int handle_size;
	void *base;

	handle_size = (sizeof(struct mdesc_handle) -
		       sizeof(struct mdesc_hdr) +
		       mdesc_size);

	base = kmalloc(handle_size + 15, GFP_KERNEL);
	if (base) {
		struct mdesc_handle *hp;
		unsigned long addr;

		addr = (unsigned long)base;
		addr = (addr + 15UL) & ~15UL;
		hp = (struct mdesc_handle *) addr;

		mdesc_handle_init(hp, handle_size, base);
		return hp;
	}

	return NULL;
}

static void mdesc_kfree(struct mdesc_handle *hp)
{
	BUG_ON(atomic_read(&hp->refcnt) != 0);
	BUG_ON(!list_empty(&hp->list));

	kfree(hp->self_base);
}

static struct mdesc_mem_ops kmalloc_mdesc_memops = {
	.alloc = mdesc_kmalloc,
	.free  = mdesc_kfree,
};

static struct mdesc_handle *mdesc_alloc(unsigned int mdesc_size,
					struct mdesc_mem_ops *mops)
{
	struct mdesc_handle *hp = mops->alloc(mdesc_size);

	if (hp)
		hp->mops = mops;

	return hp;
}

static void mdesc_free(struct mdesc_handle *hp)
{
	hp->mops->free(hp);
}

static struct mdesc_handle *cur_mdesc;
static LIST_HEAD(mdesc_zombie_list);
static DEFINE_SPINLOCK(mdesc_lock);

struct mdesc_handle *mdesc_grab(void)
{
	struct mdesc_handle *hp;
	unsigned long flags;

	spin_lock_irqsave(&mdesc_lock, flags);
	hp = cur_mdesc;
	if (hp)
		atomic_inc(&hp->refcnt);
	spin_unlock_irqrestore(&mdesc_lock, flags);

	return hp;
}
EXPORT_SYMBOL(mdesc_grab);

void mdesc_release(struct mdesc_handle *hp)
{
	unsigned long flags;

	spin_lock_irqsave(&mdesc_lock, flags);
	if (atomic_dec_and_test(&hp->refcnt)) {
		list_del_init(&hp->list);
		hp->mops->free(hp);
	}
	spin_unlock_irqrestore(&mdesc_lock, flags);
}
EXPORT_SYMBOL(mdesc_release);

static void do_mdesc_update(struct work_struct *work)
{
	unsigned long len, real_len, status;
	struct mdesc_handle *hp, *orig_hp;
	unsigned long flags;

	(void) sun4v_mach_desc(0UL, 0UL, &len);

	hp = mdesc_alloc(len, &kmalloc_mdesc_memops);
	if (!hp) {
		printk(KERN_ERR "MD: mdesc alloc fails\n");
		return;
	}

	status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
	if (status != HV_EOK || real_len > len) {
		printk(KERN_ERR "MD: mdesc reread fails with %lu\n",
		       status);
		atomic_dec(&hp->refcnt);
		mdesc_free(hp);
		return;
	}

	spin_lock_irqsave(&mdesc_lock, flags);
	orig_hp = cur_mdesc;
	cur_mdesc = hp;

	if (atomic_dec_and_test(&orig_hp->refcnt))
		mdesc_free(orig_hp);
	else
		list_add(&orig_hp->list, &mdesc_zombie_list);
	spin_unlock_irqrestore(&mdesc_lock, flags);
}

static DECLARE_WORK(mdesc_update_work, do_mdesc_update);

void mdesc_update(void)
{
	schedule_work(&mdesc_update_work);
}

static struct mdesc_elem *node_block(struct mdesc_hdr *mdesc)
{
	return (struct mdesc_elem *) (mdesc + 1);
}

static void *name_block(struct mdesc_hdr *mdesc)
{
	return ((void *) node_block(mdesc)) + mdesc->node_sz;
}

static void *data_block(struct mdesc_hdr *mdesc)
{
	return ((void *) name_block(mdesc)) + mdesc->name_sz;
}

u64 mdesc_node_by_name(struct mdesc_handle *hp,
		       u64 from_node, const char *name)
{
	struct mdesc_elem *ep = node_block(&hp->mdesc);
	const char *names = name_block(&hp->mdesc);
	u64 last_node = hp->mdesc.node_sz / 16;
	u64 ret;

	if (from_node == MDESC_NODE_NULL)
		from_node = 0;

	if (from_node >= last_node)
		return MDESC_NODE_NULL;

	ret = ep[from_node].d.val;
	while (ret < last_node) {
		if (ep[ret].tag != MD_NODE)
			return MDESC_NODE_NULL;
		if (!strcmp(names + ep[ret].name_offset, name))
			break;
		ret = ep[ret].d.val;
	}
	if (ret >= last_node)
		ret = MDESC_NODE_NULL;
	return ret;
}
EXPORT_SYMBOL(mdesc_node_by_name);

const void *mdesc_get_property(struct mdesc_handle *hp, u64 node,
			       const char *name, int *lenp)
{
	const char *names = name_block(&hp->mdesc);
	u64 last_node = hp->mdesc.node_sz / 16;
	void *data = data_block(&hp->mdesc);
	struct mdesc_elem *ep;

	if (node == MDESC_NODE_NULL || node >= last_node)
		return NULL;

	ep = node_block(&hp->mdesc) + node;
	ep++;
	for (; ep->tag != MD_NODE_END; ep++) {
		void *val = NULL;
		int len = 0;

		switch (ep->tag) {
		case MD_PROP_VAL:
			val = &ep->d.val;
			len = 8;
			break;

		case MD_PROP_STR:
		case MD_PROP_DATA:
			val = data + ep->d.data.data_offset;
			len = ep->d.data.data_len;
			break;

		default:
			break;
		}
		if (!val)
			continue;

		if (!strcmp(names + ep->name_offset, name)) {
			if (lenp)
				*lenp = len;
			return val;
		}
	}

	return NULL;
}
EXPORT_SYMBOL(mdesc_get_property);

u64 mdesc_next_arc(struct mdesc_handle *hp, u64 from, const char *arc_type)
{
	struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
	const char *names = name_block(&hp->mdesc);
	u64 last_node = hp->mdesc.node_sz / 16;

	if (from == MDESC_NODE_NULL || from >= last_node)
		return MDESC_NODE_NULL;

	ep = base + from;

	ep++;
	for (; ep->tag != MD_NODE_END; ep++) {
		if (ep->tag != MD_PROP_ARC)
			continue;

		if (strcmp(names + ep->name_offset, arc_type))
			continue;

		return ep - base;
	}

	return MDESC_NODE_NULL;
}
EXPORT_SYMBOL(mdesc_next_arc);

u64 mdesc_arc_target(struct mdesc_handle *hp, u64 arc)
{
	struct mdesc_elem *ep, *base = node_block(&hp->mdesc);

	ep = base + arc;

	return ep->d.val;
}
EXPORT_SYMBOL(mdesc_arc_target);

const char *mdesc_node_name(struct mdesc_handle *hp, u64 node)
{
	struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
	const char *names = name_block(&hp->mdesc);
	u64 last_node = hp->mdesc.node_sz / 16;

	if (node == MDESC_NODE_NULL || node >= last_node)
		return NULL;

	ep = base + node;
	if (ep->tag != MD_NODE)
		return NULL;

	return names + ep->name_offset;
}
EXPORT_SYMBOL(mdesc_node_name);

static void __init report_platform_properties(void)
{
	struct mdesc_handle *hp = mdesc_grab();
	u64 pn = mdesc_node_by_name(hp, MDESC_NODE_NULL, "platform");
	const char *s;
	const u64 *v;

	if (pn == MDESC_NODE_NULL) {
		prom_printf("No platform node in machine-description.\n");
		prom_halt();
	}

	s = mdesc_get_property(hp, pn, "banner-name", NULL);
	printk("PLATFORM: banner-name [%s]\n", s);
	s = mdesc_get_property(hp, pn, "name", NULL);
	printk("PLATFORM: name [%s]\n", s);

	v = mdesc_get_property(hp, pn, "hostid", NULL);
	if (v)
		printk("PLATFORM: hostid [%08lx]\n", *v);
	v = mdesc_get_property(hp, pn, "serial#", NULL);
	if (v)
		printk("PLATFORM: serial# [%08lx]\n", *v);
	v = mdesc_get_property(hp, pn, "stick-frequency", NULL);
	printk("PLATFORM: stick-frequency [%08lx]\n", *v);
	v = mdesc_get_property(hp, pn, "mac-address", NULL);
	if (v)
		printk("PLATFORM: mac-address [%lx]\n", *v);
	v = mdesc_get_property(hp, pn, "watchdog-resolution", NULL);
	if (v)
		printk("PLATFORM: watchdog-resolution [%lu ms]\n", *v);
	v = mdesc_get_property(hp, pn, "watchdog-max-timeout", NULL);
	if (v)
		printk("PLATFORM: watchdog-max-timeout [%lu ms]\n", *v);
	v = mdesc_get_property(hp, pn, "max-cpus", NULL);
	if (v)
		printk("PLATFORM: max-cpus [%lu]\n", *v);

	mdesc_release(hp);
}

static int inline find_in_proplist(const char *list, const char *match, int len)
{
	while (len > 0) {
		int l;

		if (!strcmp(list, match))
			return 1;
		l = strlen(list) + 1;
		list += l;
		len -= l;
	}
	return 0;
}

static void __init fill_in_one_cache(cpuinfo_sparc *c,
				     struct mdesc_handle *hp,
				     u64 mp)
{
	const u64 *level = mdesc_get_property(hp, mp, "level", NULL);
	const u64 *size = mdesc_get_property(hp, mp, "size", NULL);
	const u64 *line_size = mdesc_get_property(hp, mp, "line-size", NULL);
	const char *type;
	int type_len;

	type = mdesc_get_property(hp, mp, "type", &type_len);

	switch (*level) {
	case 1:
		if (find_in_proplist(type, "instn", type_len)) {
			c->icache_size = *size;
			c->icache_line_size = *line_size;
		} else if (find_in_proplist(type, "data", type_len)) {
			c->dcache_size = *size;
			c->dcache_line_size = *line_size;
		}
		break;

	case 2:
		c->ecache_size = *size;
		c->ecache_line_size = *line_size;
		break;

	default:
		break;
	}

	if (*level == 1) {
		u64 a;

		mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
			u64 target = mdesc_arc_target(hp, a);
			const char *name = mdesc_node_name(hp, target);

			if (!strcmp(name, "cache"))
				fill_in_one_cache(c, hp, target);
		}
	}
}

static void __init mark_core_ids(struct mdesc_handle *hp, u64 mp, int core_id)
{
	u64 a;

	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) {
		u64 t = mdesc_arc_target(hp, a);
		const char *name;
		const u64 *id;

		name = mdesc_node_name(hp, t);
		if (!strcmp(name, "cpu")) {
			id = mdesc_get_property(hp, t, "id", NULL);
			if (*id < NR_CPUS)
				cpu_data(*id).core_id = core_id;
		} else {
			u64 j;

			mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_BACK) {
				u64 n = mdesc_arc_target(hp, j);
				const char *n_name;

				n_name = mdesc_node_name(hp, n);
				if (strcmp(n_name, "cpu"))
					continue;

				id = mdesc_get_property(hp, n, "id", NULL);
				if (*id < NR_CPUS)
					cpu_data(*id).core_id = core_id;
			}
		}
	}
}

static void __init set_core_ids(struct mdesc_handle *hp)
{
	int idx;
	u64 mp;

	idx = 1;
	mdesc_for_each_node_by_name(hp, mp, "cache") {
		const u64 *level;
		const char *type;
		int len;

		level = mdesc_get_property(hp, mp, "level", NULL);
		if (*level != 1)
			continue;

		type = mdesc_get_property(hp, mp, "type", &len);
		if (!find_in_proplist(type, "instn", len))
			continue;

		mark_core_ids(hp, mp, idx);

		idx++;
	}
}

static void __init mark_proc_ids(struct mdesc_handle *hp, u64 mp, int proc_id)
{
	u64 a;

	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) {
		u64 t = mdesc_arc_target(hp, a);
		const char *name;
		const u64 *id;

		name = mdesc_node_name(hp, t);
		if (strcmp(name, "cpu"))
			continue;

		id = mdesc_get_property(hp, t, "id", NULL);
		if (*id < NR_CPUS)
			cpu_data(*id).proc_id = proc_id;
	}
}

static void __init __set_proc_ids(struct mdesc_handle *hp,
				  const char *exec_unit_name)
{
	int idx;
	u64 mp;

	idx = 0;
	mdesc_for_each_node_by_name(hp, mp, exec_unit_name) {
		const char *type;
		int len;

		type = mdesc_get_property(hp, mp, "type", &len);
		if (!find_in_proplist(type, "int", len) &&
		    !find_in_proplist(type, "integer", len))
			continue;

		mark_proc_ids(hp, mp, idx);

		idx++;
	}
}

static void __init set_proc_ids(struct mdesc_handle *hp)
{
	__set_proc_ids(hp, "exec_unit");
	__set_proc_ids(hp, "exec-unit");
}

static void __init get_one_mondo_bits(const u64 *p, unsigned int *mask, unsigned char def)
{
	u64 val;

	if (!p)
		goto use_default;
	val = *p;

	if (!val || val >= 64)
		goto use_default;

	*mask = ((1U << val) * 64U) - 1U;
	return;

use_default:
	*mask = ((1U << def) * 64U) - 1U;
}

static void __init get_mondo_data(struct mdesc_handle *hp, u64 mp,
				  struct trap_per_cpu *tb)
{
	const u64 *val;

	val = mdesc_get_property(hp, mp, "q-cpu-mondo-#bits", NULL);
	get_one_mondo_bits(val, &tb->cpu_mondo_qmask, 7);

	val = mdesc_get_property(hp, mp, "q-dev-mondo-#bits", NULL);
	get_one_mondo_bits(val, &tb->dev_mondo_qmask, 7);

	val = mdesc_get_property(hp, mp, "q-resumable-#bits", NULL);
	get_one_mondo_bits(val, &tb->resum_qmask, 6);

	val = mdesc_get_property(hp, mp, "q-nonresumable-#bits", NULL);
	get_one_mondo_bits(val, &tb->nonresum_qmask, 2);
}

static void __init mdesc_fill_in_cpu_data(void)
{
	struct mdesc_handle *hp = mdesc_grab();
	u64 mp;

	ncpus_probed = 0;
	mdesc_for_each_node_by_name(hp, mp, "cpu") {
		const u64 *id = mdesc_get_property(hp, mp, "id", NULL);
		const u64 *cfreq = mdesc_get_property(hp, mp, "clock-frequency", NULL);
		struct trap_per_cpu *tb;
		cpuinfo_sparc *c;
		int cpuid;
		u64 a;

		ncpus_probed++;

		cpuid = *id;

#ifdef CONFIG_SMP
		if (cpuid >= NR_CPUS)
			continue;
#else
		/* On uniprocessor we only want the values for the
		 * real physical cpu the kernel booted onto, however
		 * cpu_data() only has one entry at index 0.
		 */
		if (cpuid != real_hard_smp_processor_id())
			continue;
		cpuid = 0;
#endif

		c = &cpu_data(cpuid);
		c->clock_tick = *cfreq;

		tb = &trap_block[cpuid];
		get_mondo_data(hp, mp, tb);

		mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
			u64 j, t = mdesc_arc_target(hp, a);
			const char *t_name;

			t_name = mdesc_node_name(hp, t);
			if (!strcmp(t_name, "cache")) {
				fill_in_one_cache(c, hp, t);
				continue;
			}

			mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_FWD) {
				u64 n = mdesc_arc_target(hp, j);
				const char *n_name;

				n_name = mdesc_node_name(hp, n);
				if (!strcmp(n_name, "cache"))
					fill_in_one_cache(c, hp, n);
			}
		}

#ifdef CONFIG_SMP
		cpu_set(cpuid, cpu_present_map);
		cpu_set(cpuid, phys_cpu_present_map);
#endif

		c->core_id = 0;
		c->proc_id = -1;
	}

#ifdef CONFIG_SMP
	sparc64_multi_core = 1;
#endif

	set_core_ids(hp);
	set_proc_ids(hp);

	smp_fill_in_sib_core_maps();

	mdesc_release(hp);
}

void __init sun4v_mdesc_init(void)
{
	struct mdesc_handle *hp;
	unsigned long len, real_len, status;

	(void) sun4v_mach_desc(0UL, 0UL, &len);

	printk("MDESC: Size is %lu bytes.\n", len);

	hp = mdesc_alloc(len, &bootmem_mdesc_memops);
	if (hp == NULL) {
		prom_printf("MDESC: alloc of %lu bytes failed.\n", len);
		prom_halt();
	}

	status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
	if (status != HV_EOK || real_len > len) {
		prom_printf("sun4v_mach_desc fails, err(%lu), "
			    "len(%lu), real_len(%lu)\n",
			    status, len, real_len);
		mdesc_free(hp);
		prom_halt();
	}

	cur_mdesc = hp;

	report_platform_properties();
	mdesc_fill_in_cpu_data();
}
Commit	Line	Data
5cbc3073 DM	1	/* mdesc.c: Sun4V machine description handling.
	2	*
	3	* Copyright (C) 2007 David S. Miller <davem@davemloft.net>
	4	*/
	5	#include <linux/kernel.h>
	6	#include <linux/types.h>
	7	#include <linux/bootmem.h>
	8	#include <linux/log2.h>
43fdf274 DM	9	#include <linux/list.h>
43fdf274 DM	10	#include <linux/slab.h>
5cbc3073 DM	11
	12	#include <asm/hypervisor.h>
	13	#include <asm/mdesc.h>
	14	#include <asm/prom.h>
	15	#include <asm/oplib.h>
	16	#include <asm/smp.h>
	17
	18	/* Unlike the OBP device tree, the machine description is a full-on
	19	* DAG. An arbitrary number of ARCs are possible from one
	20	* node to other nodes and thus we can't use the OBP device_node
	21	* data structure to represent these nodes inside of the kernel.
	22	*
	23	* Actually, it isn't even a DAG, because there are back pointers
	24	* which create cycles in the graph.
	25	*
	26	* mdesc_hdr and mdesc_elem describe the layout of the data structure
	27	* we get from the Hypervisor.
	28	*/
	29	struct mdesc_hdr {
	30	u32 version; /* Transport version */
	31	u32 node_sz; /* node block size */
	32	u32 name_sz; /* name block size */
	33	u32 data_sz; /* data block size */
43fdf274	34	} __attribute__((aligned(16)));
5cbc3073 DM	35
	36	struct mdesc_elem {
	37	u8 tag;
	38	#define MD_LIST_END 0x00
	39	#define MD_NODE 0x4e
	40	#define MD_NODE_END 0x45
	41	#define MD_NOOP 0x20
	42	#define MD_PROP_ARC 0x61
	43	#define MD_PROP_VAL 0x76
	44	#define MD_PROP_STR 0x73
	45	#define MD_PROP_DATA 0x64
	46	u8 name_len;
	47	u16 resv;
	48	u32 name_offset;
	49	union {
	50	struct {
	51	u32 data_len;
	52	u32 data_offset;
	53	} data;
	54	u64 val;
	55	} d;
	56	};
	57
43fdf274 DM	58	struct mdesc_mem_ops {
	59	struct mdesc_handle (alloc)(unsigned int mdesc_size);
	60	void (free)(struct mdesc_handle handle);
	61	};
5cbc3073	62
43fdf274 DM	63	struct mdesc_handle {
	64	struct list_head list;
	65	struct mdesc_mem_ops *mops;
	66	void *self_base;
	67	atomic_t refcnt;
	68	unsigned int handle_size;
	69	struct mdesc_hdr mdesc;
	70	};
5cbc3073	71
43fdf274 DM	72	static void mdesc_handle_init(struct mdesc_handle *hp,
	73	unsigned int handle_size,
	74	void *base)
5cbc3073	75	{
43fdf274 DM	76	BUG_ON(((unsigned long)&hp->mdesc) & (16UL - 1));
	77
	78	memset(hp, 0, handle_size);
	79	INIT_LIST_HEAD(&hp->list);
	80	hp->self_base = base;
	81	atomic_set(&hp->refcnt, 1);
	82	hp->handle_size = handle_size;
5cbc3073 DM	83	}
5cbc3073 DM	84
43fdf274	85	static struct mdesc_handle *mdesc_bootmem_alloc(unsigned int mdesc_size)
5cbc3073	86	{
43fdf274 DM	87	struct mdesc_handle *hp;
43fdf274 DM	88	unsigned int handle_size, alloc_size;
5cbc3073	89
43fdf274 DM	90	handle_size = (sizeof(struct mdesc_handle) -
	91	sizeof(struct mdesc_hdr) +
	92	mdesc_size);
	93	alloc_size = PAGE_ALIGN(handle_size);
5cbc3073	94
43fdf274 DM	95	hp = __alloc_bootmem(alloc_size, PAGE_SIZE, 0UL);
	96	if (hp)
	97	mdesc_handle_init(hp, handle_size, hp);
	98
	99	return hp;
5cbc3073 DM	100	}
5cbc3073 DM	101
43fdf274	102	static void mdesc_bootmem_free(struct mdesc_handle *hp)
5cbc3073	103	{
43fdf274 DM	104	unsigned int alloc_size, handle_size = hp->handle_size;
43fdf274 DM	105	unsigned long start, end;
5cbc3073	106
43fdf274 DM	107	BUG_ON(atomic_read(&hp->refcnt) != 0);
43fdf274 DM	108	BUG_ON(!list_empty(&hp->list));
5cbc3073	109
43fdf274 DM	110	alloc_size = PAGE_ALIGN(handle_size);
	111
	112	start = (unsigned long) hp;
	113	end = start + alloc_size;
	114
	115	while (start < end) {
	116	struct page *p;
	117
	118	p = virt_to_page(start);
	119	ClearPageReserved(p);
	120	__free_page(p);
	121	start += PAGE_SIZE;
5cbc3073	122	}
5cbc3073 DM	123	}
5cbc3073 DM	124
43fdf274 DM	125	static struct mdesc_mem_ops bootmem_mdesc_memops = {
	126	.alloc = mdesc_bootmem_alloc,
	127	.free = mdesc_bootmem_free,
	128	};
	129
	130	static struct mdesc_handle *mdesc_kmalloc(unsigned int mdesc_size)
5cbc3073	131	{
43fdf274 DM	132	unsigned int handle_size;
43fdf274 DM	133	void *base;
5cbc3073	134
43fdf274 DM	135	handle_size = (sizeof(struct mdesc_handle) -
	136	sizeof(struct mdesc_hdr) +
	137	mdesc_size);
	138
	139	base = kmalloc(handle_size + 15, GFP_KERNEL);
	140	if (base) {
	141	struct mdesc_handle *hp;
	142	unsigned long addr;
	143
	144	addr = (unsigned long)base;
	145	addr = (addr + 15UL) & ~15UL;
	146	hp = (struct mdesc_handle *) addr;
	147
	148	mdesc_handle_init(hp, handle_size, base);
	149	return hp;
5cbc3073	150	}
43fdf274 DM	151
43fdf274 DM	152	return NULL;
5cbc3073	153	}
5cbc3073	154
43fdf274	155	static void mdesc_kfree(struct mdesc_handle *hp)
5cbc3073	156	{
43fdf274 DM	157	BUG_ON(atomic_read(&hp->refcnt) != 0);
	158	BUG_ON(!list_empty(&hp->list));
	159
	160	kfree(hp->self_base);
5cbc3073	161	}
5cbc3073	162
43fdf274 DM	163	static struct mdesc_mem_ops kmalloc_mdesc_memops = {
	164	.alloc = mdesc_kmalloc,
	165	.free = mdesc_kfree,
	166	};
	167
	168	static struct mdesc_handle *mdesc_alloc(unsigned int mdesc_size,
	169	struct mdesc_mem_ops *mops)
5cbc3073	170	{
43fdf274	171	struct mdesc_handle *hp = mops->alloc(mdesc_size);
5cbc3073	172
43fdf274 DM	173	if (hp)
43fdf274 DM	174	hp->mops = mops;
5cbc3073	175
43fdf274 DM	176	return hp;
43fdf274 DM	177	}
5cbc3073	178
43fdf274	179	static void mdesc_free(struct mdesc_handle *hp)
5cbc3073	180	{
43fdf274 DM	181	hp->mops->free(hp);
43fdf274 DM	182	}
5cbc3073	183
43fdf274 DM	184	static struct mdesc_handle *cur_mdesc;
	185	static LIST_HEAD(mdesc_zombie_list);
	186	static DEFINE_SPINLOCK(mdesc_lock);
5cbc3073	187
43fdf274 DM	188	struct mdesc_handle *mdesc_grab(void)
	189	{
	190	struct mdesc_handle *hp;
	191	unsigned long flags;
5cbc3073	192
43fdf274 DM	193	spin_lock_irqsave(&mdesc_lock, flags);
	194	hp = cur_mdesc;
	195	if (hp)
	196	atomic_inc(&hp->refcnt);
	197	spin_unlock_irqrestore(&mdesc_lock, flags);
5cbc3073	198
43fdf274	199	return hp;
5cbc3073	200	}
43fdf274	201	EXPORT_SYMBOL(mdesc_grab);
5cbc3073	202
43fdf274	203	void mdesc_release(struct mdesc_handle *hp)
5cbc3073	204	{
43fdf274	205	unsigned long flags;
5cbc3073	206
43fdf274 DM	207	spin_lock_irqsave(&mdesc_lock, flags);
	208	if (atomic_dec_and_test(&hp->refcnt)) {
	209	list_del_init(&hp->list);
	210	hp->mops->free(hp);
5cbc3073	211	}
43fdf274	212	spin_unlock_irqrestore(&mdesc_lock, flags);
5cbc3073	213	}
43fdf274	214	EXPORT_SYMBOL(mdesc_release);
5cbc3073	215
43fdf274	216	static void do_mdesc_update(struct work_struct *work)
5cbc3073	217	{
43fdf274 DM	218	unsigned long len, real_len, status;
	219	struct mdesc_handle hp, orig_hp;
	220	unsigned long flags;
	221
	222	(void) sun4v_mach_desc(0UL, 0UL, &len);
	223
	224	hp = mdesc_alloc(len, &kmalloc_mdesc_memops);
	225	if (!hp) {
	226	printk(KERN_ERR "MD: mdesc alloc fails\n");
	227	return;
	228	}
	229
	230	status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
	231	if (status != HV_EOK \|\| real_len > len) {
	232	printk(KERN_ERR "MD: mdesc reread fails with %lu\n",
	233	status);
	234	atomic_dec(&hp->refcnt);
	235	mdesc_free(hp);
	236	return;
	237	}
5cbc3073	238
43fdf274 DM	239	spin_lock_irqsave(&mdesc_lock, flags);
	240	orig_hp = cur_mdesc;
	241	cur_mdesc = hp;
5cbc3073	242
43fdf274 DM	243	if (atomic_dec_and_test(&orig_hp->refcnt))
	244	mdesc_free(orig_hp);
	245	else
	246	list_add(&orig_hp->list, &mdesc_zombie_list);
	247	spin_unlock_irqrestore(&mdesc_lock, flags);
5cbc3073 DM	248	}
5cbc3073 DM	249
43fdf274 DM	250	static DECLARE_WORK(mdesc_update_work, do_mdesc_update);
	251
	252	void mdesc_update(void)
	253	{
	254	schedule_work(&mdesc_update_work);
	255	}
	256
	257	static struct mdesc_elem node_block(struct mdesc_hdr mdesc)
5cbc3073 DM	258	{
	259	return (struct mdesc_elem *) (mdesc + 1);
	260	}
	261
43fdf274	262	static void name_block(struct mdesc_hdr mdesc)
5cbc3073 DM	263	{
	264	return ((void *) node_block(mdesc)) + mdesc->node_sz;
	265	}
	266
43fdf274	267	static void data_block(struct mdesc_hdr mdesc)
5cbc3073 DM	268	{
	269	return ((void *) name_block(mdesc)) + mdesc->name_sz;
	270	}
	271
43fdf274 DM	272	u64 mdesc_node_by_name(struct mdesc_handle *hp,
43fdf274 DM	273	u64 from_node, const char *name)
5cbc3073	274	{
43fdf274 DM	275	struct mdesc_elem *ep = node_block(&hp->mdesc);
	276	const char *names = name_block(&hp->mdesc);
	277	u64 last_node = hp->mdesc.node_sz / 16;
	278	u64 ret;
	279
	280	if (from_node == MDESC_NODE_NULL)
	281	from_node = 0;
	282
	283	if (from_node >= last_node)
	284	return MDESC_NODE_NULL;
	285
	286	ret = ep[from_node].d.val;
	287	while (ret < last_node) {
	288	if (ep[ret].tag != MD_NODE)
	289	return MDESC_NODE_NULL;
	290	if (!strcmp(names + ep[ret].name_offset, name))
	291	break;
	292	ret = ep[ret].d.val;
	293	}
	294	if (ret >= last_node)
	295	ret = MDESC_NODE_NULL;
	296	return ret;
	297	}
	298	EXPORT_SYMBOL(mdesc_node_by_name);
5cbc3073	299
43fdf274 DM	300	const void mdesc_get_property(struct mdesc_handle hp, u64 node,
	301	const char name, int lenp)
	302	{
	303	const char *names = name_block(&hp->mdesc);
	304	u64 last_node = hp->mdesc.node_sz / 16;
	305	void *data = data_block(&hp->mdesc);
	306	struct mdesc_elem *ep;
5cbc3073	307
43fdf274 DM	308	if (node == MDESC_NODE_NULL \|\| node >= last_node)
43fdf274 DM	309	return NULL;
5cbc3073	310
43fdf274 DM	311	ep = node_block(&hp->mdesc) + node;
	312	ep++;
	313	for (; ep->tag != MD_NODE_END; ep++) {
	314	void *val = NULL;
	315	int len = 0;
	316
	317	switch (ep->tag) {
	318	case MD_PROP_VAL:
	319	val = &ep->d.val;
	320	len = 8;
5cbc3073 DM	321	break;
5cbc3073 DM	322
43fdf274 DM	323	case MD_PROP_STR:
	324	case MD_PROP_DATA:
	325	val = data + ep->d.data.data_offset;
	326	len = ep->d.data.data_len;
	327	break;
5cbc3073	328
43fdf274	329	default:
5cbc3073 DM	330	break;
5cbc3073 DM	331	}
43fdf274 DM	332	if (!val)
43fdf274 DM	333	continue;
5cbc3073	334
43fdf274 DM	335	if (!strcmp(names + ep->name_offset, name)) {
	336	if (lenp)
	337	*lenp = len;
	338	return val;
	339	}
5cbc3073 DM	340	}
5cbc3073 DM	341
43fdf274 DM	342	return NULL;
	343	}
	344	EXPORT_SYMBOL(mdesc_get_property);
5cbc3073	345
43fdf274 DM	346	u64 mdesc_next_arc(struct mdesc_handle hp, u64 from, const char arc_type)
	347	{
	348	struct mdesc_elem ep, base = node_block(&hp->mdesc);
	349	const char *names = name_block(&hp->mdesc);
	350	u64 last_node = hp->mdesc.node_sz / 16;
5cbc3073	351
43fdf274 DM	352	if (from == MDESC_NODE_NULL \|\| from >= last_node)
43fdf274 DM	353	return MDESC_NODE_NULL;
5cbc3073	354
43fdf274 DM	355	ep = base + from;
	356
	357	ep++;
	358	for (; ep->tag != MD_NODE_END; ep++) {
	359	if (ep->tag != MD_PROP_ARC)
	360	continue;
	361
	362	if (strcmp(names + ep->name_offset, arc_type))
	363	continue;
	364
	365	return ep - base;
5cbc3073	366	}
43fdf274 DM	367
43fdf274 DM	368	return MDESC_NODE_NULL;
5cbc3073	369	}
43fdf274	370	EXPORT_SYMBOL(mdesc_next_arc);
5cbc3073	371
43fdf274	372	u64 mdesc_arc_target(struct mdesc_handle *hp, u64 arc)
5cbc3073	373	{
43fdf274 DM	374	struct mdesc_elem ep, base = node_block(&hp->mdesc);
	375
	376	ep = base + arc;
	377
	378	return ep->d.val;
5cbc3073	379	}
43fdf274 DM	380	EXPORT_SYMBOL(mdesc_arc_target);
	381
	382	const char mdesc_node_name(struct mdesc_handle hp, u64 node)
	383	{
	384	struct mdesc_elem ep, base = node_block(&hp->mdesc);
	385	const char *names = name_block(&hp->mdesc);
	386	u64 last_node = hp->mdesc.node_sz / 16;
	387
	388	if (node == MDESC_NODE_NULL \|\| node >= last_node)
	389	return NULL;
	390
	391	ep = base + node;
	392	if (ep->tag != MD_NODE)
	393	return NULL;
	394
	395	return names + ep->name_offset;
	396	}
	397	EXPORT_SYMBOL(mdesc_node_name);
5cbc3073 DM	398
	399	static void __init report_platform_properties(void)
	400	{
43fdf274 DM	401	struct mdesc_handle *hp = mdesc_grab();
43fdf274 DM	402	u64 pn = mdesc_node_by_name(hp, MDESC_NODE_NULL, "platform");
5cbc3073 DM	403	const char *s;
	404	const u64 *v;
	405
43fdf274	406	if (pn == MDESC_NODE_NULL) {
5cbc3073 DM	407	prom_printf("No platform node in machine-description.\n");
	408	prom_halt();
	409	}
	410
43fdf274	411	s = mdesc_get_property(hp, pn, "banner-name", NULL);
5cbc3073	412	printk("PLATFORM: banner-name [%s]\n", s);
43fdf274	413	s = mdesc_get_property(hp, pn, "name", NULL);
5cbc3073 DM	414	printk("PLATFORM: name [%s]\n", s);
5cbc3073 DM	415
43fdf274	416	v = mdesc_get_property(hp, pn, "hostid", NULL);
5cbc3073 DM	417	if (v)
5cbc3073 DM	418	printk("PLATFORM: hostid [%08lx]\n", *v);
43fdf274	419	v = mdesc_get_property(hp, pn, "serial#", NULL);
5cbc3073 DM	420	if (v)
5cbc3073 DM	421	printk("PLATFORM: serial# [%08lx]\n", *v);
43fdf274	422	v = mdesc_get_property(hp, pn, "stick-frequency", NULL);
5cbc3073	423	printk("PLATFORM: stick-frequency [%08lx]\n", *v);
43fdf274	424	v = mdesc_get_property(hp, pn, "mac-address", NULL);
5cbc3073 DM	425	if (v)
5cbc3073 DM	426	printk("PLATFORM: mac-address [%lx]\n", *v);
43fdf274	427	v = mdesc_get_property(hp, pn, "watchdog-resolution", NULL);
5cbc3073 DM	428	if (v)
5cbc3073 DM	429	printk("PLATFORM: watchdog-resolution [%lu ms]\n", *v);
43fdf274	430	v = mdesc_get_property(hp, pn, "watchdog-max-timeout", NULL);
5cbc3073 DM	431	if (v)
5cbc3073 DM	432	printk("PLATFORM: watchdog-max-timeout [%lu ms]\n", *v);
43fdf274	433	v = mdesc_get_property(hp, pn, "max-cpus", NULL);
5cbc3073 DM	434	if (v)
5cbc3073 DM	435	printk("PLATFORM: max-cpus [%lu]\n", *v);
43fdf274 DM	436
43fdf274 DM	437	mdesc_release(hp);
5cbc3073 DM	438	}
	439
	440	static int inline find_in_proplist(const char list, const char match, int len)
	441	{
	442	while (len > 0) {
	443	int l;
	444
	445	if (!strcmp(list, match))
	446	return 1;
	447	l = strlen(list) + 1;
	448	list += l;
	449	len -= l;
	450	}
	451	return 0;
	452	}
	453
43fdf274 DM	454	static void __init fill_in_one_cache(cpuinfo_sparc *c,
	455	struct mdesc_handle *hp,
	456	u64 mp)
5cbc3073	457	{
43fdf274 DM	458	const u64 *level = mdesc_get_property(hp, mp, "level", NULL);
	459	const u64 *size = mdesc_get_property(hp, mp, "size", NULL);
	460	const u64 *line_size = mdesc_get_property(hp, mp, "line-size", NULL);
5cbc3073 DM	461	const char *type;
	462	int type_len;
	463
43fdf274	464	type = mdesc_get_property(hp, mp, "type", &type_len);
5cbc3073 DM	465
	466	switch (*level) {
	467	case 1:
	468	if (find_in_proplist(type, "instn", type_len)) {
	469	c->icache_size = *size;
	470	c->icache_line_size = *line_size;
	471	} else if (find_in_proplist(type, "data", type_len)) {
	472	c->dcache_size = *size;
	473	c->dcache_line_size = *line_size;
	474	}
	475	break;
	476
	477	case 2:
	478	c->ecache_size = *size;
	479	c->ecache_line_size = *line_size;
	480	break;
	481
	482	default:
	483	break;
	484	}
	485
	486	if (*level == 1) {
43fdf274	487	u64 a;
5cbc3073	488
43fdf274 DM	489	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
	490	u64 target = mdesc_arc_target(hp, a);
	491	const char *name = mdesc_node_name(hp, target);
5cbc3073	492
43fdf274 DM	493	if (!strcmp(name, "cache"))
43fdf274 DM	494	fill_in_one_cache(c, hp, target);
5cbc3073 DM	495	}
	496	}
	497	}
	498
43fdf274	499	static void __init mark_core_ids(struct mdesc_handle *hp, u64 mp, int core_id)
5cbc3073	500	{
43fdf274	501	u64 a;
5cbc3073	502
43fdf274 DM	503	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) {
	504	u64 t = mdesc_arc_target(hp, a);
	505	const char *name;
5cbc3073 DM	506	const u64 *id;
5cbc3073 DM	507
43fdf274 DM	508	name = mdesc_node_name(hp, t);
	509	if (!strcmp(name, "cpu")) {
	510	id = mdesc_get_property(hp, t, "id", NULL);
5cbc3073 DM	511	if (*id < NR_CPUS)
	512	cpu_data(*id).core_id = core_id;
	513	} else {
43fdf274	514	u64 j;
5cbc3073	515
43fdf274 DM	516	mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_BACK) {
	517	u64 n = mdesc_arc_target(hp, j);
	518	const char *n_name;
5cbc3073	519
43fdf274 DM	520	n_name = mdesc_node_name(hp, n);
43fdf274 DM	521	if (strcmp(n_name, "cpu"))
5cbc3073 DM	522	continue;
5cbc3073 DM	523
43fdf274	524	id = mdesc_get_property(hp, n, "id", NULL);
5cbc3073 DM	525	if (*id < NR_CPUS)
	526	cpu_data(*id).core_id = core_id;
	527	}
	528	}
	529	}
	530	}
	531
43fdf274	532	static void __init set_core_ids(struct mdesc_handle *hp)
5cbc3073	533	{
5cbc3073	534	int idx;
43fdf274	535	u64 mp;
5cbc3073 DM	536
5cbc3073 DM	537	idx = 1;
43fdf274 DM	538	mdesc_for_each_node_by_name(hp, mp, "cache") {
43fdf274 DM	539	const u64 *level;
5cbc3073 DM	540	const char *type;
	541	int len;
	542
43fdf274	543	level = mdesc_get_property(hp, mp, "level", NULL);
5cbc3073 DM	544	if (*level != 1)
	545	continue;
	546
43fdf274	547	type = mdesc_get_property(hp, mp, "type", &len);
5cbc3073 DM	548	if (!find_in_proplist(type, "instn", len))
	549	continue;
	550
43fdf274	551	mark_core_ids(hp, mp, idx);
5cbc3073 DM	552
	553	idx++;
	554	}
	555	}
	556
43fdf274	557	static void __init mark_proc_ids(struct mdesc_handle *hp, u64 mp, int proc_id)
f78eae2e	558	{
43fdf274	559	u64 a;
f78eae2e	560
43fdf274 DM	561	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) {
	562	u64 t = mdesc_arc_target(hp, a);
	563	const char *name;
f78eae2e DM	564	const u64 *id;
f78eae2e DM	565
43fdf274 DM	566	name = mdesc_node_name(hp, t);
43fdf274 DM	567	if (strcmp(name, "cpu"))
f78eae2e DM	568	continue;
f78eae2e DM	569
43fdf274	570	id = mdesc_get_property(hp, t, "id", NULL);
f78eae2e DM	571	if (*id < NR_CPUS)
	572	cpu_data(*id).proc_id = proc_id;
	573	}
	574	}
	575
43fdf274 DM	576	static void __init __set_proc_ids(struct mdesc_handle *hp,
43fdf274 DM	577	const char *exec_unit_name)
f78eae2e	578	{
f78eae2e	579	int idx;
43fdf274	580	u64 mp;
f78eae2e DM	581
f78eae2e DM	582	idx = 0;
43fdf274	583	mdesc_for_each_node_by_name(hp, mp, exec_unit_name) {
f78eae2e DM	584	const char *type;
	585	int len;
	586
43fdf274	587	type = mdesc_get_property(hp, mp, "type", &len);
f78eae2e DM	588	if (!find_in_proplist(type, "int", len) &&
	589	!find_in_proplist(type, "integer", len))
	590	continue;
	591
43fdf274	592	mark_proc_ids(hp, mp, idx);
f78eae2e DM	593
	594	idx++;
	595	}
	596	}
	597
43fdf274	598	static void __init set_proc_ids(struct mdesc_handle *hp)
f78eae2e	599	{
43fdf274 DM	600	__set_proc_ids(hp, "exec_unit");
43fdf274 DM	601	__set_proc_ids(hp, "exec-unit");
f78eae2e DM	602	}
f78eae2e DM	603
5cbc3073 DM	604	static void __init get_one_mondo_bits(const u64 p, unsigned int mask, unsigned char def)
	605	{
	606	u64 val;
	607
	608	if (!p)
	609	goto use_default;
	610	val = *p;
	611
	612	if (!val \|\| val >= 64)
	613	goto use_default;
	614
	615	mask = ((1U << val) 64U) - 1U;
	616	return;
	617
	618	use_default:
	619	mask = ((1U << def) 64U) - 1U;
	620	}
	621
43fdf274 DM	622	static void __init get_mondo_data(struct mdesc_handle *hp, u64 mp,
43fdf274 DM	623	struct trap_per_cpu *tb)
5cbc3073 DM	624	{
	625	const u64 *val;
	626
43fdf274	627	val = mdesc_get_property(hp, mp, "q-cpu-mondo-#bits", NULL);
5cbc3073 DM	628	get_one_mondo_bits(val, &tb->cpu_mondo_qmask, 7);
5cbc3073 DM	629
43fdf274	630	val = mdesc_get_property(hp, mp, "q-dev-mondo-#bits", NULL);
5cbc3073 DM	631	get_one_mondo_bits(val, &tb->dev_mondo_qmask, 7);
5cbc3073 DM	632
43fdf274	633	val = mdesc_get_property(hp, mp, "q-resumable-#bits", NULL);
5cbc3073 DM	634	get_one_mondo_bits(val, &tb->resum_qmask, 6);
5cbc3073 DM	635
43fdf274	636	val = mdesc_get_property(hp, mp, "q-nonresumable-#bits", NULL);
5cbc3073 DM	637	get_one_mondo_bits(val, &tb->nonresum_qmask, 2);
	638	}
	639
	640	static void __init mdesc_fill_in_cpu_data(void)
	641	{
43fdf274 DM	642	struct mdesc_handle *hp = mdesc_grab();
43fdf274 DM	643	u64 mp;
5cbc3073 DM	644
5cbc3073 DM	645	ncpus_probed = 0;
43fdf274 DM	646	mdesc_for_each_node_by_name(hp, mp, "cpu") {
	647	const u64 *id = mdesc_get_property(hp, mp, "id", NULL);
	648	const u64 *cfreq = mdesc_get_property(hp, mp, "clock-frequency", NULL);
5cbc3073 DM	649	struct trap_per_cpu *tb;
5cbc3073 DM	650	cpuinfo_sparc *c;
5cbc3073	651	int cpuid;
43fdf274	652	u64 a;
5cbc3073 DM	653
	654	ncpus_probed++;
	655
	656	cpuid = *id;
	657
	658	#ifdef CONFIG_SMP
	659	if (cpuid >= NR_CPUS)
	660	continue;
	661	#else
	662	/* On uniprocessor we only want the values for the
	663	* real physical cpu the kernel booted onto, however
	664	* cpu_data() only has one entry at index 0.
	665	*/
	666	if (cpuid != real_hard_smp_processor_id())
	667	continue;
	668	cpuid = 0;
	669	#endif
	670
	671	c = &cpu_data(cpuid);
	672	c->clock_tick = *cfreq;
	673
	674	tb = &trap_block[cpuid];
43fdf274	675	get_mondo_data(hp, mp, tb);
5cbc3073	676
43fdf274 DM	677	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
	678	u64 j, t = mdesc_arc_target(hp, a);
	679	const char *t_name;
5cbc3073	680
43fdf274 DM	681	t_name = mdesc_node_name(hp, t);
	682	if (!strcmp(t_name, "cache")) {
	683	fill_in_one_cache(c, hp, t);
5cbc3073 DM	684	continue;
	685	}
	686
43fdf274 DM	687	mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_FWD) {
	688	u64 n = mdesc_arc_target(hp, j);
	689	const char *n_name;
5cbc3073	690
43fdf274 DM	691	n_name = mdesc_node_name(hp, n);
	692	if (!strcmp(n_name, "cache"))
	693	fill_in_one_cache(c, hp, n);
5cbc3073 DM	694	}
	695	}
	696
	697	#ifdef CONFIG_SMP
	698	cpu_set(cpuid, cpu_present_map);
	699	cpu_set(cpuid, phys_cpu_present_map);
	700	#endif
	701
	702	c->core_id = 0;
f78eae2e	703	c->proc_id = -1;
5cbc3073 DM	704	}
5cbc3073 DM	705
a2f9f6bb DM	706	#ifdef CONFIG_SMP
	707	sparc64_multi_core = 1;
	708	#endif
	709
43fdf274 DM	710	set_core_ids(hp);
43fdf274 DM	711	set_proc_ids(hp);
5cbc3073 DM	712
5cbc3073 DM	713	smp_fill_in_sib_core_maps();
43fdf274 DM	714
43fdf274 DM	715	mdesc_release(hp);
5cbc3073 DM	716	}
	717
	718	void __init sun4v_mdesc_init(void)
	719	{
43fdf274	720	struct mdesc_handle *hp;
5cbc3073 DM	721	unsigned long len, real_len, status;
	722
	723	(void) sun4v_mach_desc(0UL, 0UL, &len);
	724
	725	printk("MDESC: Size is %lu bytes.\n", len);
	726
43fdf274 DM	727	hp = mdesc_alloc(len, &bootmem_mdesc_memops);
	728	if (hp == NULL) {
	729	prom_printf("MDESC: alloc of %lu bytes failed.\n", len);
	730	prom_halt();
	731	}
5cbc3073	732
43fdf274	733	status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
5cbc3073 DM	734	if (status != HV_EOK \|\| real_len > len) {
	735	prom_printf("sun4v_mach_desc fails, err(%lu), "
	736	"len(%lu), real_len(%lu)\n",
	737	status, len, real_len);
43fdf274	738	mdesc_free(hp);
5cbc3073 DM	739	prom_halt();
	740	}
	741
43fdf274	742	cur_mdesc = hp;
5cbc3073 DM	743
	744	report_platform_properties();
	745	mdesc_fill_in_cpu_data();
	746	}