[linux-2.6-block.git] / drivers / base / cacheinfo.c

/*
 * cacheinfo support - processor cache information via sysfs
 *
 * Based on arch/x86/kernel/cpu/intel_cacheinfo.c
 * Author: Sudeep Holla <sudeep.holla@arm.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <linux/bitops.h>
#include <linux/cacheinfo.h>
#include <linux/compiler.h>
#include <linux/cpu.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/of.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/smp.h>
#include <linux/sysfs.h>

/* pointer to per cpu cacheinfo */
static DEFINE_PER_CPU(struct cpu_cacheinfo, ci_cpu_cacheinfo);
#define ci_cacheinfo(cpu)	(&per_cpu(ci_cpu_cacheinfo, cpu))
#define cache_leaves(cpu)	(ci_cacheinfo(cpu)->num_leaves)
#define per_cpu_cacheinfo(cpu)	(ci_cacheinfo(cpu)->info_list)

struct cpu_cacheinfo *get_cpu_cacheinfo(unsigned int cpu)
{
	return ci_cacheinfo(cpu);
}

#ifdef CONFIG_OF
static int cache_setup_of_node(unsigned int cpu)
{
	struct device_node *np;
	struct cacheinfo *this_leaf;
	struct device *cpu_dev = get_cpu_device(cpu);
	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
	unsigned int index = 0;

	/* skip if of_node is already populated */
	if (this_cpu_ci->info_list->of_node)
		return 0;

	if (!cpu_dev) {
		pr_err("No cpu device for CPU %d\n", cpu);
		return -ENODEV;
	}
	np = cpu_dev->of_node;
	if (!np) {
		pr_err("Failed to find cpu%d device node\n", cpu);
		return -ENOENT;
	}

	while (index < cache_leaves(cpu)) {
		this_leaf = this_cpu_ci->info_list + index;
		if (this_leaf->level != 1)
			np = of_find_next_cache_node(np);
		else
			np = of_node_get(np);/* cpu node itself */
		if (!np)
			break;
		this_leaf->of_node = np;
		index++;
	}

	if (index != cache_leaves(cpu)) /* not all OF nodes populated */
		return -ENOENT;

	return 0;
}

static inline bool cache_leaves_are_shared(struct cacheinfo *this_leaf,
					   struct cacheinfo *sib_leaf)
{
	return sib_leaf->of_node == this_leaf->of_node;
}
#else
static inline int cache_setup_of_node(unsigned int cpu) { return 0; }
static inline bool cache_leaves_are_shared(struct cacheinfo *this_leaf,
					   struct cacheinfo *sib_leaf)
{
	/*
	 * For non-DT systems, assume unique level 1 cache, system-wide
	 * shared caches for all other levels. This will be used only if
	 * arch specific code has not populated shared_cpu_map
	 */
	return !(this_leaf->level == 1);
}
#endif

static int cache_shared_cpu_map_setup(unsigned int cpu)
{
	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
	struct cacheinfo *this_leaf, *sib_leaf;
	unsigned int index;
	int ret;

	ret = cache_setup_of_node(cpu);
	if (ret)
		return ret;

	for (index = 0; index < cache_leaves(cpu); index++) {
		unsigned int i;

		this_leaf = this_cpu_ci->info_list + index;
		/* skip if shared_cpu_map is already populated */
		if (!cpumask_empty(&this_leaf->shared_cpu_map))
			continue;

		cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map);
		for_each_online_cpu(i) {
			struct cpu_cacheinfo *sib_cpu_ci = get_cpu_cacheinfo(i);

			if (i == cpu || !sib_cpu_ci->info_list)
				continue;/* skip if itself or no cacheinfo */
			sib_leaf = sib_cpu_ci->info_list + index;
			if (cache_leaves_are_shared(this_leaf, sib_leaf)) {
				cpumask_set_cpu(cpu, &sib_leaf->shared_cpu_map);
				cpumask_set_cpu(i, &this_leaf->shared_cpu_map);
			}
		}
	}

	return 0;
}

static void cache_shared_cpu_map_remove(unsigned int cpu)
{
	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
	struct cacheinfo *this_leaf, *sib_leaf;
	unsigned int sibling, index;

	for (index = 0; index < cache_leaves(cpu); index++) {
		this_leaf = this_cpu_ci->info_list + index;
		for_each_cpu(sibling, &this_leaf->shared_cpu_map) {
			struct cpu_cacheinfo *sib_cpu_ci;

			if (sibling == cpu) /* skip itself */
				continue;
			sib_cpu_ci = get_cpu_cacheinfo(sibling);
			sib_leaf = sib_cpu_ci->info_list + index;
			cpumask_clear_cpu(cpu, &sib_leaf->shared_cpu_map);
			cpumask_clear_cpu(sibling, &this_leaf->shared_cpu_map);
		}
		of_node_put(this_leaf->of_node);
	}
}

