[deliverable/linux.git] / drivers / cpuidle / sysfs.c

/*
 * sysfs.c - sysfs support
 *
 * (C) 2006-2007 Shaohua Li <shaohua.li@intel.com>
 *
 * This code is licenced under the GPL.
 */

#include <linux/kernel.h>
#include <linux/cpuidle.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/cpu.h>
#include <linux/completion.h>
#include <linux/capability.h>
#include <linux/device.h>
#include <linux/kobject.h>

#include "cpuidle.h"

static unsigned int sysfs_switch;
static int __init cpuidle_sysfs_setup(char *unused)
{
	sysfs_switch = 1;
	return 1;
}
__setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);

static ssize_t show_available_governors(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	ssize_t i = 0;
	struct cpuidle_governor *tmp;

	mutex_lock(&cpuidle_lock);
	list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
		if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) -
				    CPUIDLE_NAME_LEN - 2))
			goto out;
		i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
	}

out:
	i+= sprintf(&buf[i], "\n");
	mutex_unlock(&cpuidle_lock);
	return i;
}

static ssize_t show_current_driver(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	ssize_t ret;
	struct cpuidle_driver *drv;

	spin_lock(&cpuidle_driver_lock);
	drv = cpuidle_get_driver();
	if (drv)
		ret = sprintf(buf, "%s\n", drv->name);
	else
		ret = sprintf(buf, "none\n");
	spin_unlock(&cpuidle_driver_lock);

	return ret;
}

static ssize_t show_current_governor(struct device *dev,
				     struct device_attribute *attr,
				     char *buf)
{
	ssize_t ret;

	mutex_lock(&cpuidle_lock);
	if (cpuidle_curr_governor)
		ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
	else
		ret = sprintf(buf, "none\n");
	mutex_unlock(&cpuidle_lock);

	return ret;
}

static ssize_t store_current_governor(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf, size_t count)
{
	char gov_name[CPUIDLE_NAME_LEN];
	int ret = -EINVAL;
	size_t len = count;
	struct cpuidle_governor *gov;

	if (!len || len >= sizeof(gov_name))
		return -EINVAL;

	memcpy(gov_name, buf, len);
	gov_name[len] = '\0';
	if (gov_name[len - 1] == '\n')
		gov_name[--len] = '\0';

	mutex_lock(&cpuidle_lock);

	list_for_each_entry(gov, &cpuidle_governors, governor_list) {
		if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
			ret = cpuidle_switch_governor(gov);
			break;
		}
	}

	mutex_unlock(&cpuidle_lock);

	if (ret)
		return ret;
	else
		return count;
}

static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);
static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);

static struct attribute *cpuidle_default_attrs[] = {
	&dev_attr_current_driver.attr,
	&dev_attr_current_governor_ro.attr,
	NULL
};

static DEVICE_ATTR(available_governors, 0444, show_available_governors, NULL);
static DEVICE_ATTR(current_governor, 0644, show_current_governor,
		   store_current_governor);

static struct attribute *cpuidle_switch_attrs[] = {
	&dev_attr_available_governors.attr,
	&dev_attr_current_driver.attr,
	&dev_attr_current_governor.attr,
	NULL
};

static struct attribute_group cpuidle_attr_group = {
	.attrs = cpuidle_default_attrs,
	.name = "cpuidle",
};

/**
 * cpuidle_add_interface - add CPU global sysfs attributes
 */
int cpuidle_add_interface(struct device *dev)
{
	if (sysfs_switch)
		cpuidle_attr_group.attrs = cpuidle_switch_attrs;

	return sysfs_create_group(&dev->kobj, &cpuidle_attr_group);
}

/**
 * cpuidle_remove_interface - remove CPU global sysfs attributes
 */
void cpuidle_remove_interface(struct device *dev)
{
	sysfs_remove_group(&dev->kobj, &cpuidle_attr_group);
}

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

#define define_one_ro(_name, show) \
	static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
#define define_one_rw(_name, show, store) \
	static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)

#define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)

struct cpuidle_device_kobj {
	struct cpuidle_device *dev;
	struct completion kobj_unregister;
	struct kobject kobj;
};

static inline struct cpuidle_device *to_cpuidle_device(struct kobject *kobj)
{
	struct cpuidle_device_kobj *kdev =
		container_of(kobj, struct cpuidle_device_kobj, kobj);

	return kdev->dev;
}

static ssize_t cpuidle_show(struct kobject *kobj, struct attribute *attr,
			    char *buf)
{
	int ret = -EIO;
	struct cpuidle_device *dev = to_cpuidle_device(kobj);
	struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);

	if (cattr->show) {
		mutex_lock(&cpuidle_lock);
		ret = cattr->show(dev, buf);
		mutex_unlock(&cpuidle_lock);
	}
	return ret;
}

static ssize_t cpuidle_store(struct kobject *kobj, struct attribute *attr,
			     const char *buf, size_t count)
{
	int ret = -EIO;
	struct cpuidle_device *dev = to_cpuidle_device(kobj);
	struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);

	if (cattr->store) {
		mutex_lock(&cpuidle_lock);
		ret = cattr->store(dev, buf, count);
		mutex_unlock(&cpuidle_lock);
	}
	return ret;
}

static const struct sysfs_ops cpuidle_sysfs_ops = {
	.show = cpuidle_show,
	.store = cpuidle_store,
};

