Root/
1 | /* |
2 | * drivers/base/power/sysfs.c - sysfs entries for device PM |
3 | */ |
4 | |
5 | #include <linux/device.h> |
6 | #include <linux/string.h> |
7 | #include <linux/export.h> |
8 | #include <linux/pm_qos.h> |
9 | #include <linux/pm_runtime.h> |
10 | #include <linux/atomic.h> |
11 | #include <linux/jiffies.h> |
12 | #include "power.h" |
13 | |
14 | /* |
15 | * control - Report/change current runtime PM setting of the device |
16 | * |
17 | * Runtime power management of a device can be blocked with the help of |
18 | * this attribute. All devices have one of the following two values for |
19 | * the power/control file: |
20 | * |
21 | * + "auto\n" to allow the device to be power managed at run time; |
22 | * + "on\n" to prevent the device from being power managed at run time; |
23 | * |
24 | * The default for all devices is "auto", which means that devices may be |
25 | * subject to automatic power management, depending on their drivers. |
26 | * Changing this attribute to "on" prevents the driver from power managing |
27 | * the device at run time. Doing that while the device is suspended causes |
28 | * it to be woken up. |
29 | * |
30 | * wakeup - Report/change current wakeup option for device |
31 | * |
32 | * Some devices support "wakeup" events, which are hardware signals |
33 | * used to activate devices from suspended or low power states. Such |
34 | * devices have one of three values for the sysfs power/wakeup file: |
35 | * |
36 | * + "enabled\n" to issue the events; |
37 | * + "disabled\n" not to do so; or |
38 | * + "\n" for temporary or permanent inability to issue wakeup. |
39 | * |
40 | * (For example, unconfigured USB devices can't issue wakeups.) |
41 | * |
42 | * Familiar examples of devices that can issue wakeup events include |
43 | * keyboards and mice (both PS2 and USB styles), power buttons, modems, |
44 | * "Wake-On-LAN" Ethernet links, GPIO lines, and more. Some events |
45 | * will wake the entire system from a suspend state; others may just |
46 | * wake up the device (if the system as a whole is already active). |
47 | * Some wakeup events use normal IRQ lines; other use special out |
48 | * of band signaling. |
49 | * |
50 | * It is the responsibility of device drivers to enable (or disable) |
51 | * wakeup signaling as part of changing device power states, respecting |
52 | * the policy choices provided through the driver model. |
53 | * |
54 | * Devices may not be able to generate wakeup events from all power |
55 | * states. Also, the events may be ignored in some configurations; |
56 | * for example, they might need help from other devices that aren't |
57 | * active, or which may have wakeup disabled. Some drivers rely on |
58 | * wakeup events internally (unless they are disabled), keeping |
59 | * their hardware in low power modes whenever they're unused. This |
60 | * saves runtime power, without requiring system-wide sleep states. |
61 | * |
62 | * async - Report/change current async suspend setting for the device |
63 | * |
64 | * Asynchronous suspend and resume of the device during system-wide power |
65 | * state transitions can be enabled by writing "enabled" to this file. |
66 | * Analogously, if "disabled" is written to this file, the device will be |
67 | * suspended and resumed synchronously. |
68 | * |
69 | * All devices have one of the following two values for power/async: |
70 | * |
71 | * + "enabled\n" to permit the asynchronous suspend/resume of the device; |
72 | * + "disabled\n" to forbid it; |
73 | * |
74 | * NOTE: It generally is unsafe to permit the asynchronous suspend/resume |
75 | * of a device unless it is certain that all of the PM dependencies of the |
76 | * device are known to the PM core. However, for some devices this |
77 | * attribute is set to "enabled" by bus type code or device drivers and in |
78 | * that cases it should be safe to leave the default value. |
79 | * |
80 | * autosuspend_delay_ms - Report/change a device's autosuspend_delay value |
81 | * |
82 | * Some drivers don't want to carry out a runtime suspend as soon as a |
83 | * device becomes idle; they want it always to remain idle for some period |
84 | * of time before suspending it. This period is the autosuspend_delay |
85 | * value (expressed in milliseconds) and it can be controlled by the user. |
86 | * If the value is negative then the device will never be runtime |
87 | * suspended. |
88 | * |
89 | * NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay |
90 | * value are used only if the driver calls pm_runtime_use_autosuspend(). |
91 | * |
92 | * wakeup_count - Report the number of wakeup events related to the device |
93 | */ |
94 | |
95 | static const char enabled[] = "enabled"; |
96 | static const char disabled[] = "disabled"; |
97 | |
98 | const char power_group_name[] = "power"; |
99 | EXPORT_SYMBOL_GPL(power_group_name); |
100 | |
101 | #ifdef CONFIG_PM_RUNTIME |
102 | static const char ctrl_auto[] = "auto"; |
103 | static const char ctrl_on[] = "on"; |
104 | |
105 | static ssize_t control_show(struct device *dev, struct device_attribute *attr, |
106 | char *buf) |
107 | { |
108 | return sprintf(buf, "%s\n", |
109 | dev->power.runtime_auto ? ctrl_auto : ctrl_on); |
110 | } |
111 | |
112 | static ssize_t control_store(struct device * dev, struct device_attribute *attr, |
113 | const char * buf, size_t n) |
114 | { |
115 | char *cp; |
116 | int len = n; |
117 | |
118 | cp = memchr(buf, '\n', n); |
119 | if (cp) |
120 | len = cp - buf; |
121 | device_lock(dev); |
122 | if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0) |
123 | pm_runtime_allow(dev); |
124 | else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0) |
125 | pm_runtime_forbid(dev); |
126 | else |
127 | n = -EINVAL; |
128 | device_unlock(dev); |
129 | return n; |
130 | } |
131 | |
132 | static DEVICE_ATTR(control, 0644, control_show, control_store); |
133 | |
134 | static ssize_t rtpm_active_time_show(struct device *dev, |
135 | struct device_attribute *attr, char *buf) |
136 | { |
137 | int ret; |
138 | spin_lock_irq(&dev->power.lock); |
139 | update_pm_runtime_accounting(dev); |
140 | ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies)); |
141 | spin_unlock_irq(&dev->power.lock); |
142 | return ret; |
143 | } |
144 | |
145 | static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL); |
146 | |
147 | static ssize_t rtpm_suspended_time_show(struct device *dev, |
148 | struct device_attribute *attr, char *buf) |
149 | { |
150 | int ret; |
151 | spin_lock_irq(&dev->power.lock); |
152 | update_pm_runtime_accounting(dev); |
153 | ret = sprintf(buf, "%i\n", |
154 | jiffies_to_msecs(dev->power.suspended_jiffies)); |
155 | spin_unlock_irq(&dev->power.lock); |
156 | return ret; |
157 | } |
158 | |
159 | static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL); |
160 | |
161 | static ssize_t rtpm_status_show(struct device *dev, |
162 | struct device_attribute *attr, char *buf) |
163 | { |
164 | const char *p; |
165 | |
166 | if (dev->power.runtime_error) { |
167 | p = "error\n"; |
168 | } else if (dev->power.disable_depth) { |
169 | p = "unsupported\n"; |
170 | } else { |
171 | switch (dev->power.runtime_status) { |
172 | case RPM_SUSPENDED: |
173 | p = "suspended\n"; |
174 | break; |
175 | case RPM_SUSPENDING: |
176 | p = "suspending\n"; |
177 | break; |
178 | case RPM_RESUMING: |
179 | p = "resuming\n"; |
180 | break; |
181 | case RPM_ACTIVE: |
182 | p = "active\n"; |
183 | break; |
184 | default: |
185 | return -EIO; |
186 | } |
187 | } |
188 | return sprintf(buf, p); |
189 | } |
190 | |
191 | static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL); |
192 | |
193 | static ssize_t autosuspend_delay_ms_show(struct device *dev, |
194 | struct device_attribute *attr, char *buf) |
195 | { |
196 | if (!dev->power.use_autosuspend) |
197 | return -EIO; |
198 | return sprintf(buf, "%d\n", dev->power.autosuspend_delay); |
199 | } |
200 | |
201 | static ssize_t autosuspend_delay_ms_store(struct device *dev, |
202 | struct device_attribute *attr, const char *buf, size_t n) |
203 | { |
204 | long delay; |
205 | |
206 | if (!dev->power.use_autosuspend) |
207 | return -EIO; |
208 | |
209 | if (strict_strtol(buf, 10, &delay) != 0 || delay != (int) delay) |
210 | return -EINVAL; |
211 | |
212 | device_lock(dev); |
213 | pm_runtime_set_autosuspend_delay(dev, delay); |
214 | device_unlock(dev); |
215 | return n; |
216 | } |
217 | |
218 | static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show, |
219 | autosuspend_delay_ms_store); |
220 | |
221 | static ssize_t pm_qos_latency_show(struct device *dev, |
222 | struct device_attribute *attr, char *buf) |
223 | { |
224 | return sprintf(buf, "%d\n", dev_pm_qos_requested_latency(dev)); |
225 | } |
226 | |
227 | static ssize_t pm_qos_latency_store(struct device *dev, |
228 | struct device_attribute *attr, |
229 | const char *buf, size_t n) |
230 | { |
231 | s32 value; |
232 | int ret; |
233 | |
234 | if (kstrtos32(buf, 0, &value)) |
235 | return -EINVAL; |
236 | |
237 | if (value < 0) |
238 | return -EINVAL; |
239 | |
240 | ret = dev_pm_qos_update_request(dev->power.qos->latency_req, value); |
241 | return ret < 0 ? ret : n; |
242 | } |
243 | |
244 | static DEVICE_ATTR(pm_qos_resume_latency_us, 0644, |
245 | pm_qos_latency_show, pm_qos_latency_store); |
246 | |
247 | static ssize_t pm_qos_no_power_off_show(struct device *dev, |
248 | struct device_attribute *attr, |
249 | char *buf) |
250 | { |
251 | return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev) |
252 | & PM_QOS_FLAG_NO_POWER_OFF)); |
253 | } |
254 | |
255 | static ssize_t pm_qos_no_power_off_store(struct device *dev, |
256 | struct device_attribute *attr, |
257 | const char *buf, size_t n) |
258 | { |
259 | int ret; |
260 | |
261 | if (kstrtoint(buf, 0, &ret)) |
262 | return -EINVAL; |
263 | |
264 | if (ret != 0 && ret != 1) |
265 | return -EINVAL; |
266 | |
267 | ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret); |
268 | return ret < 0 ? ret : n; |
269 | } |
270 | |
271 | static DEVICE_ATTR(pm_qos_no_power_off, 0644, |
272 | pm_qos_no_power_off_show, pm_qos_no_power_off_store); |
273 | |
274 | static ssize_t pm_qos_remote_wakeup_show(struct device *dev, |
275 | struct device_attribute *attr, |
276 | char *buf) |
277 | { |
278 | return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev) |
279 | & PM_QOS_FLAG_REMOTE_WAKEUP)); |
280 | } |
281 | |
282 | static ssize_t pm_qos_remote_wakeup_store(struct device *dev, |
283 | struct device_attribute *attr, |
284 | const char *buf, size_t n) |
285 | { |
286 | int ret; |
287 | |
288 | if (kstrtoint(buf, 0, &ret)) |
289 | return -EINVAL; |
290 | |
291 | if (ret != 0 && ret != 1) |
292 | return -EINVAL; |
293 | |
294 | ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP, ret); |
295 | return ret < 0 ? ret : n; |
296 | } |
297 | |
298 | static DEVICE_ATTR(pm_qos_remote_wakeup, 0644, |
299 | pm_qos_remote_wakeup_show, pm_qos_remote_wakeup_store); |
300 | #endif /* CONFIG_PM_RUNTIME */ |
301 | |
302 | #ifdef CONFIG_PM_SLEEP |
303 | static ssize_t |
304 | wake_show(struct device * dev, struct device_attribute *attr, char * buf) |
305 | { |
306 | return sprintf(buf, "%s\n", device_can_wakeup(dev) |
307 | ? (device_may_wakeup(dev) ? enabled : disabled) |
308 | : ""); |
309 | } |
310 | |
311 | static ssize_t |
312 | wake_store(struct device * dev, struct device_attribute *attr, |
313 | const char * buf, size_t n) |
314 | { |
315 | char *cp; |
316 | int len = n; |
317 | |
318 | if (!device_can_wakeup(dev)) |
319 | return -EINVAL; |
320 | |
321 | cp = memchr(buf, '\n', n); |
322 | if (cp) |
323 | len = cp - buf; |
324 | if (len == sizeof enabled - 1 |
325 | && strncmp(buf, enabled, sizeof enabled - 1) == 0) |
326 | device_set_wakeup_enable(dev, 1); |
327 | else if (len == sizeof disabled - 1 |
328 | && strncmp(buf, disabled, sizeof disabled - 1) == 0) |
329 | device_set_wakeup_enable(dev, 0); |
330 | else |
331 | return -EINVAL; |
332 | return n; |
333 | } |
334 | |
335 | static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store); |
336 | |
337 | static ssize_t wakeup_count_show(struct device *dev, |
338 | struct device_attribute *attr, char *buf) |
339 | { |
340 | unsigned long count = 0; |
341 | bool enabled = false; |
342 | |
343 | spin_lock_irq(&dev->power.lock); |
344 | if (dev->power.wakeup) { |
345 | count = dev->power.wakeup->event_count; |
346 | enabled = true; |
347 | } |
348 | spin_unlock_irq(&dev->power.lock); |
349 | return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); |
350 | } |
351 | |
352 | static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL); |
353 | |
354 | static ssize_t wakeup_active_count_show(struct device *dev, |
355 | struct device_attribute *attr, char *buf) |
356 | { |
357 | unsigned long count = 0; |
358 | bool enabled = false; |
359 | |
360 | spin_lock_irq(&dev->power.lock); |
361 | if (dev->power.wakeup) { |
362 | count = dev->power.wakeup->active_count; |
363 | enabled = true; |
364 | } |
365 | spin_unlock_irq(&dev->power.lock); |
366 | return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); |
367 | } |
368 | |
369 | static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL); |
370 | |
371 | static ssize_t wakeup_abort_count_show(struct device *dev, |
372 | struct device_attribute *attr, |
373 | char *buf) |
374 | { |
375 | unsigned long count = 0; |
376 | bool enabled = false; |
377 | |
378 | spin_lock_irq(&dev->power.lock); |
379 | if (dev->power.wakeup) { |
380 | count = dev->power.wakeup->wakeup_count; |
381 | enabled = true; |
382 | } |
383 | spin_unlock_irq(&dev->power.lock); |
384 | return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); |
385 | } |
386 | |
387 | static DEVICE_ATTR(wakeup_abort_count, 0444, wakeup_abort_count_show, NULL); |
388 | |
389 | static ssize_t wakeup_expire_count_show(struct device *dev, |
390 | struct device_attribute *attr, |
391 | char *buf) |
392 | { |
393 | unsigned long count = 0; |
394 | bool enabled = false; |
395 | |
396 | spin_lock_irq(&dev->power.lock); |
397 | if (dev->power.wakeup) { |
398 | count = dev->power.wakeup->expire_count; |
399 | enabled = true; |
400 | } |
401 | spin_unlock_irq(&dev->power.lock); |
402 | return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n"); |
403 | } |
404 | |
405 | static DEVICE_ATTR(wakeup_expire_count, 0444, wakeup_expire_count_show, NULL); |
406 | |
407 | static ssize_t wakeup_active_show(struct device *dev, |
408 | struct device_attribute *attr, char *buf) |
409 | { |
410 | unsigned int active = 0; |
411 | bool enabled = false; |
412 | |
413 | spin_lock_irq(&dev->power.lock); |
414 | if (dev->power.wakeup) { |
415 | active = dev->power.wakeup->active; |
416 | enabled = true; |
417 | } |
418 | spin_unlock_irq(&dev->power.lock); |
419 | return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n"); |
420 | } |
421 | |
422 | static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL); |
423 | |
424 | static ssize_t wakeup_total_time_show(struct device *dev, |
425 | struct device_attribute *attr, char *buf) |
426 | { |
427 | s64 msec = 0; |
428 | bool enabled = false; |
429 | |
430 | spin_lock_irq(&dev->power.lock); |
431 | if (dev->power.wakeup) { |
432 | msec = ktime_to_ms(dev->power.wakeup->total_time); |
433 | enabled = true; |
434 | } |
435 | spin_unlock_irq(&dev->power.lock); |
436 | return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); |
437 | } |
438 | |
439 | static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL); |
440 | |
441 | static ssize_t wakeup_max_time_show(struct device *dev, |
442 | struct device_attribute *attr, char *buf) |
443 | { |
444 | s64 msec = 0; |
445 | bool enabled = false; |
446 | |
447 | spin_lock_irq(&dev->power.lock); |
448 | if (dev->power.wakeup) { |
449 | msec = ktime_to_ms(dev->power.wakeup->max_time); |
450 | enabled = true; |
451 | } |
452 | spin_unlock_irq(&dev->power.lock); |
453 | return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); |
454 | } |
455 | |
456 | static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL); |
457 | |
458 | static ssize_t wakeup_last_time_show(struct device *dev, |
459 | struct device_attribute *attr, char *buf) |
460 | { |
461 | s64 msec = 0; |
462 | bool enabled = false; |
463 | |
464 | spin_lock_irq(&dev->power.lock); |
465 | if (dev->power.wakeup) { |
466 | msec = ktime_to_ms(dev->power.wakeup->last_time); |
467 | enabled = true; |
468 | } |
469 | spin_unlock_irq(&dev->power.lock); |
470 | return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); |
471 | } |
472 | |
473 | static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL); |
474 | |
475 | #ifdef CONFIG_PM_AUTOSLEEP |
476 | static ssize_t wakeup_prevent_sleep_time_show(struct device *dev, |
477 | struct device_attribute *attr, |
478 | char *buf) |
479 | { |
480 | s64 msec = 0; |
481 | bool enabled = false; |
482 | |
483 | spin_lock_irq(&dev->power.lock); |
484 | if (dev->power.wakeup) { |
485 | msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time); |
486 | enabled = true; |
487 | } |
488 | spin_unlock_irq(&dev->power.lock); |
489 | return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n"); |
490 | } |
491 | |
492 | static DEVICE_ATTR(wakeup_prevent_sleep_time_ms, 0444, |
493 | wakeup_prevent_sleep_time_show, NULL); |
494 | #endif /* CONFIG_PM_AUTOSLEEP */ |
495 | #endif /* CONFIG_PM_SLEEP */ |
496 | |
497 | #ifdef CONFIG_PM_ADVANCED_DEBUG |
498 | #ifdef CONFIG_PM_RUNTIME |
499 | |
500 | static ssize_t rtpm_usagecount_show(struct device *dev, |
501 | struct device_attribute *attr, char *buf) |
502 | { |
503 | return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count)); |
504 | } |
505 | |
506 | static ssize_t rtpm_children_show(struct device *dev, |
507 | struct device_attribute *attr, char *buf) |
508 | { |
509 | return sprintf(buf, "%d\n", dev->power.ignore_children ? |
510 | 0 : atomic_read(&dev->power.child_count)); |
511 | } |
512 | |
513 | static ssize_t rtpm_enabled_show(struct device *dev, |
514 | struct device_attribute *attr, char *buf) |
515 | { |
516 | if ((dev->power.disable_depth) && (dev->power.runtime_auto == false)) |
517 | return sprintf(buf, "disabled & forbidden\n"); |
518 | else if (dev->power.disable_depth) |
519 | return sprintf(buf, "disabled\n"); |
520 | else if (dev->power.runtime_auto == false) |
521 | return sprintf(buf, "forbidden\n"); |
522 | return sprintf(buf, "enabled\n"); |
523 | } |
524 | |
525 | static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL); |
526 | static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL); |
527 | static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL); |
528 | |
529 | #endif |
530 | |
531 | #ifdef CONFIG_PM_SLEEP |
532 | |
533 | static ssize_t async_show(struct device *dev, struct device_attribute *attr, |
534 | char *buf) |
535 | { |
536 | return sprintf(buf, "%s\n", |
537 | device_async_suspend_enabled(dev) ? enabled : disabled); |
538 | } |
539 | |
540 | static ssize_t async_store(struct device *dev, struct device_attribute *attr, |
541 | const char *buf, size_t n) |
542 | { |
543 | char *cp; |
544 | int len = n; |
545 | |
546 | cp = memchr(buf, '\n', n); |
547 | if (cp) |
548 | len = cp - buf; |
549 | if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0) |
550 | device_enable_async_suspend(dev); |
551 | else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0) |
552 | device_disable_async_suspend(dev); |
553 | else |
554 | return -EINVAL; |
555 | return n; |
556 | } |
557 | |
558 | static DEVICE_ATTR(async, 0644, async_show, async_store); |
559 | |
560 | #endif |
561 | #endif /* CONFIG_PM_ADVANCED_DEBUG */ |
562 | |
563 | static struct attribute *power_attrs[] = { |
564 | #ifdef CONFIG_PM_ADVANCED_DEBUG |
565 | #ifdef CONFIG_PM_SLEEP |
566 | &dev_attr_async.attr, |
567 | #endif |
568 | #ifdef CONFIG_PM_RUNTIME |
569 | &dev_attr_runtime_status.attr, |
570 | &dev_attr_runtime_usage.attr, |
571 | &dev_attr_runtime_active_kids.attr, |
572 | &dev_attr_runtime_enabled.attr, |
573 | #endif |
574 | #endif /* CONFIG_PM_ADVANCED_DEBUG */ |
575 | NULL, |
576 | }; |
577 | static struct attribute_group pm_attr_group = { |
578 | .name = power_group_name, |
579 | .attrs = power_attrs, |
580 | }; |
581 | |
582 | static struct attribute *wakeup_attrs[] = { |
583 | #ifdef CONFIG_PM_SLEEP |
584 | &dev_attr_wakeup.attr, |
585 | &dev_attr_wakeup_count.attr, |
586 | &dev_attr_wakeup_active_count.attr, |
587 | &dev_attr_wakeup_abort_count.attr, |
588 | &dev_attr_wakeup_expire_count.attr, |
589 | &dev_attr_wakeup_active.attr, |
590 | &dev_attr_wakeup_total_time_ms.attr, |
591 | &dev_attr_wakeup_max_time_ms.attr, |
592 | &dev_attr_wakeup_last_time_ms.attr, |
593 | #ifdef CONFIG_PM_AUTOSLEEP |
594 | &dev_attr_wakeup_prevent_sleep_time_ms.attr, |
595 | #endif |
596 | #endif |
597 | NULL, |
598 | }; |
599 | static struct attribute_group pm_wakeup_attr_group = { |
600 | .name = power_group_name, |
601 | .attrs = wakeup_attrs, |
602 | }; |
603 | |
604 | static struct attribute *runtime_attrs[] = { |
605 | #ifdef CONFIG_PM_RUNTIME |
606 | #ifndef CONFIG_PM_ADVANCED_DEBUG |
607 | &dev_attr_runtime_status.attr, |
608 | #endif |
609 | &dev_attr_control.attr, |
610 | &dev_attr_runtime_suspended_time.attr, |
611 | &dev_attr_runtime_active_time.attr, |
612 | &dev_attr_autosuspend_delay_ms.attr, |
613 | #endif /* CONFIG_PM_RUNTIME */ |
614 | NULL, |
615 | }; |
616 | static struct attribute_group pm_runtime_attr_group = { |
617 | .name = power_group_name, |
618 | .attrs = runtime_attrs, |
619 | }; |
620 | |
621 | static struct attribute *pm_qos_latency_attrs[] = { |
622 | #ifdef CONFIG_PM_RUNTIME |
623 | &dev_attr_pm_qos_resume_latency_us.attr, |
624 | #endif /* CONFIG_PM_RUNTIME */ |
625 | NULL, |
626 | }; |
627 | static struct attribute_group pm_qos_latency_attr_group = { |
628 | .name = power_group_name, |
629 | .attrs = pm_qos_latency_attrs, |
630 | }; |
631 | |
632 | static struct attribute *pm_qos_flags_attrs[] = { |
633 | #ifdef CONFIG_PM_RUNTIME |
634 | &dev_attr_pm_qos_no_power_off.attr, |
635 | &dev_attr_pm_qos_remote_wakeup.attr, |
636 | #endif /* CONFIG_PM_RUNTIME */ |
637 | NULL, |
638 | }; |
639 | static struct attribute_group pm_qos_flags_attr_group = { |
640 | .name = power_group_name, |
641 | .attrs = pm_qos_flags_attrs, |
642 | }; |
643 | |
644 | int dpm_sysfs_add(struct device *dev) |
645 | { |
646 | int rc; |
647 | |
648 | rc = sysfs_create_group(&dev->kobj, &pm_attr_group); |
649 | if (rc) |
650 | return rc; |
651 | |
652 | if (pm_runtime_callbacks_present(dev)) { |
653 | rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group); |
654 | if (rc) |
655 | goto err_out; |
656 | } |
657 | |
658 | if (device_can_wakeup(dev)) { |
659 | rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group); |
660 | if (rc) { |
661 | if (pm_runtime_callbacks_present(dev)) |
662 | sysfs_unmerge_group(&dev->kobj, |
663 | &pm_runtime_attr_group); |
664 | goto err_out; |
665 | } |
666 | } |
667 | return 0; |
668 | |
669 | err_out: |
670 | sysfs_remove_group(&dev->kobj, &pm_attr_group); |
671 | return rc; |
672 | } |
673 | |
674 | int wakeup_sysfs_add(struct device *dev) |
675 | { |
676 | return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group); |
677 | } |
678 | |
679 | void wakeup_sysfs_remove(struct device *dev) |
680 | { |
681 | sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); |
682 | } |
683 | |
684 | int pm_qos_sysfs_add_latency(struct device *dev) |
685 | { |
686 | return sysfs_merge_group(&dev->kobj, &pm_qos_latency_attr_group); |
687 | } |
688 | |
689 | void pm_qos_sysfs_remove_latency(struct device *dev) |
690 | { |
691 | sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_attr_group); |
692 | } |
693 | |
694 | int pm_qos_sysfs_add_flags(struct device *dev) |
695 | { |
696 | return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group); |
697 | } |
698 | |
699 | void pm_qos_sysfs_remove_flags(struct device *dev) |
700 | { |
701 | sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group); |
702 | } |
703 | |
704 | void rpm_sysfs_remove(struct device *dev) |
705 | { |
706 | sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group); |
707 | } |
708 | |
709 | void dpm_sysfs_remove(struct device *dev) |
710 | { |
711 | dev_pm_qos_constraints_destroy(dev); |
712 | rpm_sysfs_remove(dev); |
713 | sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); |
714 | sysfs_remove_group(&dev->kobj, &pm_attr_group); |
715 | } |
716 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9