static void free_cache_attributes(unsigned int cpu)
{
	cache_shared_cpu_map_remove(cpu);

	kfree(per_cpu_cacheinfo(cpu));
	per_cpu_cacheinfo(cpu) = NULL;
}

int __weak init_cache_level(unsigned int cpu)
{
	return -ENOENT;
}

int __weak populate_cache_leaves(unsigned int cpu)
{
	return -ENOENT;
}

static int detect_cache_attributes(unsigned int cpu)
{
	int ret;

	if (init_cache_level(cpu))
		return -ENOENT;

	per_cpu_cacheinfo(cpu) = kcalloc(cache_leaves(cpu),
					 sizeof(struct cacheinfo), GFP_KERNEL);
	if (per_cpu_cacheinfo(cpu) == NULL)
		return -ENOMEM;

	ret = populate_cache_leaves(cpu);
	if (ret)
		goto free_ci;
	/*
	 * For systems using DT for cache hierarcy, of_node and shared_cpu_map
	 * will be set up here only if they are not populated already
	 */
	ret = cache_shared_cpu_map_setup(cpu);
	if (ret) {
		pr_warn("Unable to detect cache hierarcy from DT for CPU %d\n",
			cpu);
		goto free_ci;
	}
	return 0;

free_ci:
	free_cache_attributes(cpu);
	return ret;
}

/* pointer to cpuX/cache device */
static DEFINE_PER_CPU(struct device *, ci_cache_dev);
#define per_cpu_cache_dev(cpu)	(per_cpu(ci_cache_dev, cpu))

static cpumask_t cache_dev_map;

/* pointer to array of devices for cpuX/cache/indexY */
static DEFINE_PER_CPU(struct device **, ci_index_dev);
#define per_cpu_index_dev(cpu)	(per_cpu(ci_index_dev, cpu))
#define per_cache_index_dev(cpu, idx)	((per_cpu_index_dev(cpu))[idx])

#define show_one(file_name, object)				\
static ssize_t file_name##_show(struct device *dev,		\
		struct device_attribute *attr, char *buf)	\
{								\
	struct cacheinfo *this_leaf = dev_get_drvdata(dev);	\
	return sprintf(buf, "%u\n", this_leaf->object);		\
}

show_one(level, level);
show_one(coherency_line_size, coherency_line_size);
show_one(number_of_sets, number_of_sets);
show_one(physical_line_partition, physical_line_partition);
show_one(ways_of_associativity, ways_of_associativity);

static ssize_t size_show(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	struct cacheinfo *this_leaf = dev_get_drvdata(dev);

	return sprintf(buf, "%uK\n", this_leaf->size >> 10);
}

static ssize_t shared_cpumap_show_func(struct device *dev, bool list, char *buf)
{
	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
	const struct cpumask *mask = &this_leaf->shared_cpu_map;

	return cpumap_print_to_pagebuf(list, buf, mask);
}

static ssize_t shared_cpu_map_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	return shared_cpumap_show_func(dev, false, buf);
}

static ssize_t shared_cpu_list_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	return shared_cpumap_show_func(dev, true, buf);
}

static ssize_t type_show(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	struct cacheinfo *this_leaf = dev_get_drvdata(dev);

	switch (this_leaf->type) {
	case CACHE_TYPE_DATA:
		return sprintf(buf, "Data\n");
	case CACHE_TYPE_INST:
		return sprintf(buf, "Instruction\n");
	case CACHE_TYPE_UNIFIED:
		return sprintf(buf, "Unified\n");
	default:
		return -EINVAL;
	}
}

static ssize_t allocation_policy_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
	unsigned int ci_attr = this_leaf->attributes;
	int n = 0;

	if ((ci_attr & CACHE_READ_ALLOCATE) && (ci_attr & CACHE_WRITE_ALLOCATE))
		n = sprintf(buf, "ReadWriteAllocate\n");
	else if (ci_attr & CACHE_READ_ALLOCATE)
		n = sprintf(buf, "ReadAllocate\n");
	else if (ci_attr & CACHE_WRITE_ALLOCATE)
		n = sprintf(buf, "WriteAllocate\n");
	return n;
}

static ssize_t write_policy_show(struct device *dev,
				 struct device_attribute *attr, char *buf)
{
	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
	unsigned int ci_attr = this_leaf->attributes;
	int n = 0;

	if (ci_attr & CACHE_WRITE_THROUGH)
		n = sprintf(buf, "WriteThrough\n");
	else if (ci_attr & CACHE_WRITE_BACK)
		n = sprintf(buf, "WriteBack\n");
	return n;
}