static void cpuidle_sysfs_release(struct kobject *kobj)
{
	struct cpuidle_device_kobj *kdev =
		container_of(kobj, struct cpuidle_device_kobj, kobj);

	complete(&kdev->kobj_unregister);
}

static struct kobj_type ktype_cpuidle = {
	.sysfs_ops = &cpuidle_sysfs_ops,
	.release = cpuidle_sysfs_release,
};

struct cpuidle_state_attr {
	struct attribute attr;
	ssize_t (*show)(struct cpuidle_state *, \
					struct cpuidle_state_usage *, char *);
	ssize_t (*store)(struct cpuidle_state *, \
			struct cpuidle_state_usage *, const char *, size_t);
};

#define define_one_state_ro(_name, show) \
static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)

#define define_one_state_rw(_name, show, store) \
static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0644, show, store)

#define define_show_state_function(_name) \
static ssize_t show_state_##_name(struct cpuidle_state *state, \
			 struct cpuidle_state_usage *state_usage, char *buf) \
{ \
	return sprintf(buf, "%u\n", state->_name);\
}

#define define_store_state_ull_function(_name) \
static ssize_t store_state_##_name(struct cpuidle_state *state, \
				   struct cpuidle_state_usage *state_usage, \
				   const char *buf, size_t size)	\
{ \
	unsigned long long value; \
	int err; \
	if (!capable(CAP_SYS_ADMIN)) \
		return -EPERM; \
	err = kstrtoull(buf, 0, &value); \
	if (err) \
		return err; \
	if (value) \
		state_usage->_name = 1; \
	else \
		state_usage->_name = 0; \
	return size; \
}

#define define_show_state_ull_function(_name) \
static ssize_t show_state_##_name(struct cpuidle_state *state, \
				  struct cpuidle_state_usage *state_usage, \
				  char *buf)				\
{ \
	return sprintf(buf, "%llu\n", state_usage->_name);\
}

#define define_show_state_str_function(_name) \
static ssize_t show_state_##_name(struct cpuidle_state *state, \
				  struct cpuidle_state_usage *state_usage, \
				  char *buf)				\
{ \
	if (state->_name[0] == '\0')\
		return sprintf(buf, "<null>\n");\
	return sprintf(buf, "%s\n", state->_name);\
}

define_show_state_function(exit_latency)
define_show_state_function(target_residency)
define_show_state_function(power_usage)
define_show_state_ull_function(usage)
define_show_state_ull_function(time)
define_show_state_str_function(name)
define_show_state_str_function(desc)
define_show_state_ull_function(disable)
define_store_state_ull_function(disable)

define_one_state_ro(name, show_state_name);
define_one_state_ro(desc, show_state_desc);
define_one_state_ro(latency, show_state_exit_latency);
define_one_state_ro(residency, show_state_target_residency);
define_one_state_ro(power, show_state_power_usage);
define_one_state_ro(usage, show_state_usage);
define_one_state_ro(time, show_state_time);
define_one_state_rw(disable, show_state_disable, store_state_disable);

static struct attribute *cpuidle_state_default_attrs[] = {
	&attr_name.attr,
	&attr_desc.attr,
	&attr_latency.attr,
	&attr_residency.attr,
	&attr_power.attr,
	&attr_usage.attr,
	&attr_time.attr,
	&attr_disable.attr,
	NULL
};

struct cpuidle_state_kobj {
	struct cpuidle_state *state;
	struct cpuidle_state_usage *state_usage;
	struct completion kobj_unregister;
	struct kobject kobj;
};

#define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
#define kobj_to_state(k) (kobj_to_state_obj(k)->state)
#define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage)
#define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)

static ssize_t cpuidle_state_show(struct kobject *kobj, struct attribute *attr,
				  char * buf)
{
	int ret = -EIO;
	struct cpuidle_state *state = kobj_to_state(kobj);
	struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
	struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);

	if (cattr->show)
		ret = cattr->show(state, state_usage, buf);

	return ret;
}

static ssize_t cpuidle_state_store(struct kobject *kobj, struct attribute *attr,
				   const char *buf, size_t size)
{
	int ret = -EIO;
	struct cpuidle_state *state = kobj_to_state(kobj);
	struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
	struct cpuidle_state_attr *cattr = attr_to_stateattr(attr);

	if (cattr->store)
		ret = cattr->store(state, state_usage, buf, size);

	return ret;
}

static const struct sysfs_ops cpuidle_state_sysfs_ops = {
	.show = cpuidle_state_show,
	.store = cpuidle_state_store,
};

static void cpuidle_state_sysfs_release(struct kobject *kobj)
{
	struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);

	complete(&state_obj->kobj_unregister);
}

static struct kobj_type ktype_state_cpuidle = {
	.sysfs_ops = &cpuidle_state_sysfs_ops,
	.default_attrs = cpuidle_state_default_attrs,
	.release = cpuidle_state_sysfs_release,
};

static inline void cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
{
	kobject_put(&device->kobjs[i]->kobj);
	wait_for_completion(&device->kobjs[i]->kobj_unregister);
	kfree(device->kobjs[i]);
	device->kobjs[i] = NULL;
}

/**
 * cpuidle_add_state_sysfs - adds cpuidle states sysfs attributes
 * @device: the target device
 */
