Branch data Line data Source code
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 (kstrtol(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 : 0 : wake_show(struct device * dev, struct device_attribute *attr, char * buf)
305 : : {
306 [ # # ]: 0 : return sprintf(buf, "%s\n", device_can_wakeup(dev)
307 [ # # ]: 0 : ? (device_may_wakeup(dev) ? enabled : disabled)
308 : : : "");
309 : : }
310 : :
311 : : static ssize_t
312 : 0 : wake_store(struct device * dev, struct device_attribute *attr,
313 : : const char * buf, size_t n)
314 : : {
315 : : char *cp;
316 : 0 : int len = n;
317 : :
318 [ # # ]: 0 : if (!device_can_wakeup(dev))
319 : : return -EINVAL;
320 : :
321 : 0 : cp = memchr(buf, '\n', n);
322 [ # # ]: 0 : if (cp)
323 : 0 : len = cp - buf;
324 [ # # ]: 0 : if (len == sizeof enabled - 1
325 [ # # ]: 0 : && strncmp(buf, enabled, sizeof enabled - 1) == 0)
326 : 0 : device_set_wakeup_enable(dev, 1);
327 [ # # ]: 0 : else if (len == sizeof disabled - 1
328 [ # # ]: 0 : && strncmp(buf, disabled, sizeof disabled - 1) == 0)
329 : 0 : device_set_wakeup_enable(dev, 0);
330 : : else
331 : : return -EINVAL;
332 : 0 : return n;
333 : : }
334 : :
335 : : static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
336 : :
337 : 0 : 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 [ # # ]: 0 : if (dev->power.wakeup) {
345 : 0 : count = dev->power.wakeup->event_count;
346 : : enabled = true;
347 : : }
348 : : spin_unlock_irq(&dev->power.lock);
349 [ # # ]: 0 : 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 : 0 : 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 [ # # ]: 0 : if (dev->power.wakeup) {
362 : 0 : count = dev->power.wakeup->active_count;
363 : : enabled = true;
364 : : }
365 : : spin_unlock_irq(&dev->power.lock);
366 [ # # ]: 0 : 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 : 0 : 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 [ # # ]: 0 : if (dev->power.wakeup) {
380 : 0 : count = dev->power.wakeup->wakeup_count;
381 : : enabled = true;
382 : : }
383 : : spin_unlock_irq(&dev->power.lock);
384 [ # # ]: 0 : 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 : 0 : 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 [ # # ]: 0 : if (dev->power.wakeup) {
398 : 0 : count = dev->power.wakeup->expire_count;
399 : : enabled = true;
400 : : }
401 : : spin_unlock_irq(&dev->power.lock);
402 [ # # ]: 0 : 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 : 0 : 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 [ # # ]: 0 : if (dev->power.wakeup) {
415 : 0 : active = dev->power.wakeup->active;
416 : : enabled = true;
417 : : }
418 : : spin_unlock_irq(&dev->power.lock);
419 [ # # ]: 0 : 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 : 0 : 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 [ # # ]: 0 : 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 [ # # ]: 0 : 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 : 0 : 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 [ # # ]: 0 : 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 [ # # ]: 0 : 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 : 0 : 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 [ # # ]: 0 : 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 [ # # ]: 0 : 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 : 0 : int dpm_sysfs_add(struct device *dev)
645 : : {
646 : : int rc;
647 : :
648 : 128 : rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
649 [ + - ]: 128 : 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 [ - + ]: 128 : if (device_can_wakeup(dev)) {
659 : 0 : rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
660 [ # # ]: 0 : 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 : 0 : sysfs_remove_group(&dev->kobj, &pm_attr_group);
671 : 0 : return rc;
672 : : }
673 : :
674 : 0 : int wakeup_sysfs_add(struct device *dev)
675 : : {
676 : 2 : return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
677 : : }
678 : :
679 : 0 : void wakeup_sysfs_remove(struct device *dev)
680 : : {
681 : 0 : sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
682 : 0 : }
683 : :
684 : 0 : int pm_qos_sysfs_add_latency(struct device *dev)
685 : : {
686 : 0 : return sysfs_merge_group(&dev->kobj, &pm_qos_latency_attr_group);
687 : : }
688 : :
689 : 0 : void pm_qos_sysfs_remove_latency(struct device *dev)
690 : : {
691 : 16 : sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_attr_group);
692 : 16 : }
693 : :
694 : 0 : int pm_qos_sysfs_add_flags(struct device *dev)
695 : : {
696 : 0 : return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
697 : : }
698 : :
699 : 0 : void pm_qos_sysfs_remove_flags(struct device *dev)
700 : : {
701 : 16 : sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
702 : 16 : }
703 : :
704 : 0 : void rpm_sysfs_remove(struct device *dev)
705 : : {
706 : 16 : sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
707 : 0 : }
708 : :
709 : 0 : void dpm_sysfs_remove(struct device *dev)
710 : : {
711 : 16 : dev_pm_qos_constraints_destroy(dev);
712 : : rpm_sysfs_remove(dev);
713 : 16 : sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
714 : 16 : sysfs_remove_group(&dev->kobj, &pm_attr_group);
715 : 16 : }
|