static DEVICE_ATTR_RO(level);
static DEVICE_ATTR_RO(type);
static DEVICE_ATTR_RO(coherency_line_size);
static DEVICE_ATTR_RO(ways_of_associativity);
static DEVICE_ATTR_RO(number_of_sets);
static DEVICE_ATTR_RO(size);
static DEVICE_ATTR_RO(allocation_policy);
static DEVICE_ATTR_RO(write_policy);
static DEVICE_ATTR_RO(shared_cpu_map);
static DEVICE_ATTR_RO(shared_cpu_list);
static DEVICE_ATTR_RO(physical_line_partition);

static struct attribute *cache_default_attrs[] = {
	&dev_attr_type.attr,
	&dev_attr_level.attr,
	&dev_attr_shared_cpu_map.attr,
	&dev_attr_shared_cpu_list.attr,
	&dev_attr_coherency_line_size.attr,
	&dev_attr_ways_of_associativity.attr,
	&dev_attr_number_of_sets.attr,
	&dev_attr_size.attr,
	&dev_attr_allocation_policy.attr,
	&dev_attr_write_policy.attr,
	&dev_attr_physical_line_partition.attr,
	NULL
};

static umode_t
cache_default_attrs_is_visible(struct kobject *kobj,
			       struct attribute *attr, int unused)
{
	struct device *dev = kobj_to_dev(kobj);
	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
	const struct cpumask *mask = &this_leaf->shared_cpu_map;
	umode_t mode = attr->mode;

	if ((attr == &dev_attr_type.attr) && this_leaf->type)
		return mode;
	if ((attr == &dev_attr_level.attr) && this_leaf->level)
		return mode;
	if ((attr == &dev_attr_shared_cpu_map.attr) && !cpumask_empty(mask))
		return mode;
	if ((attr == &dev_attr_shared_cpu_list.attr) && !cpumask_empty(mask))
		return mode;
	if ((attr == &dev_attr_coherency_line_size.attr) &&
	    this_leaf->coherency_line_size)
		return mode;
	if ((attr == &dev_attr_ways_of_associativity.attr) &&
	    this_leaf->size) /* allow 0 = full associativity */
		return mode;
	if ((attr == &dev_attr_number_of_sets.attr) &&
	    this_leaf->number_of_sets)
		return mode;
	if ((attr == &dev_attr_size.attr) && this_leaf->size)
		return mode;
	if ((attr == &dev_attr_write_policy.attr) &&
	    (this_leaf->attributes & CACHE_WRITE_POLICY_MASK))
		return mode;
	if ((attr == &dev_attr_allocation_policy.attr) &&
	    (this_leaf->attributes & CACHE_ALLOCATE_POLICY_MASK))
		return mode;
	if ((attr == &dev_attr_physical_line_partition.attr) &&
	    this_leaf->physical_line_partition)
		return mode;

	return 0;
}

static const struct attribute_group cache_default_group = {
	.attrs = cache_default_attrs,
	.is_visible = cache_default_attrs_is_visible,
};

static const struct attribute_group *cache_default_groups[] = {
	&cache_default_group,
	NULL,
};

static const struct attribute_group *cache_private_groups[] = {
	&cache_default_group,
	NULL, /* Place holder for private group */
	NULL,
};

const struct attribute_group *
__weak cache_get_priv_group(struct cacheinfo *this_leaf)
{
	return NULL;
}

static const struct attribute_group **
cache_get_attribute_groups(struct cacheinfo *this_leaf)
{
	const struct attribute_group *priv_group =
			cache_get_priv_group(this_leaf);

	if (!priv_group)
		return cache_default_groups;

	if (!cache_private_groups[1])
		cache_private_groups[1] = priv_group;

	return cache_private_groups;
}

/* Add/Remove cache interface for CPU device */
static void cpu_cache_sysfs_exit(unsigned int cpu)
{
	int i;
	struct device *ci_dev;

	if (per_cpu_index_dev(cpu)) {
		for (i = 0; i < cache_leaves(cpu); i++) {
			ci_dev = per_cache_index_dev(cpu, i);
			if (!ci_dev)
				continue;
			device_unregister(ci_dev);
		}
		kfree(per_cpu_index_dev(cpu));
		per_cpu_index_dev(cpu) = NULL;
	}
	device_unregister(per_cpu_cache_dev(cpu));
	per_cpu_cache_dev(cpu) = NULL;
}