static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
{
	int i, ret = -ENOMEM;
	struct cpuidle_state_kobj *kobj;
	struct cpuidle_device_kobj *kdev = device->kobj_dev;
	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);

	/* state statistics */
	for (i = 0; i < drv->state_count; i++) {
		kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
		if (!kobj)
			goto error_state;
		kobj->state = &drv->states[i];
		kobj->state_usage = &device->states_usage[i];
		init_completion(&kobj->kobj_unregister);

		ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,
					   &kdev->kobj, "state%d", i);
		if (ret) {
			kfree(kobj);
			goto error_state;
		}
		kobject_uevent(&kobj->kobj, KOBJ_ADD);
		device->kobjs[i] = kobj;
	}

	return 0;

error_state:
	for (i = i - 1; i >= 0; i--)
		cpuidle_free_state_kobj(device, i);
	return ret;
}

/**
 * cpuidle_remove_driver_sysfs - removes the cpuidle states sysfs attributes
 * @device: the target device
 */
static void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
{
	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
	int i;

	for (i = 0; i < drv->state_count; i++)
		cpuidle_free_state_kobj(device, i);
}

#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
#define kobj_to_driver_kobj(k) container_of(k, struct cpuidle_driver_kobj, kobj)
#define attr_to_driver_attr(a) container_of(a, struct cpuidle_driver_attr, attr)

#define define_one_driver_ro(_name, show)                       \
	static struct cpuidle_driver_attr attr_driver_##_name = \
		__ATTR(_name, 0444, show, NULL)

struct cpuidle_driver_kobj {
	struct cpuidle_driver *drv;
	struct completion kobj_unregister;
	struct kobject kobj;
};

struct cpuidle_driver_attr {
	struct attribute attr;
	ssize_t (*show)(struct cpuidle_driver *, char *);
	ssize_t (*store)(struct cpuidle_driver *, const char *, size_t);
};

static ssize_t show_driver_name(struct cpuidle_driver *drv, char *buf)
{
	ssize_t ret;

	spin_lock(&cpuidle_driver_lock);
	ret = sprintf(buf, "%s\n", drv ? drv->name : "none");
	spin_unlock(&cpuidle_driver_lock);

	return ret;
}

static void cpuidle_driver_sysfs_release(struct kobject *kobj)
{
	struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
	complete(&driver_kobj->kobj_unregister);
}

static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute *attr,
				   char *buf)
{
	int ret = -EIO;
	struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
	struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);

	if (dattr->show)
		ret = dattr->show(driver_kobj->drv, buf);

	return ret;
}

static ssize_t cpuidle_driver_store(struct kobject *kobj, struct attribute *attr,
				    const char *buf, size_t size)
{
	int ret = -EIO;
	struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
	struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);

	if (dattr->store)
		ret = dattr->store(driver_kobj->drv, buf, size);

	return ret;
}

define_one_driver_ro(name, show_driver_name);

static const struct sysfs_ops cpuidle_driver_sysfs_ops = {
	.show = cpuidle_driver_show,
	.store = cpuidle_driver_store,
};

static struct attribute *cpuidle_driver_default_attrs[] = {
	&attr_driver_name.attr,
	NULL
};

static struct kobj_type ktype_driver_cpuidle = {
	.sysfs_ops = &cpuidle_driver_sysfs_ops,
	.default_attrs = cpuidle_driver_default_attrs,
	.release = cpuidle_driver_sysfs_release,
};

/**
 * cpuidle_add_driver_sysfs - adds the driver name sysfs attribute
 * @device: the target device
 */
static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
{
	struct cpuidle_driver_kobj *kdrv;
	struct cpuidle_device_kobj *kdev = dev->kobj_dev;
	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
	int ret;

	kdrv = kzalloc(sizeof(*kdrv), GFP_KERNEL);
	if (!kdrv)
		return -ENOMEM;

	kdrv->drv = drv;
	init_completion(&kdrv->kobj_unregister);

	ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,
				   &kdev->kobj, "driver");
	if (ret) {
		kfree(kdrv);
		return ret;
	}

	kobject_uevent(&kdrv->kobj, KOBJ_ADD);
	dev->kobj_driver = kdrv;

	return ret;
}

/**
 * cpuidle_remove_driver_sysfs - removes the driver name sysfs attribute
 * @device: the target device
 */
static void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
{
	struct cpuidle_driver_kobj *kdrv = dev->kobj_driver;
	kobject_put(&kdrv->kobj);
	wait_for_completion(&kdrv->kobj_unregister);
	kfree(kdrv);
}
#else
static inline int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
{
	return 0;
}

static inline void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
{
	;
}
#endif

/**
 * cpuidle_add_device_sysfs - adds device specific sysfs attributes
 * @device: the target device
 */
int cpuidle_add_device_sysfs(struct cpuidle_device *device)
{
	int ret;

	ret = cpuidle_add_state_sysfs(device);
	if (ret)
		return ret;

	ret = cpuidle_add_driver_sysfs(device);
	if (ret)
		cpuidle_remove_state_sysfs(device);
	return ret;
}

/**
 * cpuidle_remove_device_sysfs : removes device specific sysfs attributes
 * @device : the target device
 */
void cpuidle_remove_device_sysfs(struct cpuidle_device *device)
{
	cpuidle_remove_driver_sysfs(device);
	cpuidle_remove_state_sysfs(device);
}

