Branch data Line data Source code
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>
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>
18 : :
19 : : #include "cpuidle.h"
20 : :
21 : : static unsigned int sysfs_switch;
22 : 0 : static int __init cpuidle_sysfs_setup(char *unused)
23 : : {
24 : 0 : sysfs_switch = 1;
25 : 0 : return 1;
26 : : }
27 : : __setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
28 : :
29 : 0 : static ssize_t show_available_governors(struct device *dev,
30 : : struct device_attribute *attr,
31 : : char *buf)
32 : : {
33 : 0 : ssize_t i = 0;
34 : 0 : struct cpuidle_governor *tmp;
35 : :
36 : 0 : mutex_lock(&cpuidle_lock);
37 [ # # ]: 0 : list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
38 [ # # ]: 0 : if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) -
39 : : CPUIDLE_NAME_LEN - 2))
40 : 0 : goto out;
41 : 0 : i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
42 : : }
43 : :
44 : 0 : out:
45 : 0 : i+= sprintf(&buf[i], "\n");
46 : 0 : mutex_unlock(&cpuidle_lock);
47 : 0 : return i;
48 : : }
49 : :
50 : 0 : static ssize_t show_current_driver(struct device *dev,
51 : : struct device_attribute *attr,
52 : : char *buf)
53 : : {
54 : 0 : ssize_t ret;
55 : 0 : struct cpuidle_driver *drv;
56 : :
57 : 0 : spin_lock(&cpuidle_driver_lock);
58 : 0 : drv = cpuidle_get_driver();
59 [ # # ]: 0 : if (drv)
60 : 0 : ret = sprintf(buf, "%s\n", drv->name);
61 : : else
62 : 0 : ret = sprintf(buf, "none\n");
63 : 0 : spin_unlock(&cpuidle_driver_lock);
64 : :
65 : 0 : return ret;
66 : : }
67 : :
68 : 0 : static ssize_t show_current_governor(struct device *dev,
69 : : struct device_attribute *attr,
70 : : char *buf)
71 : : {
72 : 0 : ssize_t ret;
73 : :
74 : 0 : mutex_lock(&cpuidle_lock);
75 [ # # ]: 0 : if (cpuidle_curr_governor)
76 : 0 : ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
77 : : else
78 : 0 : ret = sprintf(buf, "none\n");
79 : 0 : mutex_unlock(&cpuidle_lock);
80 : :
81 : 0 : return ret;
82 : : }
83 : :
84 : 0 : static ssize_t store_current_governor(struct device *dev,
85 : : struct device_attribute *attr,
86 : : const char *buf, size_t count)
87 : : {
88 : 0 : char gov_name[CPUIDLE_NAME_LEN];
89 : 0 : int ret = -EINVAL;
90 : 0 : size_t len = count;
91 : 0 : struct cpuidle_governor *gov;
92 : :
93 [ # # ]: 0 : if (!len || len >= sizeof(gov_name))
94 : : return -EINVAL;
95 : :
96 : 0 : memcpy(gov_name, buf, len);
97 : 0 : gov_name[len] = '\0';
98 [ # # ]: 0 : if (gov_name[len - 1] == '\n')
99 : 0 : gov_name[--len] = '\0';
100 : :
101 : 0 : mutex_lock(&cpuidle_lock);
102 : :
103 [ # # ]: 0 : list_for_each_entry(gov, &cpuidle_governors, governor_list) {
104 [ # # # # ]: 0 : if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
105 : 0 : ret = cpuidle_switch_governor(gov);
106 : 0 : break;
107 : : }
108 : : }
109 : :
110 : 0 : mutex_unlock(&cpuidle_lock);
111 : :
112 [ # # ]: 0 : if (ret)
113 : 0 : return ret;
114 : : else
115 : 0 : return count;
116 : : }
117 : :
118 : : static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);
119 : : static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
120 : :
121 : : static struct attribute *cpuidle_default_attrs[] = {
122 : : &dev_attr_current_driver.attr,
123 : : &dev_attr_current_governor_ro.attr,
124 : : NULL
125 : : };
126 : :
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);
130 : :
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,
135 : : NULL
136 : : };
137 : :
138 : : static struct attribute_group cpuidle_attr_group = {
139 : : .attrs = cpuidle_default_attrs,
140 : : .name = "cpuidle",
141 : : };
142 : :
143 : : /**
144 : : * cpuidle_add_interface - add CPU global sysfs attributes
145 : : * @dev: the target device
146 : : */
147 : 11 : int cpuidle_add_interface(struct device *dev)
148 : : {
149 [ - + ]: 11 : if (sysfs_switch)
150 : 0 : cpuidle_attr_group.attrs = cpuidle_switch_attrs;
151 : :
152 : 11 : return sysfs_create_group(&dev->kobj, &cpuidle_attr_group);
153 : : }
154 : :
155 : : /**
156 : : * cpuidle_remove_interface - remove CPU global sysfs attributes
157 : : * @dev: the target device
158 : : */
159 : 0 : void cpuidle_remove_interface(struct device *dev)
160 : : {
161 : 0 : sysfs_remove_group(&dev->kobj, &cpuidle_attr_group);
162 : 0 : }
163 : :
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);
168 : : };
169 : :
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)
174 : :
175 : : #define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
176 : :
177 : : struct cpuidle_device_kobj {
178 : : struct cpuidle_device *dev;
179 : : struct completion kobj_unregister;
180 : : struct kobject kobj;
181 : : };
182 : :
183 : 0 : static inline struct cpuidle_device *to_cpuidle_device(struct kobject *kobj)
184 : : {
185 : 0 : struct cpuidle_device_kobj *kdev =
186 : 0 : container_of(kobj, struct cpuidle_device_kobj, kobj);
187 : :
188 : 0 : return kdev->dev;
189 : : }
190 : :
191 : 0 : static ssize_t cpuidle_show(struct kobject *kobj, struct attribute *attr,
192 : : char *buf)
193 : : {
194 : 0 : int ret = -EIO;
195 : 0 : struct cpuidle_device *dev = to_cpuidle_device(kobj);
196 : 0 : struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
197 : :
198 [ # # ]: 0 : if (cattr->show) {
199 : 0 : mutex_lock(&cpuidle_lock);
200 : 0 : ret = cattr->show(dev, buf);
201 : 0 : mutex_unlock(&cpuidle_lock);
202 : : }
203 : 0 : return ret;
204 : : }
205 : :
206 : 0 : static ssize_t cpuidle_store(struct kobject *kobj, struct attribute *attr,
207 : : const char *buf, size_t count)
208 : : {
209 : 0 : int ret = -EIO;
210 : 0 : struct cpuidle_device *dev = to_cpuidle_device(kobj);
211 : 0 : struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
212 : :
213 [ # # ]: 0 : if (cattr->store) {
214 : 0 : mutex_lock(&cpuidle_lock);
215 : 0 : ret = cattr->store(dev, buf, count);
216 : 0 : mutex_unlock(&cpuidle_lock);
217 : : }
218 : 0 : return ret;
219 : : }
220 : :
221 : : static const struct sysfs_ops cpuidle_sysfs_ops = {
222 : : .show = cpuidle_show,
223 : : .store = cpuidle_store,
224 : : };
225 : :
226 : 0 : static void cpuidle_sysfs_release(struct kobject *kobj)
227 : : {
228 : 0 : struct cpuidle_device_kobj *kdev =
229 : 0 : container_of(kobj, struct cpuidle_device_kobj, kobj);
230 : :
231 : 0 : complete(&kdev->kobj_unregister);
232 : 0 : }
233 : :
234 : : static struct kobj_type ktype_cpuidle = {
235 : : .sysfs_ops = &cpuidle_sysfs_ops,
236 : : .release = cpuidle_sysfs_release,
237 : : };
238 : :
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);
245 : : };
246 : :
247 : : #define define_one_state_ro(_name, show) \
248 : : static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
249 : :
250 : : #define define_one_state_rw(_name, show, store) \
251 : : static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0644, show, store)
252 : :
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) \
256 : : { \
257 : : return sprintf(buf, "%u\n", state->_name);\
258 : : }
259 : :
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, \
263 : : char *buf) \
264 : : { \
265 : : return sprintf(buf, "%llu\n", state_usage->_name);\
266 : : }
267 : :
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, \
271 : : char *buf) \
272 : : { \
273 : : if (state->_name[0] == '\0')\
274 : : return sprintf(buf, "<null>\n");\
275 : : return sprintf(buf, "%s\n", state->_name);\
276 : : }
277 : :
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, \
281 : : char *buf) \
282 : : { \
283 : : return sprintf(buf, "%llu\n", ktime_to_us(state->_name##_ns)); \
284 : : }
285 : :
286 : 0 : define_show_state_time_function(exit_latency)
287 : 0 : define_show_state_time_function(target_residency)
288 : 0 : define_show_state_function(power_usage)
289 : 0 : define_show_state_ull_function(usage)
290 [ # # ]: 0 : define_show_state_str_function(name)
291 [ # # ]: 0 : define_show_state_str_function(desc)
292 : 0 : define_show_state_ull_function(above)
293 : 0 : define_show_state_ull_function(below)
294 : :
295 : 0 : static ssize_t show_state_time(struct cpuidle_state *state,
296 : : struct cpuidle_state_usage *state_usage,
297 : : char *buf)
298 : : {
299 : 0 : return sprintf(buf, "%llu\n", ktime_to_us(state_usage->time_ns));
300 : : }
301 : :
302 : 0 : static ssize_t show_state_disable(struct cpuidle_state *state,
303 : : struct cpuidle_state_usage *state_usage,
304 : : char *buf)
305 : : {
306 : 0 : return sprintf(buf, "%llu\n",
307 : 0 : state_usage->disable & CPUIDLE_STATE_DISABLED_BY_USER);
308 : : }
309 : :
310 : 0 : static ssize_t store_state_disable(struct cpuidle_state *state,
311 : : struct cpuidle_state_usage *state_usage,
312 : : const char *buf, size_t size)
313 : : {
314 : 0 : unsigned int value;
315 : 0 : int err;
316 : :
317 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
318 : : return -EPERM;
319 : :
320 : 0 : err = kstrtouint(buf, 0, &value);
321 [ # # ]: 0 : if (err)
322 : 0 : return err;
323 : :
324 [ # # ]: 0 : if (value)
325 : 0 : state_usage->disable |= CPUIDLE_STATE_DISABLED_BY_USER;
326 : : else
327 : 0 : state_usage->disable &= ~CPUIDLE_STATE_DISABLED_BY_USER;
328 : :
329 : 0 : return size;
330 : : }
331 : :
332 : 0 : static ssize_t show_state_default_status(struct cpuidle_state *state,
333 : : struct cpuidle_state_usage *state_usage,
334 : : char *buf)
335 : : {
336 : 0 : return sprintf(buf, "%s\n",
337 [ # # ]: 0 : state->flags & CPUIDLE_FLAG_OFF ? "disabled" : "enabled");
338 : : }
339 : :
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);
351 : :
352 : : static struct attribute *cpuidle_state_default_attrs[] = {
353 : : &attr_name.attr,
354 : : &attr_desc.attr,
355 : : &attr_latency.attr,
356 : : &attr_residency.attr,
357 : : &attr_power.attr,
358 : : &attr_usage.attr,
359 : : &attr_time.attr,
360 : : &attr_disable.attr,
361 : : &attr_above.attr,
362 : : &attr_below.attr,
363 : : &attr_default_status.attr,
364 : : NULL
365 : : };
366 : :
367 : : struct cpuidle_state_kobj {
368 : : struct cpuidle_state *state;
369 : : struct cpuidle_state_usage *state_usage;
370 : : struct completion kobj_unregister;
371 : : struct kobject kobj;
372 : : struct cpuidle_device *device;
373 : : };
374 : :
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, \
379 : : char *buf) \
380 : : { \
381 : : return sprintf(buf, "%llu\n", state_usage->s2idle_##_name);\
382 : : }
383 : :
384 : 0 : define_show_state_s2idle_ull_function(usage);
385 : 0 : define_show_state_s2idle_ull_function(time);
386 : :
387 : : #define define_one_state_s2idle_ro(_name, show) \
388 : : static struct cpuidle_state_attr attr_s2idle_##_name = \
389 : : __ATTR(_name, 0444, show, NULL)
390 : :
391 : : define_one_state_s2idle_ro(usage, show_state_s2idle_usage);
392 : : define_one_state_s2idle_ro(time, show_state_s2idle_time);
393 : :
394 : : static struct attribute *cpuidle_state_s2idle_attrs[] = {
395 : : &attr_s2idle_usage.attr,
396 : : &attr_s2idle_time.attr,
397 : : NULL
398 : : };
399 : :
400 : : static const struct attribute_group cpuidle_state_s2idle_group = {
401 : : .name = "s2idle",
402 : : .attrs = cpuidle_state_s2idle_attrs,
403 : : };
404 : :
405 : 0 : static void cpuidle_add_s2idle_attr_group(struct cpuidle_state_kobj *kobj)
406 : : {
407 : 0 : int ret;
408 : :
409 : 0 : if (!kobj->state->enter_s2idle)
410 : : return;
411 : :
412 : 0 : ret = sysfs_create_group(&kobj->kobj, &cpuidle_state_s2idle_group);
413 : 0 : if (ret)
414 : : pr_debug("%s: sysfs attribute group not created\n", __func__);
415 : : }
416 : :
417 : 0 : static void cpuidle_remove_s2idle_attr_group(struct cpuidle_state_kobj *kobj)
418 : : {
419 : 0 : if (kobj->state->enter_s2idle)
420 : 0 : sysfs_remove_group(&kobj->kobj, &cpuidle_state_s2idle_group);
421 : : }
422 : : #else
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 */
426 : :
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)
432 : :
433 : 0 : static ssize_t cpuidle_state_show(struct kobject *kobj, struct attribute *attr,
434 : : char * buf)
435 : : {
436 : 0 : int ret = -EIO;
437 : 0 : struct cpuidle_state *state = kobj_to_state(kobj);
438 : 0 : struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
439 : 0 : struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);
440 : :
441 [ # # ]: 0 : if (cattr->show)
442 : 0 : ret = cattr->show(state, state_usage, buf);
443 : :
444 : 0 : return ret;
445 : : }
446 : :
447 : 0 : static ssize_t cpuidle_state_store(struct kobject *kobj, struct attribute *attr,
448 : : const char *buf, size_t size)
449 : : {
450 : 0 : int ret = -EIO;
451 : 0 : struct cpuidle_state *state = kobj_to_state(kobj);
452 : 0 : struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
453 : 0 : struct cpuidle_state_attr *cattr = attr_to_stateattr(attr);
454 : 0 : struct cpuidle_device *dev = kobj_to_device(kobj);
455 : :
456 [ # # ]: 0 : if (cattr->store)
457 : 0 : ret = cattr->store(state, state_usage, buf, size);
458 : :
459 : : /* reset poll time cache */
460 : 0 : dev->poll_limit_ns = 0;
461 : :
462 : 0 : return ret;
463 : : }
464 : :
465 : : static const struct sysfs_ops cpuidle_state_sysfs_ops = {
466 : : .show = cpuidle_state_show,
467 : : .store = cpuidle_state_store,
468 : : };
469 : :
470 : 0 : static void cpuidle_state_sysfs_release(struct kobject *kobj)
471 : : {
472 : 0 : struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);
473 : :
474 : 0 : complete(&state_obj->kobj_unregister);
475 : 0 : }
476 : :
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,
481 : : };
482 : :
483 : 0 : static inline void cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
484 : : {
485 [ # # ]: 0 : cpuidle_remove_s2idle_attr_group(device->kobjs[i]);
486 : 0 : kobject_put(&device->kobjs[i]->kobj);
487 : 0 : wait_for_completion(&device->kobjs[i]->kobj_unregister);
488 : 0 : kfree(device->kobjs[i]);
489 : 0 : device->kobjs[i] = NULL;
490 : 0 : }
491 : :
492 : : /**
493 : : * cpuidle_add_state_sysfs - adds cpuidle states sysfs attributes
494 : : * @device: the target device
495 : : */
496 : 0 : static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
497 : : {
498 : 0 : int i, ret = -ENOMEM;
499 : 0 : struct cpuidle_state_kobj *kobj;
500 : 0 : struct cpuidle_device_kobj *kdev = device->kobj_dev;
501 : 0 : struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
502 : :
503 : : /* state statistics */
504 [ # # ]: 0 : for (i = 0; i < drv->state_count; i++) {
505 : 0 : kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
506 [ # # ]: 0 : if (!kobj) {
507 : 0 : ret = -ENOMEM;
508 : 0 : goto error_state;
509 : : }
510 : 0 : kobj->state = &drv->states[i];
511 : 0 : kobj->state_usage = &device->states_usage[i];
512 : 0 : kobj->device = device;
513 : 0 : init_completion(&kobj->kobj_unregister);
514 : :
515 : 0 : ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,
516 : : &kdev->kobj, "state%d", i);
517 [ # # ]: 0 : if (ret) {
518 : 0 : kfree(kobj);
519 : 0 : goto error_state;
520 : : }
521 [ # # ]: 0 : cpuidle_add_s2idle_attr_group(kobj);
522 : 0 : kobject_uevent(&kobj->kobj, KOBJ_ADD);
523 : 0 : device->kobjs[i] = kobj;
524 : : }
525 : :
526 : : return 0;
527 : :
528 : 0 : error_state:
529 [ # # ]: 0 : for (i = i - 1; i >= 0; i--)
530 : 0 : cpuidle_free_state_kobj(device, i);
531 : : return ret;
532 : : }
533 : :
534 : : /**
535 : : * cpuidle_remove_driver_sysfs - removes the cpuidle states sysfs attributes
536 : : * @device: the target device
537 : : */
538 : 0 : static void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
539 : : {
540 : 0 : struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
541 : 0 : int i;
542 : :
543 [ # # ]: 0 : for (i = 0; i < drv->state_count; i++)
544 : 0 : cpuidle_free_state_kobj(device, i);
545 : 0 : }
546 : :
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)
550 : :
551 : : #define define_one_driver_ro(_name, show) \
552 : : static struct cpuidle_driver_attr attr_driver_##_name = \
553 : : __ATTR(_name, 0444, show, NULL)
554 : :
555 : : struct cpuidle_driver_kobj {
556 : : struct cpuidle_driver *drv;
557 : : struct completion kobj_unregister;
558 : : struct kobject kobj;
559 : : };
560 : :
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);
565 : : };
566 : :
567 : : static ssize_t show_driver_name(struct cpuidle_driver *drv, char *buf)
568 : : {
569 : : ssize_t ret;
570 : :
571 : : spin_lock(&cpuidle_driver_lock);
572 : : ret = sprintf(buf, "%s\n", drv ? drv->name : "none");
573 : : spin_unlock(&cpuidle_driver_lock);
574 : :
575 : : return ret;
576 : : }
577 : :
578 : : static void cpuidle_driver_sysfs_release(struct kobject *kobj)
579 : : {
580 : : struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
581 : : complete(&driver_kobj->kobj_unregister);
582 : : }
583 : :
584 : : static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute *attr,
585 : : char *buf)
586 : : {
587 : : int ret = -EIO;
588 : : struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
589 : : struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
590 : :
591 : : if (dattr->show)
592 : : ret = dattr->show(driver_kobj->drv, buf);
593 : :
594 : : return ret;
595 : : }
596 : :
597 : : static ssize_t cpuidle_driver_store(struct kobject *kobj, struct attribute *attr,
598 : : const char *buf, size_t size)
599 : : {
600 : : int ret = -EIO;
601 : : struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
602 : : struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
603 : :
604 : : if (dattr->store)
605 : : ret = dattr->store(driver_kobj->drv, buf, size);
606 : :
607 : : return ret;
608 : : }
609 : :
610 : : define_one_driver_ro(name, show_driver_name);
611 : :
612 : : static const struct sysfs_ops cpuidle_driver_sysfs_ops = {
613 : : .show = cpuidle_driver_show,
614 : : .store = cpuidle_driver_store,
615 : : };
616 : :
617 : : static struct attribute *cpuidle_driver_default_attrs[] = {
618 : : &attr_driver_name.attr,
619 : : NULL
620 : : };
621 : :
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,
626 : : };
627 : :
628 : : /**
629 : : * cpuidle_add_driver_sysfs - adds the driver name sysfs attribute
630 : : * @dev: the target device
631 : : */
632 : : static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
633 : : {
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);
637 : : int ret;
638 : :
639 : : kdrv = kzalloc(sizeof(*kdrv), GFP_KERNEL);
640 : : if (!kdrv)
641 : : return -ENOMEM;
642 : :
643 : : kdrv->drv = drv;
644 : : init_completion(&kdrv->kobj_unregister);
645 : :
646 : : ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,
647 : : &kdev->kobj, "driver");
648 : : if (ret) {
649 : : kfree(kdrv);
650 : : return ret;
651 : : }
652 : :
653 : : kobject_uevent(&kdrv->kobj, KOBJ_ADD);
654 : : dev->kobj_driver = kdrv;
655 : :
656 : : return ret;
657 : : }
658 : :
659 : : /**
660 : : * cpuidle_remove_driver_sysfs - removes the driver name sysfs attribute
661 : : * @dev: the target device
662 : : */
663 : : static void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
664 : : {
665 : : struct cpuidle_driver_kobj *kdrv = dev->kobj_driver;
666 : : kobject_put(&kdrv->kobj);
667 : : wait_for_completion(&kdrv->kobj_unregister);
668 : : kfree(kdrv);
669 : : }
670 : : #else
671 : : static inline int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
672 : : {
673 : : return 0;
674 : : }
675 : :
676 : 0 : static inline void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
677 : : {
678 : 0 : ;
679 : : }
680 : : #endif
681 : :
682 : : /**
683 : : * cpuidle_add_device_sysfs - adds device specific sysfs attributes
684 : : * @device: the target device
685 : : */
686 : 0 : int cpuidle_add_device_sysfs(struct cpuidle_device *device)
687 : : {
688 : 0 : int ret;
689 : :
690 : 0 : ret = cpuidle_add_state_sysfs(device);
691 [ # # ]: 0 : if (ret)
692 : 0 : return ret;
693 : :
694 : : ret = cpuidle_add_driver_sysfs(device);
695 : : if (ret)
696 : : cpuidle_remove_state_sysfs(device);
697 : : return ret;
698 : : }
699 : :
700 : : /**
701 : : * cpuidle_remove_device_sysfs : removes device specific sysfs attributes
702 : : * @device : the target device
703 : : */
704 : 0 : void cpuidle_remove_device_sysfs(struct cpuidle_device *device)
705 : : {
706 : 0 : cpuidle_remove_driver_sysfs(device);
707 : 0 : cpuidle_remove_state_sysfs(device);
708 : 0 : }
709 : :
710 : : /**
711 : : * cpuidle_add_sysfs - creates a sysfs instance for the target device
712 : : * @dev: the target device
713 : : */
714 : 0 : int cpuidle_add_sysfs(struct cpuidle_device *dev)
715 : : {
716 : 0 : struct cpuidle_device_kobj *kdev;
717 : 0 : struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
718 : 0 : int error;
719 : :
720 : : /*
721 : : * Return if cpu_device is not setup for this CPU.
722 : : *
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()
728 : : */
729 [ # # ]: 0 : if (!cpu_dev)
730 : : return -ENODEV;
731 : :
732 : 0 : kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
733 [ # # ]: 0 : if (!kdev)
734 : : return -ENOMEM;
735 : 0 : kdev->dev = dev;
736 : 0 : dev->kobj_dev = kdev;
737 : :
738 : 0 : init_completion(&kdev->kobj_unregister);
739 : :
740 : 0 : error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
741 : : "cpuidle");
742 [ # # ]: 0 : if (error) {
743 : 0 : kfree(kdev);
744 : 0 : return error;
745 : : }
746 : :
747 : 0 : kobject_uevent(&kdev->kobj, KOBJ_ADD);
748 : :
749 : 0 : return 0;
750 : : }
751 : :
752 : : /**
753 : : * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
754 : : * @dev: the target device
755 : : */
756 : 0 : void cpuidle_remove_sysfs(struct cpuidle_device *dev)
757 : : {
758 : 0 : struct cpuidle_device_kobj *kdev = dev->kobj_dev;
759 : :
760 : 0 : kobject_put(&kdev->kobj);
761 : 0 : wait_for_completion(&kdev->kobj_unregister);
762 : 0 : kfree(kdev);
763 : 0 : }
|
