[linux-block.git] / arch / ia64 / kernel / topology.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * This file contains NUMA specific variables and functions which are used on
 * NUMA machines with contiguous memory.
 * 		2002/08/07 Erich Focht <efocht@ess.nec.de>
 * Populate cpu entries in sysfs for non-numa systems as well
 *  	Intel Corporation - Ashok Raj
 * 02/27/2006 Zhang, Yanmin
 *	Populate cpu cache entries in sysfs for cpu cache info
 */

#include <linux/cpu.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/node.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/memblock.h>
#include <linux/nodemask.h>
#include <linux/notifier.h>
#include <linux/export.h>
#include <asm/mmzone.h>
#include <asm/numa.h>
#include <asm/cpu.h>

static struct ia64_cpu *sysfs_cpus;

void arch_fix_phys_package_id(int num, u32 slot)
{
#ifdef CONFIG_SMP
	if (cpu_data(num)->socket_id == -1)
		cpu_data(num)->socket_id = slot;
#endif
}
EXPORT_SYMBOL_GPL(arch_fix_phys_package_id);


#ifdef CONFIG_HOTPLUG_CPU
int __ref arch_register_cpu(int num)
{
	/*
	 * If CPEI can be re-targeted or if this is not
	 * CPEI target, then it is hotpluggable
	 */
	if (can_cpei_retarget() || !is_cpu_cpei_target(num))
		sysfs_cpus[num].cpu.hotpluggable = 1;
	map_cpu_to_node(num, node_cpuid[num].nid);
	return register_cpu(&sysfs_cpus[num].cpu, num);
}
EXPORT_SYMBOL(arch_register_cpu);

void __ref arch_unregister_cpu(int num)
{
	unregister_cpu(&sysfs_cpus[num].cpu);
	unmap_cpu_from_node(num, cpu_to_node(num));
}
EXPORT_SYMBOL(arch_unregister_cpu);
#else
int __init arch_register_cpu(int num)
{
	return register_cpu(&sysfs_cpus[num].cpu, num);
}
#endif /*CONFIG_HOTPLUG_CPU*/


static int __init topology_init(void)
{
	int i, err = 0;

	sysfs_cpus = kcalloc(NR_CPUS, sizeof(struct ia64_cpu), GFP_KERNEL);
	if (!sysfs_cpus)
		panic("kzalloc in topology_init failed - NR_CPUS too big?");

	for_each_present_cpu(i) {
		if((err = arch_register_cpu(i)))
			goto out;
	}
out:
	return err;
}

subsys_initcall(topology_init);


/*
 * Export cpu cache information through sysfs
 */

/*
 *  A bunch of string array to get pretty printing
 */
static const char *cache_types[] = {
	"",			/* not used */
	"Instruction",
	"Data",
	"Unified"	/* unified */
};

static const char *cache_mattrib[]={
	"WriteThrough",
	"WriteBack",
	"",		/* reserved */
	""		/* reserved */
};

struct cache_info {
	pal_cache_config_info_t	cci;
	cpumask_t shared_cpu_map;
	int level;
	int type;
	struct kobject kobj;
};

struct cpu_cache_info {
	struct cache_info *cache_leaves;
	int	num_cache_leaves;
	struct kobject kobj;
};

static struct cpu_cache_info	all_cpu_cache_info[NR_CPUS];
#define LEAF_KOBJECT_PTR(x,y)    (&all_cpu_cache_info[x].cache_leaves[y])

#ifdef CONFIG_SMP
static void cache_shared_cpu_map_setup(unsigned int cpu,
		struct cache_info * this_leaf)
{
	pal_cache_shared_info_t	csi;
	int num_shared, i = 0;
	unsigned int j;

	if (cpu_data(cpu)->threads_per_core <= 1 &&
		cpu_data(cpu)->cores_per_socket <= 1) {
		cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map);
		return;
	}

	if (ia64_pal_cache_shared_info(this_leaf->level,
					this_leaf->type,
					0,
					&csi) != PAL_STATUS_SUCCESS)
		return;

	num_shared = (int) csi.num_shared;
	do {
		for_each_possible_cpu(j)
			if (cpu_data(cpu)->socket_id == cpu_data(j)->socket_id
				&& cpu_data(j)->core_id == csi.log1_cid
				&& cpu_data(j)->thread_id == csi.log1_tid)
				cpumask_set_cpu(j, &this_leaf->shared_cpu_map);

		i++;
	} while (i < num_shared &&
		ia64_pal_cache_shared_info(this_leaf->level,
				this_leaf->type,
				i,
				&csi) == PAL_STATUS_SUCCESS);
}
#else
static void cache_shared_cpu_map_setup(unsigned int cpu,
		struct cache_info * this_leaf)
{
	cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map);
	return;
}
#endif