/**
 * cpuidle_add_sysfs - creates a sysfs instance for the target device
 * @dev: the target device
 */
int cpuidle_add_sysfs(struct cpuidle_device *dev)
{
	struct cpuidle_device_kobj *kdev;
	struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
	int error;

	kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
	if (!kdev)
		return -ENOMEM;
	kdev->dev = dev;
	dev->kobj_dev = kdev;

	init_completion(&kdev->kobj_unregister);

	error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
				   "cpuidle");
	if (error) {
		kfree(kdev);
		return error;
	}

	kobject_uevent(&kdev->kobj, KOBJ_ADD);

	return 0;
}

/**
 * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
 * @dev: the target device
 */
void cpuidle_remove_sysfs(struct cpuidle_device *dev)
{
	struct cpuidle_device_kobj *kdev = dev->kobj_dev;

	kobject_put(&kdev->kobj);
	wait_for_completion(&kdev->kobj_unregister);
	kfree(kdev);
}
Commit	Line	Data
4f86d3a8 LB	1	/*
	2	* sysfs.c - sysfs support
	3	*
	4	* (C) 2006-2007 Shaohua Li <shaohua.li@intel.com>
	5	*
	6	* This code is licenced under the GPL.
	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/cpuidle.h>
	11	#include <linux/sysfs.h>
5a0e3ad6	12	#include <linux/slab.h>
4f86d3a8	13	#include <linux/cpu.h>
728ce22b	14	#include <linux/completion.h>
3a53396b	15	#include <linux/capability.h>
8f3e9953	16	#include <linux/device.h>
728ce22b	17	#include <linux/kobject.h>
4f86d3a8 LB	18
	19	#include "cpuidle.h"
	20
	21	static unsigned int sysfs_switch;
	22	static int __init cpuidle_sysfs_setup(char *unused)
	23	{
	24	sysfs_switch = 1;
	25	return 1;
	26	}
	27	__setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
	28
8a25a2fd KS	29	static ssize_t show_available_governors(struct device *dev,
8a25a2fd KS	30	struct device_attribute *attr,
66198f36	31	char *buf)
4f86d3a8 LB	32	{
	33	ssize_t i = 0;
	34	struct cpuidle_governor *tmp;
	35
	36	mutex_lock(&cpuidle_lock);
	37	list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
f89ae89e DL	38	if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) -
f89ae89e DL	39	CPUIDLE_NAME_LEN - 2))
4f86d3a8 LB	40	goto out;
	41	i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
	42	}
	43
	44	out:
	45	i+= sprintf(&buf[i], "\n");
	46	mutex_unlock(&cpuidle_lock);
	47	return i;
	48	}
	49
8a25a2fd KS	50	static ssize_t show_current_driver(struct device *dev,
8a25a2fd KS	51	struct device_attribute *attr,
66198f36	52	char *buf)
4f86d3a8 LB	53	{
4f86d3a8 LB	54	ssize_t ret;
1f6b9f74	55	struct cpuidle_driver *drv;
4f86d3a8 LB	56
4f86d3a8 LB	57	spin_lock(&cpuidle_driver_lock);
1f6b9f74 VK	58	drv = cpuidle_get_driver();
	59	if (drv)
	60	ret = sprintf(buf, "%s\n", drv->name);
4f86d3a8 LB	61	else
	62	ret = sprintf(buf, "none\n");
	63	spin_unlock(&cpuidle_driver_lock);
	64
	65	return ret;
	66	}
	67
8a25a2fd KS	68	static ssize_t show_current_governor(struct device *dev,
8a25a2fd KS	69	struct device_attribute *attr,
66198f36	70	char *buf)
4f86d3a8 LB	71	{
	72	ssize_t ret;
	73
	74	mutex_lock(&cpuidle_lock);
	75	if (cpuidle_curr_governor)
	76	ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
	77	else
	78	ret = sprintf(buf, "none\n");
	79	mutex_unlock(&cpuidle_lock);
	80
	81	return ret;
	82	}
	83
8a25a2fd KS	84	static ssize_t store_current_governor(struct device *dev,
8a25a2fd KS	85	struct device_attribute *attr,
66198f36	86	const char *buf, size_t count)
4f86d3a8 LB	87	{
	88	char gov_name[CPUIDLE_NAME_LEN];
	89	int ret = -EINVAL;
	90	size_t len = count;
	91	struct cpuidle_governor *gov;
	92
	93	if (!len \|\| len >= sizeof(gov_name))
	94	return -EINVAL;
	95
	96	memcpy(gov_name, buf, len);
	97	gov_name[len] = '\0';
	98	if (gov_name[len - 1] == '\n')
	99	gov_name[--len] = '\0';
	100
	101	mutex_lock(&cpuidle_lock);
	102
	103	list_for_each_entry(gov, &cpuidle_governors, governor_list) {
	104	if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
	105	ret = cpuidle_switch_governor(gov);
	106	break;
	107	}
	108	}
	109
	110	mutex_unlock(&cpuidle_lock);
	111
	112	if (ret)
	113	return ret;
	114	else
	115	return count;
	116	}
	117
8a25a2fd KS	118	static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);
8a25a2fd KS	119	static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
4f86d3a8	120
8a25a2fd KS	121	static struct attribute *cpuidle_default_attrs[] = {
	122	&dev_attr_current_driver.attr,
	123	&dev_attr_current_governor_ro.attr,
4f86d3a8 LB	124	NULL
	125	};
	126
8a25a2fd KS	127	static DEVICE_ATTR(available_governors, 0444, show_available_governors, NULL);
	128	static DEVICE_ATTR(current_governor, 0644, show_current_governor,
	129	store_current_governor);
4f86d3a8	130
8a25a2fd KS	131	static struct attribute *cpuidle_switch_attrs[] = {
	132	&dev_attr_available_governors.attr,
	133	&dev_attr_current_driver.attr,
	134	&dev_attr_current_governor.attr,
4f86d3a8 LB	135	NULL
	136	};
	137
8a25a2fd KS	138	static struct attribute_group cpuidle_attr_group = {
8a25a2fd KS	139	.attrs = cpuidle_default_attrs,
4f86d3a8 LB	140	.name = "cpuidle",
	141	};
	142
	143	/**
8a25a2fd	144	* cpuidle_add_interface - add CPU global sysfs attributes
4f86d3a8	145	*/
8a25a2fd	146	int cpuidle_add_interface(struct device *dev)
4f86d3a8 LB	147	{
4f86d3a8 LB	148	if (sysfs_switch)
8a25a2fd	149	cpuidle_attr_group.attrs = cpuidle_switch_attrs;
4f86d3a8	150
8a25a2fd	151	return sysfs_create_group(&dev->kobj, &cpuidle_attr_group);
4f86d3a8 LB	152	}
	153
	154	/**
8a25a2fd	155	* cpuidle_remove_interface - remove CPU global sysfs attributes
4f86d3a8	156	*/
8a25a2fd	157	void cpuidle_remove_interface(struct device *dev)
4f86d3a8	158	{
8a25a2fd	159	sysfs_remove_group(&dev->kobj, &cpuidle_attr_group);
4f86d3a8 LB	160	}
	161
	162	struct cpuidle_attr {
	163	struct attribute attr;
	164	ssize_t (show)(struct cpuidle_device , char *);
	165	ssize_t (store)(struct cpuidle_device , const char *, size_t count);
	166	};
	167
	168	#define define_one_ro(_name, show) \
	169	static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
	170	#define define_one_rw(_name, show, store) \
	171	static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
	172