static int cpu_cache_sysfs_init(unsigned int cpu)
{
	struct device *dev = get_cpu_device(cpu);

	if (per_cpu_cacheinfo(cpu) == NULL)
		return -ENOENT;

	per_cpu_cache_dev(cpu) = cpu_device_create(dev, NULL, NULL, "cache");
	if (IS_ERR(per_cpu_cache_dev(cpu)))
		return PTR_ERR(per_cpu_cache_dev(cpu));

	/* Allocate all required memory */
	per_cpu_index_dev(cpu) = kcalloc(cache_leaves(cpu),
					 sizeof(struct device *), GFP_KERNEL);
	if (unlikely(per_cpu_index_dev(cpu) == NULL))
		goto err_out;

	return 0;

err_out:
	cpu_cache_sysfs_exit(cpu);
	return -ENOMEM;
}

static int cache_add_dev(unsigned int cpu)
{
	unsigned int i;
	int rc;
	struct device *ci_dev, *parent;
	struct cacheinfo *this_leaf;
	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
	const struct attribute_group **cache_groups;

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

	parent = per_cpu_cache_dev(cpu);
	for (i = 0; i < cache_leaves(cpu); i++) {
		this_leaf = this_cpu_ci->info_list + i;
		if (this_leaf->disable_sysfs)
			continue;
		cache_groups = cache_get_attribute_groups(this_leaf);
		ci_dev = cpu_device_create(parent, this_leaf, cache_groups,
					   "index%1u", i);
		if (IS_ERR(ci_dev)) {
			rc = PTR_ERR(ci_dev);
			goto err;
		}
		per_cache_index_dev(cpu, i) = ci_dev;
	}
	cpumask_set_cpu(cpu, &cache_dev_map);

	return 0;
err:
	cpu_cache_sysfs_exit(cpu);
	return rc;
}

static void cache_remove_dev(unsigned int cpu)
{
	if (!cpumask_test_cpu(cpu, &cache_dev_map))
		return;
	cpumask_clear_cpu(cpu, &cache_dev_map);

	cpu_cache_sysfs_exit(cpu);
}

static int cacheinfo_cpu_callback(struct notifier_block *nfb,
				  unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
	int rc = 0;

	switch (action & ~CPU_TASKS_FROZEN) {
	case CPU_ONLINE:
		rc = detect_cache_attributes(cpu);
		if (!rc)
			rc = cache_add_dev(cpu);
		break;
	case CPU_DEAD:
		cache_remove_dev(cpu);
		if (per_cpu_cacheinfo(cpu))
			free_cache_attributes(cpu);
		break;
	}
	return notifier_from_errno(rc);
}

static int __init cacheinfo_sysfs_init(void)
{
	int cpu, rc = 0;

	cpu_notifier_register_begin();

	for_each_online_cpu(cpu) {
		rc = detect_cache_attributes(cpu);
		if (rc)
			goto out;
		rc = cache_add_dev(cpu);
		if (rc) {
			free_cache_attributes(cpu);
			pr_err("error populating cacheinfo..cpu%d\n", cpu);
			goto out;
		}
	}
	__hotcpu_notifier(cacheinfo_cpu_callback, 0);

out:
	cpu_notifier_register_done();
	return rc;
}