static ssize_t show_coherency_line_size(struct cache_info *this_leaf,
					char *buf)
{
	return sprintf(buf, "%u\n", 1 << this_leaf->cci.pcci_line_size);
}

static ssize_t show_ways_of_associativity(struct cache_info *this_leaf,
					char *buf)
{
	return sprintf(buf, "%u\n", this_leaf->cci.pcci_assoc);
}

static ssize_t show_attributes(struct cache_info *this_leaf, char *buf)
{
	return sprintf(buf,
			"%s\n",
			cache_mattrib[this_leaf->cci.pcci_cache_attr]);
}

static ssize_t show_size(struct cache_info *this_leaf, char *buf)
{
	return sprintf(buf, "%uK\n", this_leaf->cci.pcci_cache_size / 1024);
}

static ssize_t show_number_of_sets(struct cache_info *this_leaf, char *buf)
{
	unsigned number_of_sets = this_leaf->cci.pcci_cache_size;
	number_of_sets /= this_leaf->cci.pcci_assoc;
	number_of_sets /= 1 << this_leaf->cci.pcci_line_size;

	return sprintf(buf, "%u\n", number_of_sets);
}

static ssize_t show_shared_cpu_map(struct cache_info *this_leaf, char *buf)
{
	cpumask_t shared_cpu_map;

	cpumask_and(&shared_cpu_map,
				&this_leaf->shared_cpu_map, cpu_online_mask);
	return scnprintf(buf, PAGE_SIZE, "%*pb\n",
			 cpumask_pr_args(&shared_cpu_map));
}

static ssize_t show_type(struct cache_info *this_leaf, char *buf)
{
	int type = this_leaf->type + this_leaf->cci.pcci_unified;
	return sprintf(buf, "%s\n", cache_types[type]);
}

static ssize_t show_level(struct cache_info *this_leaf, char *buf)
{
	return sprintf(buf, "%u\n", this_leaf->level);
}

struct cache_attr {
	struct attribute attr;
	ssize_t (*show)(struct cache_info *, char *);
	ssize_t (*store)(struct cache_info *, const char *, size_t count);
};

#ifdef define_one_ro
	#undef define_one_ro
#endif
#define define_one_ro(_name) \
	static struct cache_attr _name = \