4f86d3a8	173	#define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
f89ae89e	174
728ce22b DL	175	struct cpuidle_device_kobj {
	176	struct cpuidle_device *dev;
	177	struct completion kobj_unregister;
	178	struct kobject kobj;
	179	};
	180
	181	static inline struct cpuidle_device to_cpuidle_device(struct kobject kobj)
	182	{
	183	struct cpuidle_device_kobj *kdev =
	184	container_of(kobj, struct cpuidle_device_kobj, kobj);
	185
	186	return kdev->dev;
	187	}
	188
f89ae89e DL	189	static ssize_t cpuidle_show(struct kobject kobj, struct attribute attr,
f89ae89e DL	190	char *buf)
4f86d3a8 LB	191	{
4f86d3a8 LB	192	int ret = -EIO;
728ce22b	193	struct cpuidle_device *dev = to_cpuidle_device(kobj);
f89ae89e	194	struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
4f86d3a8 LB	195
	196	if (cattr->show) {
	197	mutex_lock(&cpuidle_lock);
	198	ret = cattr->show(dev, buf);
	199	mutex_unlock(&cpuidle_lock);
	200	}
	201	return ret;
	202	}
	203
f89ae89e DL	204	static ssize_t cpuidle_store(struct kobject kobj, struct attribute attr,
f89ae89e DL	205	const char *buf, size_t count)
4f86d3a8 LB	206	{
4f86d3a8 LB	207	int ret = -EIO;
728ce22b	208	struct cpuidle_device *dev = to_cpuidle_device(kobj);
f89ae89e	209	struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
4f86d3a8 LB	210
	211	if (cattr->store) {
	212	mutex_lock(&cpuidle_lock);
	213	ret = cattr->store(dev, buf, count);
	214	mutex_unlock(&cpuidle_lock);
	215	}
	216	return ret;
	217	}
	218
52cf25d0	219	static const struct sysfs_ops cpuidle_sysfs_ops = {
4f86d3a8 LB	220	.show = cpuidle_show,
	221	.store = cpuidle_store,
	222	};
	223
	224	static void cpuidle_sysfs_release(struct kobject *kobj)
	225	{
728ce22b DL	226	struct cpuidle_device_kobj *kdev =
728ce22b DL	227	container_of(kobj, struct cpuidle_device_kobj, kobj);
4f86d3a8	228
728ce22b	229	complete(&kdev->kobj_unregister);
4f86d3a8 LB	230	}
	231
	232	static struct kobj_type ktype_cpuidle = {
	233	.sysfs_ops = &cpuidle_sysfs_ops,
	234	.release = cpuidle_sysfs_release,
	235	};
	236
	237	struct cpuidle_state_attr {
	238	struct attribute attr;
4202735e DD	239	ssize_t (show)(struct cpuidle_state , \
4202735e DD	240	struct cpuidle_state_usage , char );
dc7fd275 SL	241	ssize_t (store)(struct cpuidle_state , \
dc7fd275 SL	242	struct cpuidle_state_usage , const char , size_t);
4f86d3a8 LB	243	};
	244
	245	#define define_one_state_ro(_name, show) \
	246	static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
	247
