2 * sysfs.c - sysfs support
4 * (C) 2006-2007 Shaohua Li <shaohua.li@intel.com>
6 * This code is licenced under the GPL.
9 #include <linux/kernel.h>
10 #include <linux/cpuidle.h>
11 #include <linux/sysfs.h>
12 #include <linux/slab.h>
13 #include <linux/cpu.h>
14 #include <linux/completion.h>
15 #include <linux/capability.h>
16 #include <linux/device.h>
17 #include <linux/kobject.h>
21 static unsigned int sysfs_switch;
22 static int __init cpuidle_sysfs_setup(char *unused)
27 __setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
29 static ssize_t show_available_governors(struct device *dev,
30 struct device_attribute *attr,
34 struct cpuidle_governor *tmp;
36 mutex_lock(&cpuidle_lock);
37 list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
38 if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) -
39 CPUIDLE_NAME_LEN - 2))
41 i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
45 i+= sprintf(&buf[i], "\n");
46 mutex_unlock(&cpuidle_lock);
50 static ssize_t show_current_driver(struct device *dev,
51 struct device_attribute *attr,
55 struct cpuidle_driver *drv;
57 spin_lock(&cpuidle_driver_lock);
58 drv = cpuidle_get_driver();
60 ret = sprintf(buf, "%s\n", drv->name);
62 ret = sprintf(buf, "none\n");
63 spin_unlock(&cpuidle_driver_lock);
68 static ssize_t show_current_governor(struct device *dev,
69 struct device_attribute *attr,
74 mutex_lock(&cpuidle_lock);
75 if (cpuidle_curr_governor)
76 ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
78 ret = sprintf(buf, "none\n");
79 mutex_unlock(&cpuidle_lock);
84 static ssize_t store_current_governor(struct device *dev,
85 struct device_attribute *attr,
86 const char *buf, size_t count)
88 char gov_name[CPUIDLE_NAME_LEN];
91 struct cpuidle_governor *gov;
93 if (!len || len >= sizeof(gov_name))
96 memcpy(gov_name, buf, len);
98 if (gov_name[len - 1] == '\n')
99 gov_name[--len] = '\0';
101 mutex_lock(&cpuidle_lock);
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);
110 mutex_unlock(&cpuidle_lock);
118 static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);
119 static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
121 static struct attribute *cpuidle_default_attrs[] = {
122 &dev_attr_current_driver.attr,
123 &dev_attr_current_governor_ro.attr,
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);
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,
138 static struct attribute_group cpuidle_attr_group = {
139 .attrs = cpuidle_default_attrs,
144 * cpuidle_add_interface - add CPU global sysfs attributes
145 * @dev: the target device
147 int cpuidle_add_interface(struct device *dev)
150 cpuidle_attr_group.attrs = cpuidle_switch_attrs;
152 return sysfs_create_group(&dev->kobj, &cpuidle_attr_group);
156 * cpuidle_remove_interface - remove CPU global sysfs attributes
157 * @dev: the target device
159 void cpuidle_remove_interface(struct device *dev)
161 sysfs_remove_group(&dev->kobj, &cpuidle_attr_group);
164 struct cpuidle_attr {
165 struct attribute attr;
166 ssize_t (*show)(struct cpuidle_device *, char *);
167 ssize_t (*store)(struct cpuidle_device *, const char *, size_t count);
170 #define define_one_ro(_name, show) \
171 static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
172 #define define_one_rw(_name, show, store) \
173 static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
175 #define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
177 struct cpuidle_device_kobj {
178 struct cpuidle_device *dev;
179 struct completion kobj_unregister;
183 static inline struct cpuidle_device *to_cpuidle_device(struct kobject *kobj)
185 struct cpuidle_device_kobj *kdev =
186 container_of(kobj, struct cpuidle_device_kobj, kobj);
191 static ssize_t cpuidle_show(struct kobject *kobj, struct attribute *attr,
195 struct cpuidle_device *dev = to_cpuidle_device(kobj);
196 struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
199 mutex_lock(&cpuidle_lock);
200 ret = cattr->show(dev, buf);
201 mutex_unlock(&cpuidle_lock);
206 static ssize_t cpuidle_store(struct kobject *kobj, struct attribute *attr,
207 const char *buf, size_t count)
210 struct cpuidle_device *dev = to_cpuidle_device(kobj);
211 struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
214 mutex_lock(&cpuidle_lock);
215 ret = cattr->store(dev, buf, count);
216 mutex_unlock(&cpuidle_lock);
221 static const struct sysfs_ops cpuidle_sysfs_ops = {
222 .show = cpuidle_show,
223 .store = cpuidle_store,
226 static void cpuidle_sysfs_release(struct kobject *kobj)
228 struct cpuidle_device_kobj *kdev =
229 container_of(kobj, struct cpuidle_device_kobj, kobj);
231 complete(&kdev->kobj_unregister);
234 static struct kobj_type ktype_cpuidle = {
235 .sysfs_ops = &cpuidle_sysfs_ops,
236 .release = cpuidle_sysfs_release,
239 struct cpuidle_state_attr {
240 struct attribute attr;
241 ssize_t (*show)(struct cpuidle_state *, \
242 struct cpuidle_state_usage *, char *);
243 ssize_t (*store)(struct cpuidle_state *, \
244 struct cpuidle_state_usage *, const char *, size_t);
247 #define define_one_state_ro(_name, show) \
248 static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
250 #define define_one_state_rw(_name, show, store) \
251 static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0644, show, store)
253 #define define_show_state_function(_name) \
254 static ssize_t show_state_##_name(struct cpuidle_state *state, \
255 struct cpuidle_state_usage *state_usage, char *buf) \
257 return sprintf(buf, "%u\n", state->_name);\
260 #define define_show_state_ull_function(_name) \
261 static ssize_t show_state_##_name(struct cpuidle_state *state, \
262 struct cpuidle_state_usage *state_usage, \
265 return sprintf(buf, "%llu\n", state_usage->_name);\
268 #define define_show_state_str_function(_name) \
269 static ssize_t show_state_##_name(struct cpuidle_state *state, \
270 struct cpuidle_state_usage *state_usage, \
273 if (state->_name[0] == '\0')\
274 return sprintf(buf, "<null>\n");\
275 return sprintf(buf, "%s\n", state->_name);\
278 #define define_show_state_time_function(_name) \
279 static ssize_t show_state_##_name(struct cpuidle_state *state, \
280 struct cpuidle_state_usage *state_usage, \
283 return sprintf(buf, "%llu\n", ktime_to_us(state->_name##_ns)); \
286 define_show_state_time_function(exit_latency)
287 define_show_state_time_function(target_residency)
288 define_show_state_function(power_usage)
289 define_show_state_ull_function(usage)
290 define_show_state_str_function(name)
291 define_show_state_str_function(desc)
292 define_show_state_ull_function(above)
293 define_show_state_ull_function(below)
295 static ssize_t show_state_time(struct cpuidle_state *state,
296 struct cpuidle_state_usage *state_usage,
299 return sprintf(buf, "%llu\n", ktime_to_us(state_usage->time_ns));
302 static ssize_t show_state_disable(struct cpuidle_state *state,
303 struct cpuidle_state_usage *state_usage,
306 return sprintf(buf, "%llu\n",
307 state_usage->disable & CPUIDLE_STATE_DISABLED_BY_USER);
310 static ssize_t store_state_disable(struct cpuidle_state *state,
311 struct cpuidle_state_usage *state_usage,
312 const char *buf, size_t size)
317 if (!capable(CAP_SYS_ADMIN))
320 err = kstrtouint(buf, 0, &value);
325 state_usage->disable |= CPUIDLE_STATE_DISABLED_BY_USER;
327 state_usage->disable &= ~CPUIDLE_STATE_DISABLED_BY_USER;
332 static ssize_t show_state_default_status(struct cpuidle_state *state,
333 struct cpuidle_state_usage *state_usage,
336 return sprintf(buf, "%s\n",
337 state->flags & CPUIDLE_FLAG_OFF ? "disabled" : "enabled");
340 define_one_state_ro(name, show_state_name);
341 define_one_state_ro(desc, show_state_desc);
342 define_one_state_ro(latency, show_state_exit_latency);
343 define_one_state_ro(residency, show_state_target_residency);
344 define_one_state_ro(power, show_state_power_usage);
345 define_one_state_ro(usage, show_state_usage);
346 define_one_state_ro(time, show_state_time);
347 define_one_state_rw(disable, show_state_disable, store_state_disable);
348 define_one_state_ro(above, show_state_above);
349 define_one_state_ro(below, show_state_below);
350 define_one_state_ro(default_status, show_state_default_status);
352 static struct attribute *cpuidle_state_default_attrs[] = {
356 &attr_residency.attr,
363 &attr_default_status.attr,
367 struct cpuidle_state_kobj {
368 struct cpuidle_state *state;
369 struct cpuidle_state_usage *state_usage;
370 struct completion kobj_unregister;
372 struct cpuidle_device *device;
375 #ifdef CONFIG_SUSPEND
376 #define define_show_state_s2idle_ull_function(_name) \
377 static ssize_t show_state_s2idle_##_name(struct cpuidle_state *state, \
378 struct cpuidle_state_usage *state_usage, \
381 return sprintf(buf, "%llu\n", state_usage->s2idle_##_name);\
384 define_show_state_s2idle_ull_function(usage);
385 define_show_state_s2idle_ull_function(time);
387 #define define_one_state_s2idle_ro(_name, show) \
388 static struct cpuidle_state_attr attr_s2idle_##_name = \
389 __ATTR(_name, 0444, show, NULL)
391 define_one_state_s2idle_ro(usage, show_state_s2idle_usage);
392 define_one_state_s2idle_ro(time, show_state_s2idle_time);
394 static struct attribute *cpuidle_state_s2idle_attrs[] = {
395 &attr_s2idle_usage.attr,
396 &attr_s2idle_time.attr,
400 static const struct attribute_group cpuidle_state_s2idle_group = {
402 .attrs = cpuidle_state_s2idle_attrs,
405 static void cpuidle_add_s2idle_attr_group(struct cpuidle_state_kobj *kobj)
409 if (!kobj->state->enter_s2idle)
412 ret = sysfs_create_group(&kobj->kobj, &cpuidle_state_s2idle_group);
414 pr_debug("%s: sysfs attribute group not created\n", __func__);
417 static void cpuidle_remove_s2idle_attr_group(struct cpuidle_state_kobj *kobj)
419 if (kobj->state->enter_s2idle)
420 sysfs_remove_group(&kobj->kobj, &cpuidle_state_s2idle_group);
423 static inline void cpuidle_add_s2idle_attr_group(struct cpuidle_state_kobj *kobj) { }
424 static inline void cpuidle_remove_s2idle_attr_group(struct cpuidle_state_kobj *kobj) { }
425 #endif /* CONFIG_SUSPEND */
427 #define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
428 #define kobj_to_state(k) (kobj_to_state_obj(k)->state)
429 #define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage)
430 #define kobj_to_device(k) (kobj_to_state_obj(k)->device)
431 #define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
433 static ssize_t cpuidle_state_show(struct kobject *kobj, struct attribute *attr,
437 struct cpuidle_state *state = kobj_to_state(kobj);
438 struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
439 struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);
442 ret = cattr->show(state, state_usage, buf);
447 static ssize_t cpuidle_state_store(struct kobject *kobj, struct attribute *attr,
448 const char *buf, size_t size)
451 struct cpuidle_state *state = kobj_to_state(kobj);
452 struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
453 struct cpuidle_state_attr *cattr = attr_to_stateattr(attr);
454 struct cpuidle_device *dev = kobj_to_device(kobj);
457 ret = cattr->store(state, state_usage, buf, size);
459 /* reset poll time cache */
460 dev->poll_limit_ns = 0;
465 static const struct sysfs_ops cpuidle_state_sysfs_ops = {
466 .show = cpuidle_state_show,
467 .store = cpuidle_state_store,
470 static void cpuidle_state_sysfs_release(struct kobject *kobj)
472 struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);
474 complete(&state_obj->kobj_unregister);
477 static struct kobj_type ktype_state_cpuidle = {
478 .sysfs_ops = &cpuidle_state_sysfs_ops,
479 .default_attrs = cpuidle_state_default_attrs,
480 .release = cpuidle_state_sysfs_release,
483 static inline void cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
485 cpuidle_remove_s2idle_attr_group(device->kobjs[i]);
486 kobject_put(&device->kobjs[i]->kobj);
487 wait_for_completion(&device->kobjs[i]->kobj_unregister);
488 kfree(device->kobjs[i]);
489 device->kobjs[i] = NULL;
493 * cpuidle_add_state_sysfs - adds cpuidle states sysfs attributes
494 * @device: the target device
496 static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
498 int i, ret = -ENOMEM;
499 struct cpuidle_state_kobj *kobj;
500 struct cpuidle_device_kobj *kdev = device->kobj_dev;
501 struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
503 /* state statistics */
504 for (i = 0; i < drv->state_count; i++) {
505 kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
510 kobj->state = &drv->states[i];
511 kobj->state_usage = &device->states_usage[i];
512 kobj->device = device;
513 init_completion(&kobj->kobj_unregister);
515 ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,
516 &kdev->kobj, "state%d", i);
521 cpuidle_add_s2idle_attr_group(kobj);
522 kobject_uevent(&kobj->kobj, KOBJ_ADD);
523 device->kobjs[i] = kobj;
529 for (i = i - 1; i >= 0; i--)
530 cpuidle_free_state_kobj(device, i);
535 * cpuidle_remove_driver_sysfs - removes the cpuidle states sysfs attributes
536 * @device: the target device
538 static void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
540 struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
543 for (i = 0; i < drv->state_count; i++)
544 cpuidle_free_state_kobj(device, i);
547 #ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
548 #define kobj_to_driver_kobj(k) container_of(k, struct cpuidle_driver_kobj, kobj)
549 #define attr_to_driver_attr(a) container_of(a, struct cpuidle_driver_attr, attr)
551 #define define_one_driver_ro(_name, show) \
552 static struct cpuidle_driver_attr attr_driver_##_name = \
553 __ATTR(_name, 0444, show, NULL)
555 struct cpuidle_driver_kobj {
556 struct cpuidle_driver *drv;
557 struct completion kobj_unregister;
561 struct cpuidle_driver_attr {
562 struct attribute attr;
563 ssize_t (*show)(struct cpuidle_driver *, char *);
564 ssize_t (*store)(struct cpuidle_driver *, const char *, size_t);
567 static ssize_t show_driver_name(struct cpuidle_driver *drv, char *buf)
571 spin_lock(&cpuidle_driver_lock);
572 ret = sprintf(buf, "%s\n", drv ? drv->name : "none");
573 spin_unlock(&cpuidle_driver_lock);
578 static void cpuidle_driver_sysfs_release(struct kobject *kobj)
580 struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
581 complete(&driver_kobj->kobj_unregister);
584 static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute *attr,
588 struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
589 struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
592 ret = dattr->show(driver_kobj->drv, buf);
597 static ssize_t cpuidle_driver_store(struct kobject *kobj, struct attribute *attr,
598 const char *buf, size_t size)
601 struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
602 struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
605 ret = dattr->store(driver_kobj->drv, buf, size);
610 define_one_driver_ro(name, show_driver_name);
612 static const struct sysfs_ops cpuidle_driver_sysfs_ops = {
613 .show = cpuidle_driver_show,
614 .store = cpuidle_driver_store,
617 static struct attribute *cpuidle_driver_default_attrs[] = {
618 &attr_driver_name.attr,
622 static struct kobj_type ktype_driver_cpuidle = {
623 .sysfs_ops = &cpuidle_driver_sysfs_ops,
624 .default_attrs = cpuidle_driver_default_attrs,
625 .release = cpuidle_driver_sysfs_release,
629 * cpuidle_add_driver_sysfs - adds the driver name sysfs attribute
630 * @dev: the target device
632 static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
634 struct cpuidle_driver_kobj *kdrv;
635 struct cpuidle_device_kobj *kdev = dev->kobj_dev;
636 struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
639 kdrv = kzalloc(sizeof(*kdrv), GFP_KERNEL);
644 init_completion(&kdrv->kobj_unregister);
646 ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,
647 &kdev->kobj, "driver");
653 kobject_uevent(&kdrv->kobj, KOBJ_ADD);
654 dev->kobj_driver = kdrv;
660 * cpuidle_remove_driver_sysfs - removes the driver name sysfs attribute
661 * @dev: the target device
663 static void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
665 struct cpuidle_driver_kobj *kdrv = dev->kobj_driver;
666 kobject_put(&kdrv->kobj);
667 wait_for_completion(&kdrv->kobj_unregister);
671 static inline int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
676 static inline void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
683 * cpuidle_add_device_sysfs - adds device specific sysfs attributes
684 * @device: the target device
686 int cpuidle_add_device_sysfs(struct cpuidle_device *device)
690 ret = cpuidle_add_state_sysfs(device);
694 ret = cpuidle_add_driver_sysfs(device);
696 cpuidle_remove_state_sysfs(device);
701 * cpuidle_remove_device_sysfs : removes device specific sysfs attributes
702 * @device : the target device
704 void cpuidle_remove_device_sysfs(struct cpuidle_device *device)
706 cpuidle_remove_driver_sysfs(device);
707 cpuidle_remove_state_sysfs(device);
711 * cpuidle_add_sysfs - creates a sysfs instance for the target device
712 * @dev: the target device
714 int cpuidle_add_sysfs(struct cpuidle_device *dev)
716 struct cpuidle_device_kobj *kdev;
717 struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
721 * Return if cpu_device is not setup for this CPU.
723 * This could happen if the arch did not set up cpu_device
724 * since this CPU is not in cpu_present mask and the
725 * driver did not send a correct CPU mask during registration.
726 * Without this check we would end up passing bogus
727 * value for &cpu_dev->kobj in kobject_init_and_add()
732 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
736 dev->kobj_dev = kdev;
738 init_completion(&kdev->kobj_unregister);
740 error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
747 kobject_uevent(&kdev->kobj, KOBJ_ADD);
753 * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
754 * @dev: the target device
756 void cpuidle_remove_sysfs(struct cpuidle_device *dev)
758 struct cpuidle_device_kobj *kdev = dev->kobj_dev;
760 kobject_put(&kdev->kobj);
761 wait_for_completion(&kdev->kobj_unregister);