__ATTR(_name, 0444, show_##_name, NULL)

define_one_ro(level);
define_one_ro(type);
define_one_ro(coherency_line_size);
define_one_ro(ways_of_associativity);
define_one_ro(size);
define_one_ro(number_of_sets);
define_one_ro(shared_cpu_map);
define_one_ro(attributes);

static struct attribute * cache_default_attrs[] = {
	&type.attr,
	&level.attr,
	&coherency_line_size.attr,
	&ways_of_associativity.attr,
	&attributes.attr,
	&size.attr,
	&number_of_sets.attr,
	&shared_cpu_map.attr,
	NULL
};
ATTRIBUTE_GROUPS(cache_default);

#define to_object(k) container_of(k, struct cache_info, kobj)
#define to_attr(a) container_of(a, struct cache_attr, attr)

static ssize_t ia64_cache_show(struct kobject * kobj, struct attribute * attr, char * buf)
{
	struct cache_attr *fattr = to_attr(attr);
	struct cache_info *this_leaf = to_object(kobj);
	ssize_t ret;

	ret = fattr->show ? fattr->show(this_leaf, buf) : 0;
	return ret;
}

static const struct sysfs_ops cache_sysfs_ops = {
	.show   = ia64_cache_show
};

static struct kobj_type cache_ktype = {
	.sysfs_ops	= &cache_sysfs_ops,
	.default_groups	= cache_default_groups,
};

static struct kobj_type cache_ktype_percpu_entry = {
	.sysfs_ops	= &cache_sysfs_ops,
};

static void cpu_cache_sysfs_exit(unsigned int cpu)
{
	kfree(all_cpu_cache_info[cpu].cache_leaves);
	all_cpu_cache_info[cpu].cache_leaves = NULL;
	all_cpu_cache_info[cpu].num_cache_leaves = 0;
	memset(&all_cpu_cache_info[cpu].kobj, 0, sizeof(struct kobject));
	return;
}

static int cpu_cache_sysfs_init(unsigned int cpu)
{
	unsigned long i, levels, unique_caches;
	pal_cache_config_info_t cci;
	int j;
	long status;
	struct cache_info *this_cache;
	int num_cache_leaves = 0;

	if ((status = ia64_pal_cache_summary(&levels, &unique_caches)) != 0) {
		printk(KERN_ERR "ia64_pal_cache_summary=%ld\n", status);
		return -1;
	}

	this_cache=kcalloc(unique_caches, sizeof(struct cache_info),
			   GFP_KERNEL);
	if (this_cache == NULL)
		return -ENOMEM;

	for (i=0; i < levels; i++) {
		for (j=2; j >0 ; j--) {
			if ((status=ia64_pal_cache_config_info(i,j, &cci)) !=
					PAL_STATUS_SUCCESS)
				continue;

			this_cache[num_cache_leaves].cci = cci;
			this_cache[num_cache_leaves].level = i + 1;
			this_cache[num_cache_leaves].type = j;

			cache_shared_cpu_map_setup(cpu,
					&this_cache[num_cache_leaves]);
			num_cache_leaves ++;
		}
	}

	all_cpu_cache_info[cpu].cache_leaves = this_cache;
	all_cpu_cache_info[cpu].num_cache_leaves = num_cache_leaves;

	memset(&all_cpu_cache_info[cpu].kobj, 0, sizeof(struct kobject));

	return 0;
}

/* Add cache interface for CPU device */
static int cache_add_dev(unsigned int cpu)
{
	struct device *sys_dev = get_cpu_device(cpu);
	unsigned long i, j;
	struct cache_info *this_object;
	int retval = 0;

	if (all_cpu_cache_info[cpu].kobj.parent)
		return 0;


	retval = cpu_cache_sysfs_init(cpu);
	if (unlikely(retval < 0))
		return retval;

	retval = kobject_init_and_add(&all_cpu_cache_info[cpu].kobj,
				      &cache_ktype_percpu_entry, &sys_dev->kobj,
				      "%s", "cache");
	if (unlikely(retval < 0)) {
		cpu_cache_sysfs_exit(cpu);
		return retval;
	}

	for (i = 0; i < all_cpu_cache_info[cpu].num_cache_leaves; i++) {
		this_object = LEAF_KOBJECT_PTR(cpu,i);
		retval = kobject_init_and_add(&(this_object->kobj),
					      &cache_ktype,
					      &all_cpu_cache_info[cpu].kobj,
					      "index%1lu", i);
		if (unlikely(retval)) {
			for (j = 0; j < i; j++) {
				kobject_put(&(LEAF_KOBJECT_PTR(cpu,j)->kobj));
			}
			kobject_put(&all_cpu_cache_info[cpu].kobj);
			cpu_cache_sysfs_exit(cpu);
			return retval;
		}
		kobject_uevent(&(this_object->kobj), KOBJ_ADD);
	}
	kobject_uevent(&all_cpu_cache_info[cpu].kobj, KOBJ_ADD);
	return retval;
}

/* Remove cache interface for CPU device */
static int cache_remove_dev(unsigned int cpu)
{
	unsigned long i;

	for (i = 0; i < all_cpu_cache_info[cpu].num_cache_leaves; i++)
		kobject_put(&(LEAF_KOBJECT_PTR(cpu,i)->kobj));

	if (all_cpu_cache_info[cpu].kobj.parent) {
		kobject_put(&all_cpu_cache_info[cpu].kobj);
		memset(&all_cpu_cache_info[cpu].kobj,
			0,
			sizeof(struct kobject));
	}

	cpu_cache_sysfs_exit(cpu);

	return 0;
}

static int __init cache_sysfs_init(void)
{
	int ret;

	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "ia64/topology:online",
				cache_add_dev, cache_remove_dev);
	WARN_ON(ret < 0);
	return 0;
}
device_initcall(cache_sysfs_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
d3c251ab MR	6	* This file contains NUMA specific variables and functions which are used on
d3c251ab MR	7	* NUMA machines with contiguous memory.
1da177e4 LT	8	* 2002/08/07 Erich Focht <efocht@ess.nec.de>
	9	* Populate cpu entries in sysfs for non-numa systems as well
	10	* Intel Corporation - Ashok Raj
f1918005 ZY	11	* 02/27/2006 Zhang, Yanmin
f1918005 ZY	12	* Populate cpu cache entries in sysfs for cpu cache info
1da177e4 LT	13	*/
1da177e4 LT	14
1da177e4 LT	15	#include <linux/cpu.h>
	16	#include <linux/kernel.h>
	17	#include <linux/mm.h>
	18	#include <linux/node.h>
5a0e3ad6	19	#include <linux/slab.h>
1da177e4	20	#include <linux/init.h>
57c8a661	21	#include <linux/memblock.h>
1da177e4	22	#include <linux/nodemask.h>
f1918005	23	#include <linux/notifier.h>
bd3ff194	24	#include <linux/export.h>
1da177e4 LT	25	#include <asm/mmzone.h>
	26	#include <asm/numa.h>
	27	#include <asm/cpu.h>
	28
1da177e4 LT	29	static struct ia64_cpu *sysfs_cpus;
1da177e4 LT	30
fe086a7b AC	31	void arch_fix_phys_package_id(int num, u32 slot)
	32	{
	33	#ifdef CONFIG_SMP
	34	if (cpu_data(num)->socket_id == -1)
	35	cpu_data(num)->socket_id = slot;
	36	#endif
	37	}
	38	EXPORT_SYMBOL_GPL(arch_fix_phys_package_id);
	39
6d3c5111 HS	40
	41	#ifdef CONFIG_HOTPLUG_CPU
	42	int __ref arch_register_cpu(int num)
1da177e4	43	{
55e59c51	44	/*
25985edc	45	* If CPEI can be re-targeted or if this is not
72486f1f	46	* CPEI target, then it is hotpluggable
55e59c51	47	*/
72486f1f SS	48	if (can_cpei_retarget() \|\| !is_cpu_cpei_target(num))
72486f1f SS	49	sysfs_cpus[num].cpu.hotpluggable = 1;
3212fe15	50	map_cpu_to_node(num, node_cpuid[num].nid);
76b67ed9	51	return register_cpu(&sysfs_cpus[num].cpu, num);
1da177e4	52	}
6d3c5111	53	EXPORT_SYMBOL(arch_register_cpu);
1da177e4	54
8704ad85	55	void __ref arch_unregister_cpu(int num)
1da177e4	56	{
3212fe15 KH	57	unregister_cpu(&sysfs_cpus[num].cpu);
3212fe15 KH	58	unmap_cpu_from_node(num, cpu_to_node(num));
1da177e4	59	}
1da177e4	60	EXPORT_SYMBOL(arch_unregister_cpu);
6d3c5111	61	#else
c4dd854f	62	int __init arch_register_cpu(int num)
6d3c5111 HS	63	{
	64	return register_cpu(&sysfs_cpus[num].cpu, num);
	65	}
1da177e4 LT	66	#endif /CONFIG_HOTPLUG_CPU/
	67
	68
	69	static int __init topology_init(void)
	70	{
	71	int i, err = 0;
	72
6396bb22	73	sysfs_cpus = kcalloc(NR_CPUS, sizeof(struct ia64_cpu), GFP_KERNEL);
a813213d PJ	74	if (!sysfs_cpus)
a813213d PJ	75	panic("kzalloc in topology_init failed - NR_CPUS too big?");
1da177e4	76
69dcc991	77	for_each_present_cpu(i) {
1da177e4 LT	78	if((err = arch_register_cpu(i)))
1da177e4 LT	79	goto out;
69dcc991	80	}
1da177e4 LT	81	out:
	82	return err;
	83	}
	84
69dcc991	85	subsys_initcall(topology_init);
f1918005 ZY	86
	87
	88	/*
	89	* Export cpu cache information through sysfs
	90	*/
	91
	92	/*
	93	* A bunch of string array to get pretty printing
	94	*/
	95	static const char *cache_types[] = {
	96	"", /* not used */
	97	"Instruction",
	98	"Data",
	99	"Unified" /* unified */
	100	};
	101
	102	static const char *cache_mattrib[]={
	103	"WriteThrough",
	104	"WriteBack",
	105	"", /* reserved */
	106	"" /* reserved */
	107	};
	108
	109	struct cache_info {
	110	pal_cache_config_info_t cci;
	111	cpumask_t shared_cpu_map;
	112	int level;
	113	int type;
	114	struct kobject kobj;
	115	};
	116
	117	struct cpu_cache_info {
	118	struct cache_info *cache_leaves;
	119	int num_cache_leaves;
	120	struct kobject kobj;
	121	};
	122
ccce9bb8	123	static struct cpu_cache_info all_cpu_cache_info[NR_CPUS];
f1918005 ZY	124	#define LEAF_KOBJECT_PTR(x,y) (&all_cpu_cache_info[x].cache_leaves[y])
	125
	126	#ifdef CONFIG_SMP
ccce9bb8	127	static void cache_shared_cpu_map_setup(unsigned int cpu,
f1918005 ZY	128	struct cache_info * this_leaf)
	129	{
	130	pal_cache_shared_info_t csi;
	131	int num_shared, i = 0;
	132	unsigned int j;
	133
	134	if (cpu_data(cpu)->threads_per_core <= 1 &&
	135	cpu_data(cpu)->cores_per_socket <= 1) {
5d2068da	136	cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map);
f1918005 ZY	137	return;
	138	}
	139
	140	if (ia64_pal_cache_shared_info(this_leaf->level,
	141	this_leaf->type,
	142	0,
	143	&csi) != PAL_STATUS_SUCCESS)
	144	return;
	145
	146	num_shared = (int) csi.num_shared;
	147	do {
fb1bb34d	148	for_each_possible_cpu(j)
f1918005 ZY	149	if (cpu_data(cpu)->socket_id == cpu_data(j)->socket_id
	150	&& cpu_data(j)->core_id == csi.log1_cid
	151	&& cpu_data(j)->thread_id == csi.log1_tid)
5d2068da	152	cpumask_set_cpu(j, &this_leaf->shared_cpu_map);
f1918005 ZY	153
	154	i++;
	155	} while (i < num_shared &&
	156	ia64_pal_cache_shared_info(this_leaf->level,
	157	this_leaf->type,
	158	i,
	159	&csi) == PAL_STATUS_SUCCESS);
	160	}
	161	#else