3a53396b SL	248	#define define_one_state_rw(_name, show, store) \
	249	static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0644, show, store)
	250
4f86d3a8	251	#define define_show_state_function(_name) \
4202735e DD	252	static ssize_t show_state_##_name(struct cpuidle_state *state, \
4202735e DD	253	struct cpuidle_state_usage state_usage, char buf) \
4f86d3a8 LB	254	{ \
	255	return sprintf(buf, "%u\n", state->_name);\
	256	}
	257
dc7fd275	258	#define define_store_state_ull_function(_name) \
3a53396b	259	static ssize_t store_state_##_name(struct cpuidle_state *state, \
f89ae89e DL	260	struct cpuidle_state_usage *state_usage, \
f89ae89e DL	261	const char *buf, size_t size) \
3a53396b	262	{ \
dc7fd275	263	unsigned long long value; \
3a53396b SL	264	int err; \
	265	if (!capable(CAP_SYS_ADMIN)) \
	266	return -EPERM; \
dc7fd275	267	err = kstrtoull(buf, 0, &value); \
3a53396b SL	268	if (err) \
	269	return err; \
	270	if (value) \
dc7fd275	271	state_usage->_name = 1; \
3a53396b	272	else \
dc7fd275	273	state_usage->_name = 0; \
3a53396b SL	274	return size; \
	275	}
	276
8b78cf60	277	#define define_show_state_ull_function(_name) \
4202735e	278	static ssize_t show_state_##_name(struct cpuidle_state *state, \
f89ae89e DL	279	struct cpuidle_state_usage *state_usage, \
f89ae89e DL	280	char *buf) \
8b78cf60	281	{ \
4202735e	282	return sprintf(buf, "%llu\n", state_usage->_name);\
8b78cf60 YY	283	}
8b78cf60 YY	284
4fcb2fcd	285	#define define_show_state_str_function(_name) \
4202735e	286	static ssize_t show_state_##_name(struct cpuidle_state *state, \
f89ae89e DL	287	struct cpuidle_state_usage *state_usage, \
f89ae89e DL	288	char *buf) \
4fcb2fcd VP	289	{ \
	290	if (state->_name[0] == '\0')\
	291	return sprintf(buf, "<null>\n");\
	292	return sprintf(buf, "%s\n", state->_name);\
4f86d3a8 LB	293	}
	294
	295	define_show_state_function(exit_latency)
9bc0482f	296	define_show_state_function(target_residency)
4f86d3a8	297	define_show_state_function(power_usage)
8b78cf60 YY	298	define_show_state_ull_function(usage)
8b78cf60 YY	299	define_show_state_ull_function(time)
4fcb2fcd VP	300	define_show_state_str_function(name)
4fcb2fcd VP	301	define_show_state_str_function(desc)
dc7fd275 SL	302	define_show_state_ull_function(disable)
dc7fd275 SL	303	define_store_state_ull_function(disable)
4fcb2fcd	304
4f86d3a8	305	define_one_state_ro(name, show_state_name);
4fcb2fcd	306	define_one_state_ro(desc, show_state_desc);
4f86d3a8	307	define_one_state_ro(latency, show_state_exit_latency);
9bc0482f	308	define_one_state_ro(residency, show_state_target_residency);
4f86d3a8 LB	309	define_one_state_ro(power, show_state_power_usage);
	310	define_one_state_ro(usage, show_state_usage);
	311	define_one_state_ro(time, show_state_time);
3a53396b	312	define_one_state_rw(disable, show_state_disable, store_state_disable);
4f86d3a8 LB	313
	314	static struct attribute *cpuidle_state_default_attrs[] = {
	315	&attr_name.attr,
4fcb2fcd	316	&attr_desc.attr,
4f86d3a8	317	&attr_latency.attr,
9bc0482f	318	&attr_residency.attr,
4f86d3a8 LB	319	&attr_power.attr,
	320	&attr_usage.attr,
	321	&attr_time.attr,
3a53396b	322	&attr_disable.attr,
4f86d3a8 LB	323	NULL
	324	};
	325
349631e0 DL	326	struct cpuidle_state_kobj {
	327	struct cpuidle_state *state;
	328	struct cpuidle_state_usage *state_usage;
	329	struct completion kobj_unregister;
	330	struct kobject kobj;
	331	};
	332
4f86d3a8 LB	333	#define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
4f86d3a8 LB	334	#define kobj_to_state(k) (kobj_to_state_obj(k)->state)
4202735e	335	#define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage)
4f86d3a8	336	#define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
f89ae89e DL	337
	338	static ssize_t cpuidle_state_show(struct kobject kobj, struct attribute attr,
	339	char * buf)
4f86d3a8 LB	340	{
	341	int ret = -EIO;
	342	struct cpuidle_state *state = kobj_to_state(kobj);
4202735e	343	struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
4f86d3a8 LB	344	struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);
	345
	346	if (cattr->show)
4202735e	347	ret = cattr->show(state, state_usage, buf);
4f86d3a8 LB	348
	349	return ret;
	350	}
	351
f89ae89e DL	352	static ssize_t cpuidle_state_store(struct kobject kobj, struct attribute attr,
f89ae89e DL	353	const char *buf, size_t size)
3a53396b SL	354	{
	355	int ret = -EIO;
	356	struct cpuidle_state *state = kobj_to_state(kobj);
dc7fd275	357	struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
3a53396b SL	358	struct cpuidle_state_attr *cattr = attr_to_stateattr(attr);
	359
	360	if (cattr->store)
dc7fd275	361	ret = cattr->store(state, state_usage, buf, size);
3a53396b SL	362
	363	return ret;
	364	}
	365
