blob: e949618b9be0ee3d0e95b48bbac4fd5f93ad21f2 [file] [log] [blame]
Len Brown4f86d3a2007-10-03 18:58:00 -04001/*
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>
12#include <linux/cpu.h>
13
14#include "cpuidle.h"
15
16static unsigned int sysfs_switch;
17static int __init cpuidle_sysfs_setup(char *unused)
18{
19 sysfs_switch = 1;
20 return 1;
21}
22__setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
23
24static ssize_t show_available_governors(struct sys_device *dev, char *buf)
25{
26 ssize_t i = 0;
27 struct cpuidle_governor *tmp;
28
29 mutex_lock(&cpuidle_lock);
30 list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
31 if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) - CPUIDLE_NAME_LEN - 2))
32 goto out;
33 i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
34 }
35
36out:
37 i+= sprintf(&buf[i], "\n");
38 mutex_unlock(&cpuidle_lock);
39 return i;
40}
41
42static ssize_t show_current_driver(struct sys_device *dev, char *buf)
43{
44 ssize_t ret;
45
46 spin_lock(&cpuidle_driver_lock);
47 if (cpuidle_curr_driver)
48 ret = sprintf(buf, "%s\n", cpuidle_curr_driver->name);
49 else
50 ret = sprintf(buf, "none\n");
51 spin_unlock(&cpuidle_driver_lock);
52
53 return ret;
54}
55
56static ssize_t show_current_governor(struct sys_device *dev, char *buf)
57{
58 ssize_t ret;
59
60 mutex_lock(&cpuidle_lock);
61 if (cpuidle_curr_governor)
62 ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
63 else
64 ret = sprintf(buf, "none\n");
65 mutex_unlock(&cpuidle_lock);
66
67 return ret;
68}
69
70static ssize_t store_current_governor(struct sys_device *dev,
71 const char *buf, size_t count)
72{
73 char gov_name[CPUIDLE_NAME_LEN];
74 int ret = -EINVAL;
75 size_t len = count;
76 struct cpuidle_governor *gov;
77
78 if (!len || len >= sizeof(gov_name))
79 return -EINVAL;
80
81 memcpy(gov_name, buf, len);
82 gov_name[len] = '\0';
83 if (gov_name[len - 1] == '\n')
84 gov_name[--len] = '\0';
85
86 mutex_lock(&cpuidle_lock);
87
88 list_for_each_entry(gov, &cpuidle_governors, governor_list) {
89 if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
90 ret = cpuidle_switch_governor(gov);
91 break;
92 }
93 }
94
95 mutex_unlock(&cpuidle_lock);
96
97 if (ret)
98 return ret;
99 else
100 return count;
101}
102
103static SYSDEV_ATTR(current_driver, 0444, show_current_driver, NULL);
104static SYSDEV_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
105
106static struct attribute *cpuclass_default_attrs[] = {
107 &attr_current_driver.attr,
108 &attr_current_governor_ro.attr,
109 NULL
110};
111
112static SYSDEV_ATTR(available_governors, 0444, show_available_governors, NULL);
113static SYSDEV_ATTR(current_governor, 0644, show_current_governor,
114 store_current_governor);
115
116static struct attribute *cpuclass_switch_attrs[] = {
117 &attr_available_governors.attr,
118 &attr_current_driver.attr,
119 &attr_current_governor.attr,
120 NULL
121};
122
123static struct attribute_group cpuclass_attr_group = {
124 .attrs = cpuclass_default_attrs,
125 .name = "cpuidle",
126};
127
128/**
129 * cpuidle_add_class_sysfs - add CPU global sysfs attributes
130 */
131int cpuidle_add_class_sysfs(struct sysdev_class *cls)
132{
133 if (sysfs_switch)
134 cpuclass_attr_group.attrs = cpuclass_switch_attrs;
135
136 return sysfs_create_group(&cls->kset.kobj, &cpuclass_attr_group);
137}
138
139/**
140 * cpuidle_remove_class_sysfs - remove CPU global sysfs attributes
141 */
142void cpuidle_remove_class_sysfs(struct sysdev_class *cls)
143{
144 sysfs_remove_group(&cls->kset.kobj, &cpuclass_attr_group);
145}
146
147struct cpuidle_attr {
148 struct attribute attr;
149 ssize_t (*show)(struct cpuidle_device *, char *);
150 ssize_t (*store)(struct cpuidle_device *, const char *, size_t count);
151};
152
153#define define_one_ro(_name, show) \
154 static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
155#define define_one_rw(_name, show, store) \
156 static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
157
158#define kobj_to_cpuidledev(k) container_of(k, struct cpuidle_device, kobj)
159#define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
160static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char * buf)
161{
162 int ret = -EIO;
163 struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
164 struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
165
166 if (cattr->show) {
167 mutex_lock(&cpuidle_lock);
168 ret = cattr->show(dev, buf);
169 mutex_unlock(&cpuidle_lock);
170 }
171 return ret;
172}
173
174static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr,
175 const char * buf, size_t count)
176{
177 int ret = -EIO;
178 struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
179 struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
180
181 if (cattr->store) {
182 mutex_lock(&cpuidle_lock);
183 ret = cattr->store(dev, buf, count);
184 mutex_unlock(&cpuidle_lock);
185 }
186 return ret;
187}
188
189static struct sysfs_ops cpuidle_sysfs_ops = {
190 .show = cpuidle_show,
191 .store = cpuidle_store,
192};
193
194static void cpuidle_sysfs_release(struct kobject *kobj)
195{
196 struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
197
198 complete(&dev->kobj_unregister);
199}
200
201static struct kobj_type ktype_cpuidle = {
202 .sysfs_ops = &cpuidle_sysfs_ops,
203 .release = cpuidle_sysfs_release,
204};
205
206struct cpuidle_state_attr {
207 struct attribute attr;
208 ssize_t (*show)(struct cpuidle_state *, char *);
209 ssize_t (*store)(struct cpuidle_state *, const char *, size_t);
210};
211
212#define define_one_state_ro(_name, show) \
213static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
214
215#define define_show_state_function(_name) \
216static ssize_t show_state_##_name(struct cpuidle_state *state, char *buf) \
217{ \
218 return sprintf(buf, "%u\n", state->_name);\
219}
220
Yi Yang8b78cf62008-02-25 08:46:12 +0800221#define define_show_state_ull_function(_name) \
222static ssize_t show_state_##_name(struct cpuidle_state *state, char *buf) \
223{ \
224 return sprintf(buf, "%llu\n", state->_name);\
225}
226
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800227#define define_show_state_str_function(_name) \
228static ssize_t show_state_##_name(struct cpuidle_state *state, char *buf) \
229{ \
230 if (state->_name[0] == '\0')\
231 return sprintf(buf, "<null>\n");\
232 return sprintf(buf, "%s\n", state->_name);\
Len Brown4f86d3a2007-10-03 18:58:00 -0400233}
234
235define_show_state_function(exit_latency)
236define_show_state_function(power_usage)
Yi Yang8b78cf62008-02-25 08:46:12 +0800237define_show_state_ull_function(usage)
238define_show_state_ull_function(time)
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800239define_show_state_str_function(name)
240define_show_state_str_function(desc)
241
Len Brown4f86d3a2007-10-03 18:58:00 -0400242define_one_state_ro(name, show_state_name);
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800243define_one_state_ro(desc, show_state_desc);
Len Brown4f86d3a2007-10-03 18:58:00 -0400244define_one_state_ro(latency, show_state_exit_latency);
245define_one_state_ro(power, show_state_power_usage);
246define_one_state_ro(usage, show_state_usage);
247define_one_state_ro(time, show_state_time);
248
249static struct attribute *cpuidle_state_default_attrs[] = {
250 &attr_name.attr,
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800251 &attr_desc.attr,
Len Brown4f86d3a2007-10-03 18:58:00 -0400252 &attr_latency.attr,
253 &attr_power.attr,
254 &attr_usage.attr,
255 &attr_time.attr,
256 NULL
257};
258
259#define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
260#define kobj_to_state(k) (kobj_to_state_obj(k)->state)
261#define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
262static ssize_t cpuidle_state_show(struct kobject * kobj,
263 struct attribute * attr ,char * buf)
264{
265 int ret = -EIO;
266 struct cpuidle_state *state = kobj_to_state(kobj);
267 struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);
268
269 if (cattr->show)
270 ret = cattr->show(state, buf);
271
272 return ret;
273}
274
275static struct sysfs_ops cpuidle_state_sysfs_ops = {
276 .show = cpuidle_state_show,
277};
278
279static void cpuidle_state_sysfs_release(struct kobject *kobj)
280{
281 struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);
282
283 complete(&state_obj->kobj_unregister);
284}
285
286static struct kobj_type ktype_state_cpuidle = {
287 .sysfs_ops = &cpuidle_state_sysfs_ops,
288 .default_attrs = cpuidle_state_default_attrs,
289 .release = cpuidle_state_sysfs_release,
290};
291
292static void inline cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
293{
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800294 kobject_put(&device->kobjs[i]->kobj);
Len Brown4f86d3a2007-10-03 18:58:00 -0400295 wait_for_completion(&device->kobjs[i]->kobj_unregister);
296 kfree(device->kobjs[i]);
297 device->kobjs[i] = NULL;
298}
299
300/**
301 * cpuidle_add_driver_sysfs - adds driver-specific sysfs attributes
302 * @device: the target device
303 */
304int cpuidle_add_state_sysfs(struct cpuidle_device *device)
305{
306 int i, ret = -ENOMEM;
307 struct cpuidle_state_kobj *kobj;
308
309 /* state statistics */
310 for (i = 0; i < device->state_count; i++) {
311 kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
312 if (!kobj)
313 goto error_state;
314 kobj->state = &device->states[i];
315 init_completion(&kobj->kobj_unregister);
316
Greg Kroah-Hartman94f57f32007-12-17 15:54:39 -0400317 ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle, &device->kobj,
318 "state%d", i);
Len Brown4f86d3a2007-10-03 18:58:00 -0400319 if (ret) {
320 kfree(kobj);
321 goto error_state;
322 }
Greg Kroah-Hartman94f57f32007-12-17 15:54:39 -0400323 kobject_uevent(&kobj->kobj, KOBJ_ADD);
Len Brown4f86d3a2007-10-03 18:58:00 -0400324 device->kobjs[i] = kobj;
325 }
326
327 return 0;
328
329error_state:
330 for (i = i - 1; i >= 0; i--)
331 cpuidle_free_state_kobj(device, i);
332 return ret;
333}
334
335/**
336 * cpuidle_remove_driver_sysfs - removes driver-specific sysfs attributes
337 * @device: the target device
338 */
339void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
340{
341 int i;
342
343 for (i = 0; i < device->state_count; i++)
344 cpuidle_free_state_kobj(device, i);
345}
346
347/**
348 * cpuidle_add_sysfs - creates a sysfs instance for the target device
349 * @sysdev: the target device
350 */
351int cpuidle_add_sysfs(struct sys_device *sysdev)
352{
353 int cpu = sysdev->id;
354 struct cpuidle_device *dev;
Greg Kroah-Hartman94f57f32007-12-17 15:54:39 -0400355 int error;
Len Brown4f86d3a2007-10-03 18:58:00 -0400356
357 dev = per_cpu(cpuidle_devices, cpu);
Greg Kroah-Hartman94f57f32007-12-17 15:54:39 -0400358 error = kobject_init_and_add(&dev->kobj, &ktype_cpuidle, &sysdev->kobj,
359 "cpuidle");
360 if (!error)
361 kobject_uevent(&dev->kobj, KOBJ_ADD);
362 return error;
Len Brown4f86d3a2007-10-03 18:58:00 -0400363}
364
365/**
366 * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
367 * @sysdev: the target device
368 */
369void cpuidle_remove_sysfs(struct sys_device *sysdev)
370{
371 int cpu = sysdev->id;
372 struct cpuidle_device *dev;
373
374 dev = per_cpu(cpuidle_devices, cpu);
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800375 kobject_put(&dev->kobj);
Len Brown4f86d3a2007-10-03 18:58:00 -0400376}