ccce9bb8	162	static void cache_shared_cpu_map_setup(unsigned int cpu,
f1918005 ZY	163	struct cache_info * this_leaf)
f1918005 ZY	164	{
5d2068da	165	cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map);
f1918005 ZY	166	return;
	167	}
	168	#endif
	169
	170	static ssize_t show_coherency_line_size(struct cache_info *this_leaf,
	171	char *buf)
	172	{
	173	return sprintf(buf, "%u\n", 1 << this_leaf->cci.pcci_line_size);
	174	}
	175
	176	static ssize_t show_ways_of_associativity(struct cache_info *this_leaf,
	177	char *buf)
	178	{
	179	return sprintf(buf, "%u\n", this_leaf->cci.pcci_assoc);
	180	}
	181
	182	static ssize_t show_attributes(struct cache_info this_leaf, char buf)
	183	{
	184	return sprintf(buf,
	185	"%s\n",
	186	cache_mattrib[this_leaf->cci.pcci_cache_attr]);
	187	}
	188
	189	static ssize_t show_size(struct cache_info this_leaf, char buf)
	190	{
	191	return sprintf(buf, "%uK\n", this_leaf->cci.pcci_cache_size / 1024);
	192	}
	193
	194	static ssize_t show_number_of_sets(struct cache_info this_leaf, char buf)
	195	{
	196	unsigned number_of_sets = this_leaf->cci.pcci_cache_size;
	197	number_of_sets /= this_leaf->cci.pcci_assoc;
	198	number_of_sets /= 1 << this_leaf->cci.pcci_line_size;
	199
	200	return sprintf(buf, "%u\n", number_of_sets);
	201	}
	202
	203	static ssize_t show_shared_cpu_map(struct cache_info this_leaf, char buf)
	204	{
f1918005 ZY	205	cpumask_t shared_cpu_map;
f1918005 ZY	206
7d7f9848 SB	207	cpumask_and(&shared_cpu_map,
7d7f9848 SB	208	&this_leaf->shared_cpu_map, cpu_online_mask);
90b586c0 TH	209	return scnprintf(buf, PAGE_SIZE, "%*pb\n",
90b586c0 TH	210	cpumask_pr_args(&shared_cpu_map));
f1918005 ZY	211	}
	212
	213	static ssize_t show_type(struct cache_info this_leaf, char buf)
	214	{
	215	int type = this_leaf->type + this_leaf->cci.pcci_unified;
	216	return sprintf(buf, "%s\n", cache_types[type]);
	217	}
	218
	219	static ssize_t show_level(struct cache_info this_leaf, char buf)
	220	{
	221	return sprintf(buf, "%u\n", this_leaf->level);
	222	}
	223
	224	struct cache_attr {
	225	struct attribute attr;
	226	ssize_t (show)(struct cache_info , char *);
	227	ssize_t (store)(struct cache_info , const char *, size_t count);
	228	};
	229
	230	#ifdef define_one_ro
	231	#undef define_one_ro
	232	#endif
	233	#define define_one_ro(_name) \
	234	static struct cache_attr _name = \
	235	__ATTR(_name, 0444, show_##_name, NULL)
	236
	237	define_one_ro(level);
	238	define_one_ro(type);
	239	define_one_ro(coherency_line_size);
	240	define_one_ro(ways_of_associativity);
	241	define_one_ro(size);
	242	define_one_ro(number_of_sets);
	243	define_one_ro(shared_cpu_map);
	244	define_one_ro(attributes);
	245
	246	static struct attribute * cache_default_attrs[] = {
	247	&type.attr,
	248	&level.attr,
	249	&coherency_line_size.attr,
	250	&ways_of_associativity.attr,
	251	&attributes.attr,
	252	&size.attr,
	253	&number_of_sets.attr,
	254	&shared_cpu_map.attr,
	255	NULL
	256	};
a7eddfc9	257	ATTRIBUTE_GROUPS(cache_default);
f1918005 ZY	258
	259	#define to_object(k) container_of(k, struct cache_info, kobj)
	260	#define to_attr(a) container_of(a, struct cache_attr, attr)
	261
4fafc8c2	262	static ssize_t ia64_cache_show(struct kobject * kobj, struct attribute * attr, char * buf)
f1918005 ZY	263	{
	264	struct cache_attr *fattr = to_attr(attr);
	265	struct cache_info *this_leaf = to_object(kobj);
	266	ssize_t ret;
	267
	268	ret = fattr->show ? fattr->show(this_leaf, buf) : 0;
	269	return ret;
	270	}
	271
52cf25d0	272	static const struct sysfs_ops cache_sysfs_ops = {
4fafc8c2	273	.show = ia64_cache_show
f1918005 ZY	274	};
	275
	276	static struct kobj_type cache_ktype = {
	277	.sysfs_ops = &cache_sysfs_ops,
a7eddfc9	278	.default_groups = cache_default_groups,
f1918005 ZY	279	};
	280
	281	static struct kobj_type cache_ktype_percpu_entry = {
	282	.sysfs_ops = &cache_sysfs_ops,
	283	};
	284
ccce9bb8	285	static void cpu_cache_sysfs_exit(unsigned int cpu)
f1918005	286	{
cbf283c0 JJ	287	kfree(all_cpu_cache_info[cpu].cache_leaves);
cbf283c0 JJ	288	all_cpu_cache_info[cpu].cache_leaves = NULL;
f1918005 ZY	289	all_cpu_cache_info[cpu].num_cache_leaves = 0;
f1918005 ZY	290	memset(&all_cpu_cache_info[cpu].kobj, 0, sizeof(struct kobject));
f1918005 ZY	291	return;
	292	}
	293
ccce9bb8	294	static int cpu_cache_sysfs_init(unsigned int cpu)
f1918005	295	{
e088a4ad	296	unsigned long i, levels, unique_caches;
f1918005 ZY	297	pal_cache_config_info_t cci;
f1918005 ZY	298	int j;
e088a4ad	299	long status;
f1918005 ZY	300	struct cache_info *this_cache;
	301	int num_cache_leaves = 0;
	302
	303	if ((status = ia64_pal_cache_summary(&levels, &unique_caches)) != 0) {
	304	printk(KERN_ERR "ia64_pal_cache_summary=%ld\n", status);
	305	return -1;
	306	}
	307
6396bb22 KC	308	this_cache=kcalloc(unique_caches, sizeof(struct cache_info),
6396bb22 KC	309	GFP_KERNEL);
f1918005 ZY	310	if (this_cache == NULL)
	311	return -ENOMEM;
	312
	313	for (i=0; i < levels; i++) {
	314	for (j=2; j >0 ; j--) {
	315	if ((status=ia64_pal_cache_config_info(i,j, &cci)) !=
	316	PAL_STATUS_SUCCESS)
	317	continue;
	318
	319	this_cache[num_cache_leaves].cci = cci;
	320	this_cache[num_cache_leaves].level = i + 1;
	321	this_cache[num_cache_leaves].type = j;
	322
	323	cache_shared_cpu_map_setup(cpu,
	324	&this_cache[num_cache_leaves]);
	325	num_cache_leaves ++;
	326	}
	327	}
	328
	329	all_cpu_cache_info[cpu].cache_leaves = this_cache;
	330	all_cpu_cache_info[cpu].num_cache_leaves = num_cache_leaves;
	331
	332	memset(&all_cpu_cache_info[cpu].kobj, 0, sizeof(struct kobject));
	333
	334	return 0;
	335	}
	336
	337	/* Add cache interface for CPU device */
5c584dd5	338	static int cache_add_dev(unsigned int cpu)
f1918005	339	{
5c584dd5	340	struct device *sys_dev = get_cpu_device(cpu);
f1918005 ZY	341	unsigned long i, j;
	342	struct cache_info *this_object;
	343	int retval = 0;
f1918005 ZY	344
	345	if (all_cpu_cache_info[cpu].kobj.parent)
	346	return 0;
	347
f1918005 ZY	348
f1918005 ZY	349	retval = cpu_cache_sysfs_init(cpu);
f1918005 ZY	350	if (unlikely(retval < 0))
	351	return retval;
	352
c199790a GKH	353	retval = kobject_init_and_add(&all_cpu_cache_info[cpu].kobj,
	354	&cache_ktype_percpu_entry, &sys_dev->kobj,
	355	"%s", "cache");
5359dffd FY	356	if (unlikely(retval < 0)) {
	357	cpu_cache_sysfs_exit(cpu);
	358	return retval;
	359	}
f1918005 ZY	360
	361	for (i = 0; i < all_cpu_cache_info[cpu].num_cache_leaves; i++) {
	362	this_object = LEAF_KOBJECT_PTR(cpu,i);
c199790a GKH	363	retval = kobject_init_and_add(&(this_object->kobj),
	364	&cache_ktype,
	365	&all_cpu_cache_info[cpu].kobj,
	366	"index%1lu", i);
f1918005 ZY	367	if (unlikely(retval)) {
f1918005 ZY	368	for (j = 0; j < i; j++) {
38a382ae	369	kobject_put(&(LEAF_KOBJECT_PTR(cpu,j)->kobj));
f1918005	370	}
38a382ae	371	kobject_put(&all_cpu_cache_info[cpu].kobj);
f1918005	372	cpu_cache_sysfs_exit(cpu);
5359dffd	373	return retval;
f1918005	374	}
c199790a	375	kobject_uevent(&(this_object->kobj), KOBJ_ADD);
f1918005	376	}
c199790a	377	kobject_uevent(&all_cpu_cache_info[cpu].kobj, KOBJ_ADD);
f1918005 ZY	378	return retval;
	379	}
	380
	381	/* Remove cache interface for CPU device */
5c584dd5	382	static int cache_remove_dev(unsigned int cpu)
f1918005	383	{
f1918005 ZY	384	unsigned long i;
	385
	386	for (i = 0; i < all_cpu_cache_info[cpu].num_cache_leaves; i++)
38a382ae	387	kobject_put(&(LEAF_KOBJECT_PTR(cpu,i)->kobj));
f1918005 ZY	388
f1918005 ZY	389	if (all_cpu_cache_info[cpu].kobj.parent) {
38a382ae	390	kobject_put(&all_cpu_cache_info[cpu].kobj);
f1918005 ZY	391	memset(&all_cpu_cache_info[cpu].kobj,
	392	0,
	393	sizeof(struct kobject));
	394	}
	395
	396	cpu_cache_sysfs_exit(cpu);
	397
	398	return 0;
	399	}
	400
db6a5cef	401	static int __init cache_sysfs_init(void)
f1918005	402	{
5c584dd5	403	int ret;
f1918005	404
5c584dd5 SAS	405	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "ia64/topology:online",
	406	cache_add_dev, cache_remove_dev);
	407	WARN_ON(ret < 0);
f1918005 ZY	408	return 0;
f1918005 ZY	409	}
f1918005	410	device_initcall(cache_sysfs_init);