52cf25d0	366	static const struct sysfs_ops cpuidle_state_sysfs_ops = {
4f86d3a8	367	.show = cpuidle_state_show,
3a53396b	368	.store = cpuidle_state_store,
4f86d3a8 LB	369	};
	370
	371	static void cpuidle_state_sysfs_release(struct kobject *kobj)
	372	{
	373	struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);
	374
	375	complete(&state_obj->kobj_unregister);
	376	}
	377
	378	static struct kobj_type ktype_state_cpuidle = {
	379	.sysfs_ops = &cpuidle_state_sysfs_ops,
	380	.default_attrs = cpuidle_state_default_attrs,
	381	.release = cpuidle_state_sysfs_release,
	382	};
	383
42b16b3f	384	static inline void cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
4f86d3a8	385	{
c10997f6	386	kobject_put(&device->kobjs[i]->kobj);
4f86d3a8 LB	387	wait_for_completion(&device->kobjs[i]->kobj_unregister);
	388	kfree(device->kobjs[i]);
	389	device->kobjs[i] = NULL;
	390	}
	391
	392	/**
bf4d1b5d	393	* cpuidle_add_state_sysfs - adds cpuidle states sysfs attributes
4f86d3a8 LB	394	* @device: the target device
4f86d3a8 LB	395	*/
bf4d1b5d	396	static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
4f86d3a8 LB	397	{
	398	int i, ret = -ENOMEM;
	399	struct cpuidle_state_kobj *kobj;
728ce22b	400	struct cpuidle_device_kobj *kdev = device->kobj_dev;
bf4d1b5d	401	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
4f86d3a8 LB	402
4f86d3a8 LB	403	/* state statistics */
d75e4af1	404	for (i = 0; i < drv->state_count; i++) {
4f86d3a8 LB	405	kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
	406	if (!kobj)
	407	goto error_state;
46bcfad7	408	kobj->state = &drv->states[i];
4202735e	409	kobj->state_usage = &device->states_usage[i];
4f86d3a8 LB	410	init_completion(&kobj->kobj_unregister);
4f86d3a8 LB	411
e45a00d6	412	ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,
728ce22b	413	&kdev->kobj, "state%d", i);
4f86d3a8 LB	414	if (ret) {
	415	kfree(kobj);
	416	goto error_state;
	417	}
94f57f33	418	kobject_uevent(&kobj->kobj, KOBJ_ADD);
4f86d3a8 LB	419	device->kobjs[i] = kobj;
	420	}
	421
	422	return 0;
	423
	424	error_state:
	425	for (i = i - 1; i >= 0; i--)
	426	cpuidle_free_state_kobj(device, i);
	427	return ret;
	428	}
	429
	430	/**
bf4d1b5d	431	* cpuidle_remove_driver_sysfs - removes the cpuidle states sysfs attributes
4f86d3a8 LB	432	* @device: the target device
4f86d3a8 LB	433	*/
bf4d1b5d	434	static void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
4f86d3a8	435	{
d75e4af1	436	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
4f86d3a8 LB	437	int i;
4f86d3a8 LB	438
d75e4af1	439	for (i = 0; i < drv->state_count; i++)
4f86d3a8 LB	440	cpuidle_free_state_kobj(device, i);
	441	}
	442
bf4d1b5d DL	443	#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
	444	#define kobj_to_driver_kobj(k) container_of(k, struct cpuidle_driver_kobj, kobj)
	445	#define attr_to_driver_attr(a) container_of(a, struct cpuidle_driver_attr, attr)
	446
	447	#define define_one_driver_ro(_name, show) \
	448	static struct cpuidle_driver_attr attr_driver_##_name = \
4f8eea9b	449	__ATTR(_name, 0444, show, NULL)
bf4d1b5d DL	450
	451	struct cpuidle_driver_kobj {
	452	struct cpuidle_driver *drv;
	453	struct completion kobj_unregister;
	454	struct kobject kobj;
	455	};
	456
	457	struct cpuidle_driver_attr {
	458	struct attribute attr;
	459	ssize_t (show)(struct cpuidle_driver , char *);
	460	ssize_t (store)(struct cpuidle_driver , const char *, size_t);
	461	};
	462
	463	static ssize_t show_driver_name(struct cpuidle_driver drv, char buf)
	464	{
	465	ssize_t ret;
	466
	467	spin_lock(&cpuidle_driver_lock);
	468	ret = sprintf(buf, "%s\n", drv ? drv->name : "none");
	469	spin_unlock(&cpuidle_driver_lock);
	470
	471	return ret;
	472	}
	473
	474	static void cpuidle_driver_sysfs_release(struct kobject *kobj)
	475	{
	476	struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
	477	complete(&driver_kobj->kobj_unregister);
	478	}
	479