device_initcall(cacheinfo_sysfs_init);
Commit	Line	Data
246246cb SH	1	/*
	2	* cacheinfo support - processor cache information via sysfs
	3	*
	4	* Based on arch/x86/kernel/cpu/intel_cacheinfo.c
	5	* Author: Sudeep Holla <sudeep.holla@arm.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	12	* kind, whether express or implied; without even the implied warranty
	13	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19	#include <linux/bitops.h>
	20	#include <linux/cacheinfo.h>
	21	#include <linux/compiler.h>
	22	#include <linux/cpu.h>
	23	#include <linux/device.h>
	24	#include <linux/init.h>
	25	#include <linux/of.h>
	26	#include <linux/sched.h>
	27	#include <linux/slab.h>
	28	#include <linux/smp.h>
	29	#include <linux/sysfs.h>
	30
	31	/* pointer to per cpu cacheinfo */
	32	static DEFINE_PER_CPU(struct cpu_cacheinfo, ci_cpu_cacheinfo);
	33	#define ci_cacheinfo(cpu) (&per_cpu(ci_cpu_cacheinfo, cpu))
	34	#define cache_leaves(cpu) (ci_cacheinfo(cpu)->num_leaves)
	35	#define per_cpu_cacheinfo(cpu) (ci_cacheinfo(cpu)->info_list)
	36
	37	struct cpu_cacheinfo *get_cpu_cacheinfo(unsigned int cpu)
	38	{
	39	return ci_cacheinfo(cpu);
	40	}
	41
	42	#ifdef CONFIG_OF
	43	static int cache_setup_of_node(unsigned int cpu)
	44	{
	45	struct device_node *np;
	46	struct cacheinfo *this_leaf;
	47	struct device *cpu_dev = get_cpu_device(cpu);
	48	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
	49	unsigned int index = 0;
	50
	51	/* skip if of_node is already populated */
	52	if (this_cpu_ci->info_list->of_node)
	53	return 0;
	54
	55	if (!cpu_dev) {
	56	pr_err("No cpu device for CPU %d\n", cpu);
	57	return -ENODEV;
	58	}
	59	np = cpu_dev->of_node;
	60	if (!np) {
	61	pr_err("Failed to find cpu%d device node\n", cpu);
	62	return -ENOENT;
	63	}
	64
8a7d95f9	65	while (index < cache_leaves(cpu)) {
246246cb SH	66	this_leaf = this_cpu_ci->info_list + index;
	67	if (this_leaf->level != 1)
	68	np = of_find_next_cache_node(np);
	69	else
	70	np = of_node_get(np);/* cpu node itself */
8a7d95f9 SH	71	if (!np)
8a7d95f9 SH	72	break;
246246cb SH	73	this_leaf->of_node = np;
	74	index++;
	75	}
8a7d95f9 SH	76
	77	if (index != cache_leaves(cpu)) /* not all OF nodes populated */
	78	return -ENOENT;
	79
246246cb SH	80	return 0;
	81	}
	82
	83	static inline bool cache_leaves_are_shared(struct cacheinfo *this_leaf,
	84	struct cacheinfo *sib_leaf)
	85	{
	86	return sib_leaf->of_node == this_leaf->of_node;
	87	}
	88	#else
	89	static inline int cache_setup_of_node(unsigned int cpu) { return 0; }
	90	static inline bool cache_leaves_are_shared(struct cacheinfo *this_leaf,
	91	struct cacheinfo *sib_leaf)
	92	{
	93	/*
	94	* For non-DT systems, assume unique level 1 cache, system-wide
	95	* shared caches for all other levels. This will be used only if
	96	* arch specific code has not populated shared_cpu_map
	97	*/
	98	return !(this_leaf->level == 1);
	99	}
	100	#endif
	101
	102	static int cache_shared_cpu_map_setup(unsigned int cpu)
	103	{
	104	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
	105	struct cacheinfo this_leaf, sib_leaf;
	106	unsigned int index;
	107	int ret;
	108
	109	ret = cache_setup_of_node(cpu);
	110	if (ret)
	111	return ret;
	112
	113	for (index = 0; index < cache_leaves(cpu); index++) {
	114	unsigned int i;
	115
	116	this_leaf = this_cpu_ci->info_list + index;
	117	/* skip if shared_cpu_map is already populated */
	118	if (!cpumask_empty(&this_leaf->shared_cpu_map))
	119	continue;
	120
	121	cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map);
	122	for_each_online_cpu(i) {
	123	struct cpu_cacheinfo *sib_cpu_ci = get_cpu_cacheinfo(i);
	124
	125	if (i == cpu \|\| !sib_cpu_ci->info_list)
	126	continue;/* skip if itself or no cacheinfo */
	127	sib_leaf = sib_cpu_ci->info_list + index;
	128	if (cache_leaves_are_shared(this_leaf, sib_leaf)) {
	129	cpumask_set_cpu(cpu, &sib_leaf->shared_cpu_map);
	130	cpumask_set_cpu(i, &this_leaf->shared_cpu_map);
	131	}
	132	}
	133	}
	134
	135	return 0;
	136	}
	137
	138	static void cache_shared_cpu_map_remove(unsigned int cpu)
	139	{
	140	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
	141	struct cacheinfo this_leaf, sib_leaf;
	142	unsigned int sibling, index;
	143
144	for (index = 0; index < cache_leaves(cpu); index++) {
145	this_leaf = this_cpu_ci->info_list + index;
146	for_each_cpu(sibling, &this_leaf->shared_cpu_map) {
147	struct cpu_cacheinfo *sib_cpu_ci;
148
149	if (sibling == cpu) /* skip itself */
150	continue;
151	sib_cpu_ci = get_cpu_cacheinfo(sibling);
152	sib_leaf = sib_cpu_ci->info_list + index;
153	cpumask_clear_cpu(cpu, &sib_leaf->shared_cpu_map);
154	cpumask_clear_cpu(sibling, &this_leaf->shared_cpu_map);
155	}
156	of_node_put(this_leaf->of_node);
157	}
158	}
159
160	static void free_cache_attributes(unsigned int cpu)
161	{
162	cache_shared_cpu_map_remove(cpu);
163
164	kfree(per_cpu_cacheinfo(cpu));
165	per_cpu_cacheinfo(cpu) = NULL;
166	}
167
168	int __weak init_cache_level(unsigned int cpu)
169	{
170	return -ENOENT;
171	}
172
173	int __weak populate_cache_leaves(unsigned int cpu)
174	{
175	return -ENOENT;
176	}
177
178	static int detect_cache_attributes(unsigned int cpu)
179	{
180	int ret;
181
182	if (init_cache_level(cpu))
183	return -ENOENT;
184
185	per_cpu_cacheinfo(cpu) = kcalloc(cache_leaves(cpu),
186	sizeof(struct cacheinfo), GFP_KERNEL);
187	if (per_cpu_cacheinfo(cpu) == NULL)
188	return -ENOMEM;
189
190	ret = populate_cache_leaves(cpu);
191	if (ret)
192	goto free_ci;
193	/*
194	* For systems using DT for cache hierarcy, of_node and shared_cpu_map
195	* will be set up here only if they are not populated already
196	*/
197	ret = cache_shared_cpu_map_setup(cpu);
8a7d95f9 SH	198	if (ret) {
	199	pr_warn("Unable to detect cache hierarcy from DT for CPU %d\n",
	200	cpu);
246246cb	201	goto free_ci;
8a7d95f9	202	}
246246cb SH	203	return 0;
	204
	205	free_ci:
	206	free_cache_attributes(cpu);
	207	return ret;
	208	}
	209
	210	/* pointer to cpuX/cache device */
	211	static DEFINE_PER_CPU(struct device *, ci_cache_dev);
	212	#define per_cpu_cache_dev(cpu) (per_cpu(ci_cache_dev, cpu))
	213
	214	static cpumask_t cache_dev_map;
	215
	216	/* pointer to array of devices for cpuX/cache/indexY */
	217	static DEFINE_PER_CPU(struct device **, ci_index_dev);
	218	#define per_cpu_index_dev(cpu) (per_cpu(ci_index_dev, cpu))
	219	#define per_cache_index_dev(cpu, idx) ((per_cpu_index_dev(cpu))[idx])
	220
	221	#define show_one(file_name, object) \
	222	static ssize_t file_name##_show(struct device *dev, \
	223	struct device_attribute attr, char buf) \
	224	{ \
	225	struct cacheinfo *this_leaf = dev_get_drvdata(dev); \
	226	return sprintf(buf, "%u\n", this_leaf->object); \
	227	}
	228
	229	show_one(level, level);
	230	show_one(coherency_line_size, coherency_line_size);
	231	show_one(number_of_sets, number_of_sets);
	232	show_one(physical_line_partition, physical_line_partition);
	233	show_one(ways_of_associativity, ways_of_associativity);
	234
	235	static ssize_t size_show(struct device *dev,
	236	struct device_attribute attr, char buf)
	237	{
	238	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
	239
	240	return sprintf(buf, "%uK\n", this_leaf->size >> 10);
	241	}
	242
	243	static ssize_t shared_cpumap_show_func(struct device dev, bool list, char buf)
	244	{
	245	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
	246	const struct cpumask *mask = &this_leaf->shared_cpu_map;
	247
	248	return cpumap_print_to_pagebuf(list, buf, mask);
	249	}
	250
	251	static ssize_t shared_cpu_map_show(struct device *dev,
	252	struct device_attribute attr, char buf)
	253	{
	254	return shared_cpumap_show_func(dev, false, buf);
	255	}
	256
	257	static ssize_t shared_cpu_list_show(struct device *dev,
	258	struct device_attribute attr, char buf)
	259	{
	260	return shared_cpumap_show_func(dev, true, buf);
	261	}
	262
	263	static ssize_t type_show(struct device *dev,
	264	struct device_attribute attr, char buf)
	265	{
	266	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
267
268	switch (this_leaf->type) {
269	case CACHE_TYPE_DATA:
270	return sprintf(buf, "Data\n");
271	case CACHE_TYPE_INST:
272	return sprintf(buf, "Instruction\n");
273	case CACHE_TYPE_UNIFIED:
274	return sprintf(buf, "Unified\n");
275	default:
276	return -EINVAL;
277	}
278	}
279
280	static ssize_t allocation_policy_show(struct device *dev,
281	struct device_attribute attr, char buf)
282	{
283	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
284	unsigned int ci_attr = this_leaf->attributes;
285	int n = 0;
286
287	if ((ci_attr & CACHE_READ_ALLOCATE) && (ci_attr & CACHE_WRITE_ALLOCATE))
288	n = sprintf(buf, "ReadWriteAllocate\n");
289	else if (ci_attr & CACHE_READ_ALLOCATE)
290	n = sprintf(buf, "ReadAllocate\n");
291	else if (ci_attr & CACHE_WRITE_ALLOCATE)
292	n = sprintf(buf, "WriteAllocate\n");
293	return n;
294	}
295
296	static ssize_t write_policy_show(struct device *dev,
297	struct device_attribute attr, char buf)
298	{
299	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
300	unsigned int ci_attr = this_leaf->attributes;
301	int n = 0;
302
303	if (ci_attr & CACHE_WRITE_THROUGH)
304	n = sprintf(buf, "WriteThrough\n");
305	else if (ci_attr & CACHE_WRITE_BACK)
306	n = sprintf(buf, "WriteBack\n");
307	return n;
308	}
309
310	static DEVICE_ATTR_RO(level);
311	static DEVICE_ATTR_RO(type);
312	static DEVICE_ATTR_RO(coherency_line_size);
313	static DEVICE_ATTR_RO(ways_of_associativity);
314	static DEVICE_ATTR_RO(number_of_sets);
315	static DEVICE_ATTR_RO(size);
316	static DEVICE_ATTR_RO(allocation_policy);
317	static DEVICE_ATTR_RO(write_policy);
318	static DEVICE_ATTR_RO(shared_cpu_map);
319	static DEVICE_ATTR_RO(shared_cpu_list);
320	static DEVICE_ATTR_RO(physical_line_partition);
321
322	static struct attribute *cache_default_attrs[] = {
323	&dev_attr_type.attr,
324	&dev_attr_level.attr,
325	&dev_attr_shared_cpu_map.attr,
326	&dev_attr_shared_cpu_list.attr,
327	&dev_attr_coherency_line_size.attr,
328	&dev_attr_ways_of_associativity.attr,
329	&dev_attr_number_of_sets.attr,
330	&dev_attr_size.attr,
331	&dev_attr_allocation_policy.attr,
332	&dev_attr_write_policy.attr,
333	&dev_attr_physical_line_partition.attr,
334	NULL
335	};
336
337	static umode_t
338	cache_default_attrs_is_visible(struct kobject *kobj,
339	struct attribute *attr, int unused)
340	{
341	struct device *dev = kobj_to_dev(kobj);
342	struct cacheinfo *this_leaf = dev_get_drvdata(dev);
343	const struct cpumask *mask = &this_leaf->shared_cpu_map;
344	umode_t mode = attr->mode;
345
346	if ((attr == &dev_attr_type.attr) && this_leaf->type)
347	return mode;
348	if ((attr == &dev_attr_level.attr) && this_leaf->level)
349	return mode;
350	if ((attr == &dev_attr_shared_cpu_map.attr) && !cpumask_empty(mask))
351	return mode;
352	if ((attr == &dev_attr_shared_cpu_list.attr) && !cpumask_empty(mask))
353	return mode;
354	if ((attr == &dev_attr_coherency_line_size.attr) &&
355	this_leaf->coherency_line_size)
356	return mode;
357	if ((attr == &dev_attr_ways_of_associativity.attr) &&
358	this_leaf->size) /* allow 0 = full associativity */
359	return mode;
360	if ((attr == &dev_attr_number_of_sets.attr) &&
361	this_leaf->number_of_sets)
362	return mode;
363	if ((attr == &dev_attr_size.attr) && this_leaf->size)
364	return mode;
365	if ((attr == &dev_attr_write_policy.attr) &&
366	(this_leaf->attributes & CACHE_WRITE_POLICY_MASK))
367	return mode;
368	if ((attr == &dev_attr_allocation_policy.attr) &&
369	(this_leaf->attributes & CACHE_ALLOCATE_POLICY_MASK))
370	return mode;
371	if ((attr == &dev_attr_physical_line_partition.attr) &&
372	this_leaf->physical_line_partition)
373	return mode;
374
375	return 0;
376	}
377
378	static const struct attribute_group cache_default_group = {
379	.attrs = cache_default_attrs,
380	.is_visible = cache_default_attrs_is_visible,
381	};
382
383	static const struct attribute_group *cache_default_groups[] = {
384	&cache_default_group,
385	NULL,
386	};
387
388	static const struct attribute_group *cache_private_groups[] = {
389	&cache_default_group,
390	NULL, /* Place holder for private group */
391	NULL,
392	};
393
394	const struct attribute_group *
395	__weak cache_get_priv_group(struct cacheinfo *this_leaf)
396	{
397	return NULL;
398	}
399
400	static const struct attribute_group **
401	cache_get_attribute_groups(struct cacheinfo *this_leaf)
402	{
403	const struct attribute_group *priv_group =
404	cache_get_priv_group(this_leaf);
405
406	if (!priv_group)
407	return cache_default_groups;
408
409	if (!cache_private_groups[1])
410	cache_private_groups[1] = priv_group;
411
412	return cache_private_groups;
413	}
414
415	/* Add/Remove cache interface for CPU device */
416	static void cpu_cache_sysfs_exit(unsigned int cpu)
417	{
418	int i;
419	struct device *ci_dev;
420
421	if (per_cpu_index_dev(cpu)) {
422	for (i = 0; i < cache_leaves(cpu); i++) {
423	ci_dev = per_cache_index_dev(cpu, i);
424	if (!ci_dev)
425	continue;
426	device_unregister(ci_dev);
427	}
428	kfree(per_cpu_index_dev(cpu));
429	per_cpu_index_dev(cpu) = NULL;
430	}
431	device_unregister(per_cpu_cache_dev(cpu));
432	per_cpu_cache_dev(cpu) = NULL;
433	}
434
435	static int cpu_cache_sysfs_init(unsigned int cpu)
436	{
437	struct device *dev = get_cpu_device(cpu);
438
439	if (per_cpu_cacheinfo(cpu) == NULL)
440	return -ENOENT;
441
442	per_cpu_cache_dev(cpu) = cpu_device_create(dev, NULL, NULL, "cache");
443	if (IS_ERR(per_cpu_cache_dev(cpu)))
444	return PTR_ERR(per_cpu_cache_dev(cpu));
445
446	/* Allocate all required memory */
447	per_cpu_index_dev(cpu) = kcalloc(cache_leaves(cpu),
448	sizeof(struct device *), GFP_KERNEL);
449	if (unlikely(per_cpu_index_dev(cpu) == NULL))
450	goto err_out;
451
452	return 0;
453
454	err_out:
455	cpu_cache_sysfs_exit(cpu);
456	return -ENOMEM;
457	}
458
459	static int cache_add_dev(unsigned int cpu)
460	{
461	unsigned int i;
462	int rc;
463	struct device ci_dev, parent;
464	struct cacheinfo *this_leaf;
465	struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu);
466	const struct attribute_group **cache_groups;
467
468	rc = cpu_cache_sysfs_init(cpu);
469	if (unlikely(rc < 0))
470	return rc;
471
472	parent = per_cpu_cache_dev(cpu);
473	for (i = 0; i < cache_leaves(cpu); i++) {
474	this_leaf = this_cpu_ci->info_list + i;
475	if (this_leaf->disable_sysfs)
476	continue;
477	cache_groups = cache_get_attribute_groups(this_leaf);
478	ci_dev = cpu_device_create(parent, this_leaf, cache_groups,
479	"index%1u", i);
480	if (IS_ERR(ci_dev)) {
481	rc = PTR_ERR(ci_dev);
482	goto err;
483	}
484	per_cache_index_dev(cpu, i) = ci_dev;
485	}
486	cpumask_set_cpu(cpu, &cache_dev_map);
487
488	return 0;
489	err:
490	cpu_cache_sysfs_exit(cpu);
491	return rc;
492	}
493
494	static void cache_remove_dev(unsigned int cpu)
495	{
496	if (!cpumask_test_cpu(cpu, &cache_dev_map))
497	return;
498	cpumask_clear_cpu(cpu, &cache_dev_map);
499
500	cpu_cache_sysfs_exit(cpu);
501	}
502
503	static int cacheinfo_cpu_callback(struct notifier_block *nfb,
504	unsigned long action, void *hcpu)
505	{
506	unsigned int cpu = (unsigned long)hcpu;
507	int rc = 0;
508
509	switch (action & ~CPU_TASKS_FROZEN) {
510	case CPU_ONLINE:
511	rc = detect_cache_attributes(cpu);
512	if (!rc)
513	rc = cache_add_dev(cpu);
514	break;
515	case CPU_DEAD:
516	cache_remove_dev(cpu);
517	if (per_cpu_cacheinfo(cpu))
518	free_cache_attributes(cpu);
519	break;
520	}
521	return notifier_from_errno(rc);
522	}
523
524	static int __init cacheinfo_sysfs_init(void)
525	{
526	int cpu, rc = 0;
527
528	cpu_notifier_register_begin();
529
530	for_each_online_cpu(cpu) {
531	rc = detect_cache_attributes(cpu);
6df43c9b	532	if (rc)
246246cb	533	goto out;
246246cb SH	534	rc = cache_add_dev(cpu);
	535	if (rc) {
	536	free_cache_attributes(cpu);
	537	pr_err("error populating cacheinfo..cpu%d\n", cpu);
	538	goto out;
	539	}
	540	}
	541	__hotcpu_notifier(cacheinfo_cpu_callback, 0);
	542
	543	out:
	544	cpu_notifier_register_done();
	545	return rc;
	546	}
	547
	548	device_initcall(cacheinfo_sysfs_init);