f89ae89e DL	480	static ssize_t cpuidle_driver_show(struct kobject kobj, struct attribute attr,
f89ae89e DL	481	char *buf)
bf4d1b5d DL	482	{
	483	int ret = -EIO;
	484	struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
	485	struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
	486
	487	if (dattr->show)
	488	ret = dattr->show(driver_kobj->drv, buf);
	489
	490	return ret;
	491	}
	492
	493	static ssize_t cpuidle_driver_store(struct kobject kobj, struct attribute attr,
	494	const char *buf, size_t size)
	495	{
	496	int ret = -EIO;
	497	struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
	498	struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
	499
	500	if (dattr->store)
	501	ret = dattr->store(driver_kobj->drv, buf, size);
	502
	503	return ret;
	504	}
	505
	506	define_one_driver_ro(name, show_driver_name);
	507
	508	static const struct sysfs_ops cpuidle_driver_sysfs_ops = {
	509	.show = cpuidle_driver_show,
	510	.store = cpuidle_driver_store,
	511	};
	512
	513	static struct attribute *cpuidle_driver_default_attrs[] = {
	514	&attr_driver_name.attr,
	515	NULL
	516	};
	517
	518	static struct kobj_type ktype_driver_cpuidle = {
	519	.sysfs_ops = &cpuidle_driver_sysfs_ops,
	520	.default_attrs = cpuidle_driver_default_attrs,
	521	.release = cpuidle_driver_sysfs_release,
	522	};
	523
	524	/**
	525	* cpuidle_add_driver_sysfs - adds the driver name sysfs attribute
	526	* @device: the target device
	527	*/
	528	static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
	529	{
	530	struct cpuidle_driver_kobj *kdrv;
728ce22b	531	struct cpuidle_device_kobj *kdev = dev->kobj_dev;
bf4d1b5d DL	532	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
	533	int ret;
	534
	535	kdrv = kzalloc(sizeof(*kdrv), GFP_KERNEL);
	536	if (!kdrv)
	537	return -ENOMEM;
	538
	539	kdrv->drv = drv;
	540	init_completion(&kdrv->kobj_unregister);
	541
	542	ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,
728ce22b	543	&kdev->kobj, "driver");
bf4d1b5d DL	544	if (ret) {
	545	kfree(kdrv);
	546	return ret;
	547	}
	548
	549	kobject_uevent(&kdrv->kobj, KOBJ_ADD);
	550	dev->kobj_driver = kdrv;
	551
	552	return ret;
	553	}
	554
	555	/**
	556	* cpuidle_remove_driver_sysfs - removes the driver name sysfs attribute
	557	* @device: the target device
	558	*/
	559	static void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
	560	{
	561	struct cpuidle_driver_kobj *kdrv = dev->kobj_driver;
	562	kobject_put(&kdrv->kobj);
	563	wait_for_completion(&kdrv->kobj_unregister);
	564	kfree(kdrv);
	565	}
	566	#else
	567	static inline int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
	568	{
	569	return 0;
	570	}
	571
	572	static inline void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
	573	{
	574	;
	575	}
	576	#endif
	577
	578	/**
	579	* cpuidle_add_device_sysfs - adds device specific sysfs attributes
	580	* @device: the target device
	581	*/
	582	int cpuidle_add_device_sysfs(struct cpuidle_device *device)
	583	{
	584	int ret;
	585
	586	ret = cpuidle_add_state_sysfs(device);
	587	if (ret)
	588	return ret;
	589
	590	ret = cpuidle_add_driver_sysfs(device);
	591	if (ret)
	592	cpuidle_remove_state_sysfs(device);
	593	return ret;
	594	}
	595
	596	/**
	597	* cpuidle_remove_device_sysfs : removes device specific sysfs attributes
	598	* @device : the target device
	599	*/
	600	void cpuidle_remove_device_sysfs(struct cpuidle_device *device)
	601	{
	602	cpuidle_remove_driver_sysfs(device);
	603	cpuidle_remove_state_sysfs(device);
	604	}
	605
4f86d3a8 LB	606	/**
4f86d3a8 LB	607	* cpuidle_add_sysfs - creates a sysfs instance for the target device
8a25a2fd	608	* @dev: the target device
4f86d3a8	609	*/
1aef40e2	610	int cpuidle_add_sysfs(struct cpuidle_device *dev)
4f86d3a8	611	{
728ce22b	612	struct cpuidle_device_kobj *kdev;
1aef40e2	613	struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
94f57f33	614	int error;
4f86d3a8	615
728ce22b DL	616	kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
	617	if (!kdev)
	618	return -ENOMEM;
	619	kdev->dev = dev;
	620	dev->kobj_dev = kdev;
	621
	622	init_completion(&kdev->kobj_unregister);
	623
	624	error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
	625	"cpuidle");
	626	if (error) {
	627	kfree(kdev);
	628	return error;
	629	}
e45a00d6	630
728ce22b DL	631	kobject_uevent(&kdev->kobj, KOBJ_ADD);
	632
	633	return 0;
4f86d3a8 LB	634	}
	635
	636	/**
	637	* cpuidle_remove_sysfs - deletes a sysfs instance on the target device
8a25a2fd	638	* @dev: the target device
4f86d3a8	639	*/
1aef40e2	640	void cpuidle_remove_sysfs(struct cpuidle_device *dev)
4f86d3a8	641	{
728ce22b DL	642	struct cpuidle_device_kobj *kdev = dev->kobj_dev;
	643
	644	kobject_put(&kdev->kobj);
	645	wait_for_completion(&kdev->kobj_unregister);
	646	kfree(kdev);
4f86d3a8	647	}