Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /* sysfs entries for device PM */
3 : #include <linux/device.h>
4 : #include <linux/kobject.h>
5 : #include <linux/string.h>
6 : #include <linux/export.h>
7 : #include <linux/pm_qos.h>
8 : #include <linux/pm_runtime.h>
9 : #include <linux/pm_wakeup.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 : const char power_group_name[] = "power";
96 : EXPORT_SYMBOL_GPL(power_group_name);
97 :
98 : static const char ctrl_auto[] = "auto";
99 : static const char ctrl_on[] = "on";
100 :
101 0 : static ssize_t control_show(struct device *dev, struct device_attribute *attr,
102 : char *buf)
103 : {
104 0 : return sysfs_emit(buf, "%s\n",
105 0 : dev->power.runtime_auto ? ctrl_auto : ctrl_on);
106 : }
107 :
108 0 : static ssize_t control_store(struct device * dev, struct device_attribute *attr,
109 : const char * buf, size_t n)
110 : {
111 0 : device_lock(dev);
112 0 : if (sysfs_streq(buf, ctrl_auto))
113 0 : pm_runtime_allow(dev);
114 0 : else if (sysfs_streq(buf, ctrl_on))
115 0 : pm_runtime_forbid(dev);
116 : else
117 : n = -EINVAL;
118 0 : device_unlock(dev);
119 0 : return n;
120 : }
121 :
122 : static DEVICE_ATTR_RW(control);
123 :
124 0 : static ssize_t runtime_active_time_show(struct device *dev,
125 : struct device_attribute *attr,
126 : char *buf)
127 : {
128 0 : u64 tmp = pm_runtime_active_time(dev);
129 :
130 0 : do_div(tmp, NSEC_PER_MSEC);
131 :
132 0 : return sysfs_emit(buf, "%llu\n", tmp);
133 : }
134 :
135 : static DEVICE_ATTR_RO(runtime_active_time);
136 :
137 0 : static ssize_t runtime_suspended_time_show(struct device *dev,
138 : struct device_attribute *attr,
139 : char *buf)
140 : {
141 0 : u64 tmp = pm_runtime_suspended_time(dev);
142 :
143 0 : do_div(tmp, NSEC_PER_MSEC);
144 :
145 0 : return sysfs_emit(buf, "%llu\n", tmp);
146 : }
147 :
148 : static DEVICE_ATTR_RO(runtime_suspended_time);
149 :
150 0 : static ssize_t runtime_status_show(struct device *dev,
151 : struct device_attribute *attr, char *buf)
152 : {
153 : const char *output;
154 :
155 0 : if (dev->power.runtime_error) {
156 : output = "error";
157 0 : } else if (dev->power.disable_depth) {
158 : output = "unsupported";
159 : } else {
160 0 : switch (dev->power.runtime_status) {
161 : case RPM_SUSPENDED:
162 : output = "suspended";
163 : break;
164 : case RPM_SUSPENDING:
165 0 : output = "suspending";
166 0 : break;
167 : case RPM_RESUMING:
168 0 : output = "resuming";
169 0 : break;
170 : case RPM_ACTIVE:
171 0 : output = "active";
172 0 : break;
173 : default:
174 : return -EIO;
175 : }
176 : }
177 0 : return sysfs_emit(buf, "%s\n", output);
178 : }
179 :
180 : static DEVICE_ATTR_RO(runtime_status);
181 :
182 0 : static ssize_t autosuspend_delay_ms_show(struct device *dev,
183 : struct device_attribute *attr,
184 : char *buf)
185 : {
186 0 : if (!dev->power.use_autosuspend)
187 : return -EIO;
188 :
189 0 : return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay);
190 : }
191 :
192 0 : static ssize_t autosuspend_delay_ms_store(struct device *dev,
193 : struct device_attribute *attr, const char *buf, size_t n)
194 : {
195 : long delay;
196 :
197 0 : if (!dev->power.use_autosuspend)
198 : return -EIO;
199 :
200 0 : if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay)
201 : return -EINVAL;
202 :
203 0 : device_lock(dev);
204 0 : pm_runtime_set_autosuspend_delay(dev, delay);
205 0 : device_unlock(dev);
206 0 : return n;
207 : }
208 :
209 : static DEVICE_ATTR_RW(autosuspend_delay_ms);
210 :
211 0 : static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
212 : struct device_attribute *attr,
213 : char *buf)
214 : {
215 0 : s32 value = dev_pm_qos_requested_resume_latency(dev);
216 :
217 0 : if (value == 0)
218 0 : return sysfs_emit(buf, "n/a\n");
219 0 : if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
220 0 : value = 0;
221 :
222 0 : return sysfs_emit(buf, "%d\n", value);
223 : }
224 :
225 0 : static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
226 : struct device_attribute *attr,
227 : const char *buf, size_t n)
228 : {
229 : s32 value;
230 : int ret;
231 :
232 0 : if (!kstrtos32(buf, 0, &value)) {
233 : /*
234 : * Prevent users from writing negative or "no constraint" values
235 : * directly.
236 : */
237 0 : if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
238 : return -EINVAL;
239 :
240 0 : if (value == 0)
241 0 : value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;
242 0 : } else if (sysfs_streq(buf, "n/a")) {
243 0 : value = 0;
244 : } else {
245 : return -EINVAL;
246 : }
247 :
248 0 : ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req,
249 : value);
250 0 : return ret < 0 ? ret : n;
251 : }
252 :
253 : static DEVICE_ATTR_RW(pm_qos_resume_latency_us);
254 :
255 0 : static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
256 : struct device_attribute *attr,
257 : char *buf)
258 : {
259 0 : s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
260 :
261 0 : if (value < 0)
262 0 : return sysfs_emit(buf, "%s\n", "auto");
263 0 : if (value == PM_QOS_LATENCY_ANY)
264 0 : return sysfs_emit(buf, "%s\n", "any");
265 :
266 0 : return sysfs_emit(buf, "%d\n", value);
267 : }
268 :
269 0 : static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
270 : struct device_attribute *attr,
271 : const char *buf, size_t n)
272 : {
273 : s32 value;
274 : int ret;
275 :
276 0 : if (kstrtos32(buf, 0, &value) == 0) {
277 : /* Users can't write negative values directly */
278 0 : if (value < 0)
279 : return -EINVAL;
280 : } else {
281 0 : if (sysfs_streq(buf, "auto"))
282 0 : value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
283 0 : else if (sysfs_streq(buf, "any"))
284 0 : value = PM_QOS_LATENCY_ANY;
285 : else
286 : return -EINVAL;
287 : }
288 0 : ret = dev_pm_qos_update_user_latency_tolerance(dev, value);
289 0 : return ret < 0 ? ret : n;
290 : }
291 :
292 : static DEVICE_ATTR_RW(pm_qos_latency_tolerance_us);
293 :
294 0 : static ssize_t pm_qos_no_power_off_show(struct device *dev,
295 : struct device_attribute *attr,
296 : char *buf)
297 : {
298 0 : return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
299 0 : & PM_QOS_FLAG_NO_POWER_OFF));
300 : }
301 :
302 0 : static ssize_t pm_qos_no_power_off_store(struct device *dev,
303 : struct device_attribute *attr,
304 : const char *buf, size_t n)
305 : {
306 : int ret;
307 :
308 0 : if (kstrtoint(buf, 0, &ret))
309 : return -EINVAL;
310 :
311 0 : if (ret != 0 && ret != 1)
312 : return -EINVAL;
313 :
314 0 : ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
315 0 : return ret < 0 ? ret : n;
316 : }
317 :
318 : static DEVICE_ATTR_RW(pm_qos_no_power_off);
319 :
320 : #ifdef CONFIG_PM_SLEEP
321 : static const char _enabled[] = "enabled";
322 : static const char _disabled[] = "disabled";
323 :
324 0 : static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
325 : char *buf)
326 : {
327 0 : return sysfs_emit(buf, "%s\n", device_can_wakeup(dev)
328 0 : ? (device_may_wakeup(dev) ? _enabled : _disabled)
329 : : "");
330 : }
331 :
332 0 : static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
333 : const char *buf, size_t n)
334 : {
335 0 : if (!device_can_wakeup(dev))
336 : return -EINVAL;
337 :
338 0 : if (sysfs_streq(buf, _enabled))
339 0 : device_set_wakeup_enable(dev, 1);
340 0 : else if (sysfs_streq(buf, _disabled))
341 0 : device_set_wakeup_enable(dev, 0);
342 : else
343 : return -EINVAL;
344 0 : return n;
345 : }
346 :
347 : static DEVICE_ATTR_RW(wakeup);
348 :
349 0 : static ssize_t wakeup_count_show(struct device *dev,
350 : struct device_attribute *attr, char *buf)
351 : {
352 : unsigned long count;
353 0 : bool enabled = false;
354 :
355 0 : spin_lock_irq(&dev->power.lock);
356 0 : if (dev->power.wakeup) {
357 0 : count = dev->power.wakeup->wakeup_count;
358 0 : enabled = true;
359 : }
360 0 : spin_unlock_irq(&dev->power.lock);
361 :
362 0 : if (!enabled)
363 0 : return sysfs_emit(buf, "\n");
364 0 : return sysfs_emit(buf, "%lu\n", count);
365 : }
366 :
367 : static DEVICE_ATTR_RO(wakeup_count);
368 :
369 0 : static ssize_t wakeup_active_count_show(struct device *dev,
370 : struct device_attribute *attr,
371 : char *buf)
372 : {
373 : unsigned long count;
374 0 : bool enabled = false;
375 :
376 0 : spin_lock_irq(&dev->power.lock);
377 0 : if (dev->power.wakeup) {
378 0 : count = dev->power.wakeup->active_count;
379 0 : enabled = true;
380 : }
381 0 : spin_unlock_irq(&dev->power.lock);
382 :
383 0 : if (!enabled)
384 0 : return sysfs_emit(buf, "\n");
385 0 : return sysfs_emit(buf, "%lu\n", count);
386 : }
387 :
388 : static DEVICE_ATTR_RO(wakeup_active_count);
389 :
390 0 : static ssize_t wakeup_abort_count_show(struct device *dev,
391 : struct device_attribute *attr,
392 : char *buf)
393 : {
394 : unsigned long count;
395 0 : bool enabled = false;
396 :
397 0 : spin_lock_irq(&dev->power.lock);
398 0 : if (dev->power.wakeup) {
399 0 : count = dev->power.wakeup->wakeup_count;
400 0 : enabled = true;
401 : }
402 0 : spin_unlock_irq(&dev->power.lock);
403 :
404 0 : if (!enabled)
405 0 : return sysfs_emit(buf, "\n");
406 0 : return sysfs_emit(buf, "%lu\n", count);
407 : }
408 :
409 : static DEVICE_ATTR_RO(wakeup_abort_count);
410 :
411 0 : static ssize_t wakeup_expire_count_show(struct device *dev,
412 : struct device_attribute *attr,
413 : char *buf)
414 : {
415 : unsigned long count;
416 0 : bool enabled = false;
417 :
418 0 : spin_lock_irq(&dev->power.lock);
419 0 : if (dev->power.wakeup) {
420 0 : count = dev->power.wakeup->expire_count;
421 0 : enabled = true;
422 : }
423 0 : spin_unlock_irq(&dev->power.lock);
424 :
425 0 : if (!enabled)
426 0 : return sysfs_emit(buf, "\n");
427 0 : return sysfs_emit(buf, "%lu\n", count);
428 : }
429 :
430 : static DEVICE_ATTR_RO(wakeup_expire_count);
431 :
432 0 : static ssize_t wakeup_active_show(struct device *dev,
433 : struct device_attribute *attr, char *buf)
434 : {
435 : unsigned int active;
436 0 : bool enabled = false;
437 :
438 0 : spin_lock_irq(&dev->power.lock);
439 0 : if (dev->power.wakeup) {
440 0 : active = dev->power.wakeup->active;
441 0 : enabled = true;
442 : }
443 0 : spin_unlock_irq(&dev->power.lock);
444 :
445 0 : if (!enabled)
446 0 : return sysfs_emit(buf, "\n");
447 0 : return sysfs_emit(buf, "%u\n", active);
448 : }
449 :
450 : static DEVICE_ATTR_RO(wakeup_active);
451 :
452 0 : static ssize_t wakeup_total_time_ms_show(struct device *dev,
453 : struct device_attribute *attr,
454 : char *buf)
455 : {
456 : s64 msec;
457 0 : bool enabled = false;
458 :
459 0 : spin_lock_irq(&dev->power.lock);
460 0 : if (dev->power.wakeup) {
461 0 : msec = ktime_to_ms(dev->power.wakeup->total_time);
462 0 : enabled = true;
463 : }
464 0 : spin_unlock_irq(&dev->power.lock);
465 :
466 0 : if (!enabled)
467 0 : return sysfs_emit(buf, "\n");
468 0 : return sysfs_emit(buf, "%lld\n", msec);
469 : }
470 :
471 : static DEVICE_ATTR_RO(wakeup_total_time_ms);
472 :
473 0 : static ssize_t wakeup_max_time_ms_show(struct device *dev,
474 : struct device_attribute *attr, char *buf)
475 : {
476 : s64 msec;
477 0 : bool enabled = false;
478 :
479 0 : spin_lock_irq(&dev->power.lock);
480 0 : if (dev->power.wakeup) {
481 0 : msec = ktime_to_ms(dev->power.wakeup->max_time);
482 0 : enabled = true;
483 : }
484 0 : spin_unlock_irq(&dev->power.lock);
485 :
486 0 : if (!enabled)
487 0 : return sysfs_emit(buf, "\n");
488 0 : return sysfs_emit(buf, "%lld\n", msec);
489 : }
490 :
491 : static DEVICE_ATTR_RO(wakeup_max_time_ms);
492 :
493 0 : static ssize_t wakeup_last_time_ms_show(struct device *dev,
494 : struct device_attribute *attr,
495 : char *buf)
496 : {
497 : s64 msec;
498 0 : bool enabled = false;
499 :
500 0 : spin_lock_irq(&dev->power.lock);
501 0 : if (dev->power.wakeup) {
502 0 : msec = ktime_to_ms(dev->power.wakeup->last_time);
503 0 : enabled = true;
504 : }
505 0 : spin_unlock_irq(&dev->power.lock);
506 :
507 0 : if (!enabled)
508 0 : return sysfs_emit(buf, "\n");
509 0 : return sysfs_emit(buf, "%lld\n", msec);
510 : }
511 :
512 : static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
513 : kgid_t kgid)
514 : {
515 0 : if (dev->power.wakeup && dev->power.wakeup->dev)
516 0 : return device_change_owner(dev->power.wakeup->dev, kuid, kgid);
517 : return 0;
518 : }
519 :
520 : static DEVICE_ATTR_RO(wakeup_last_time_ms);
521 :
522 : #ifdef CONFIG_PM_AUTOSLEEP
523 : static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
524 : struct device_attribute *attr,
525 : char *buf)
526 : {
527 : s64 msec;
528 : bool enabled = false;
529 :
530 : spin_lock_irq(&dev->power.lock);
531 : if (dev->power.wakeup) {
532 : msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
533 : enabled = true;
534 : }
535 : spin_unlock_irq(&dev->power.lock);
536 :
537 : if (!enabled)
538 : return sysfs_emit(buf, "\n");
539 : return sysfs_emit(buf, "%lld\n", msec);
540 : }
541 :
542 : static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
543 : #endif /* CONFIG_PM_AUTOSLEEP */
544 : #else /* CONFIG_PM_SLEEP */
545 : static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
546 : kgid_t kgid)
547 : {
548 : return 0;
549 : }
550 : #endif
551 :
552 : #ifdef CONFIG_PM_ADVANCED_DEBUG
553 : static ssize_t runtime_usage_show(struct device *dev,
554 : struct device_attribute *attr, char *buf)
555 : {
556 : return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
557 : }
558 : static DEVICE_ATTR_RO(runtime_usage);
559 :
560 : static ssize_t runtime_active_kids_show(struct device *dev,
561 : struct device_attribute *attr,
562 : char *buf)
563 : {
564 : return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
565 : 0 : atomic_read(&dev->power.child_count));
566 : }
567 : static DEVICE_ATTR_RO(runtime_active_kids);
568 :
569 : static ssize_t runtime_enabled_show(struct device *dev,
570 : struct device_attribute *attr, char *buf)
571 : {
572 : const char *output;
573 :
574 : if (dev->power.disable_depth && !dev->power.runtime_auto)
575 : output = "disabled & forbidden";
576 : else if (dev->power.disable_depth)
577 : output = "disabled";
578 : else if (!dev->power.runtime_auto)
579 : output = "forbidden";
580 : else
581 : output = "enabled";
582 :
583 : return sysfs_emit(buf, "%s\n", output);
584 : }
585 : static DEVICE_ATTR_RO(runtime_enabled);
586 :
587 : #ifdef CONFIG_PM_SLEEP
588 : static ssize_t async_show(struct device *dev, struct device_attribute *attr,
589 : char *buf)
590 : {
591 : return sysfs_emit(buf, "%s\n",
592 : device_async_suspend_enabled(dev) ?
593 : _enabled : _disabled);
594 : }
595 :
596 : static ssize_t async_store(struct device *dev, struct device_attribute *attr,
597 : const char *buf, size_t n)
598 : {
599 : if (sysfs_streq(buf, _enabled))
600 : device_enable_async_suspend(dev);
601 : else if (sysfs_streq(buf, _disabled))
602 : device_disable_async_suspend(dev);
603 : else
604 : return -EINVAL;
605 : return n;
606 : }
607 :
608 : static DEVICE_ATTR_RW(async);
609 :
610 : #endif /* CONFIG_PM_SLEEP */
611 : #endif /* CONFIG_PM_ADVANCED_DEBUG */
612 :
613 : static struct attribute *power_attrs[] = {
614 : #ifdef CONFIG_PM_ADVANCED_DEBUG
615 : #ifdef CONFIG_PM_SLEEP
616 : &dev_attr_async.attr,
617 : #endif
618 : &dev_attr_runtime_status.attr,
619 : &dev_attr_runtime_usage.attr,
620 : &dev_attr_runtime_active_kids.attr,
621 : &dev_attr_runtime_enabled.attr,
622 : #endif /* CONFIG_PM_ADVANCED_DEBUG */
623 : NULL,
624 : };
625 : static const struct attribute_group pm_attr_group = {
626 : .name = power_group_name,
627 : .attrs = power_attrs,
628 : };
629 :
630 : static struct attribute *wakeup_attrs[] = {
631 : #ifdef CONFIG_PM_SLEEP
632 : &dev_attr_wakeup.attr,
633 : &dev_attr_wakeup_count.attr,
634 : &dev_attr_wakeup_active_count.attr,
635 : &dev_attr_wakeup_abort_count.attr,
636 : &dev_attr_wakeup_expire_count.attr,
637 : &dev_attr_wakeup_active.attr,
638 : &dev_attr_wakeup_total_time_ms.attr,
639 : &dev_attr_wakeup_max_time_ms.attr,
640 : &dev_attr_wakeup_last_time_ms.attr,
641 : #ifdef CONFIG_PM_AUTOSLEEP
642 : &dev_attr_wakeup_prevent_sleep_time_ms.attr,
643 : #endif
644 : #endif
645 : NULL,
646 : };
647 : static const struct attribute_group pm_wakeup_attr_group = {
648 : .name = power_group_name,
649 : .attrs = wakeup_attrs,
650 : };
651 :
652 : static struct attribute *runtime_attrs[] = {
653 : #ifndef CONFIG_PM_ADVANCED_DEBUG
654 : &dev_attr_runtime_status.attr,
655 : #endif
656 : &dev_attr_control.attr,
657 : &dev_attr_runtime_suspended_time.attr,
658 : &dev_attr_runtime_active_time.attr,
659 : &dev_attr_autosuspend_delay_ms.attr,
660 : NULL,
661 : };
662 : static const struct attribute_group pm_runtime_attr_group = {
663 : .name = power_group_name,
664 : .attrs = runtime_attrs,
665 : };
666 :
667 : static struct attribute *pm_qos_resume_latency_attrs[] = {
668 : &dev_attr_pm_qos_resume_latency_us.attr,
669 : NULL,
670 : };
671 : static const struct attribute_group pm_qos_resume_latency_attr_group = {
672 : .name = power_group_name,
673 : .attrs = pm_qos_resume_latency_attrs,
674 : };
675 :
676 : static struct attribute *pm_qos_latency_tolerance_attrs[] = {
677 : &dev_attr_pm_qos_latency_tolerance_us.attr,
678 : NULL,
679 : };
680 : static const struct attribute_group pm_qos_latency_tolerance_attr_group = {
681 : .name = power_group_name,
682 : .attrs = pm_qos_latency_tolerance_attrs,
683 : };
684 :
685 : static struct attribute *pm_qos_flags_attrs[] = {
686 : &dev_attr_pm_qos_no_power_off.attr,
687 : NULL,
688 : };
689 : static const struct attribute_group pm_qos_flags_attr_group = {
690 : .name = power_group_name,
691 : .attrs = pm_qos_flags_attrs,
692 : };
693 :
694 540 : int dpm_sysfs_add(struct device *dev)
695 : {
696 : int rc;
697 :
698 : /* No need to create PM sysfs if explicitly disabled. */
699 540 : if (device_pm_not_required(dev))
700 : return 0;
701 :
702 540 : rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
703 540 : if (rc)
704 : return rc;
705 :
706 540 : if (!pm_runtime_has_no_callbacks(dev)) {
707 540 : rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
708 540 : if (rc)
709 : goto err_out;
710 : }
711 540 : if (device_can_wakeup(dev)) {
712 0 : rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
713 0 : if (rc)
714 : goto err_runtime;
715 : }
716 540 : if (dev->power.set_latency_tolerance) {
717 0 : rc = sysfs_merge_group(&dev->kobj,
718 : &pm_qos_latency_tolerance_attr_group);
719 0 : if (rc)
720 : goto err_wakeup;
721 : }
722 540 : rc = pm_wakeup_source_sysfs_add(dev);
723 540 : if (rc)
724 : goto err_latency;
725 : return 0;
726 :
727 : err_latency:
728 0 : sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
729 : err_wakeup:
730 0 : sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
731 : err_runtime:
732 0 : sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
733 : err_out:
734 0 : sysfs_remove_group(&dev->kobj, &pm_attr_group);
735 0 : return rc;
736 : }
737 :
738 0 : int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
739 : {
740 : int rc;
741 :
742 0 : if (device_pm_not_required(dev))
743 : return 0;
744 :
745 0 : rc = sysfs_group_change_owner(&dev->kobj, &pm_attr_group, kuid, kgid);
746 0 : if (rc)
747 : return rc;
748 :
749 0 : if (!pm_runtime_has_no_callbacks(dev)) {
750 0 : rc = sysfs_group_change_owner(
751 : &dev->kobj, &pm_runtime_attr_group, kuid, kgid);
752 0 : if (rc)
753 : return rc;
754 : }
755 :
756 0 : if (device_can_wakeup(dev)) {
757 0 : rc = sysfs_group_change_owner(&dev->kobj, &pm_wakeup_attr_group,
758 : kuid, kgid);
759 0 : if (rc)
760 : return rc;
761 :
762 0 : rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid);
763 0 : if (rc)
764 : return rc;
765 : }
766 :
767 0 : if (dev->power.set_latency_tolerance) {
768 0 : rc = sysfs_group_change_owner(
769 : &dev->kobj, &pm_qos_latency_tolerance_attr_group, kuid,
770 : kgid);
771 0 : if (rc)
772 : return rc;
773 : }
774 : return 0;
775 : }
776 :
777 0 : int wakeup_sysfs_add(struct device *dev)
778 : {
779 0 : int ret = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
780 :
781 0 : if (!ret)
782 0 : kobject_uevent(&dev->kobj, KOBJ_CHANGE);
783 :
784 0 : return ret;
785 : }
786 :
787 0 : void wakeup_sysfs_remove(struct device *dev)
788 : {
789 0 : sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
790 0 : kobject_uevent(&dev->kobj, KOBJ_CHANGE);
791 0 : }
792 :
793 1 : int pm_qos_sysfs_add_resume_latency(struct device *dev)
794 : {
795 1 : return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
796 : }
797 :
798 5 : void pm_qos_sysfs_remove_resume_latency(struct device *dev)
799 : {
800 5 : sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
801 5 : }
802 :
803 0 : int pm_qos_sysfs_add_flags(struct device *dev)
804 : {
805 0 : return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
806 : }
807 :
808 5 : void pm_qos_sysfs_remove_flags(struct device *dev)
809 : {
810 5 : sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
811 5 : }
812 :
813 0 : int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
814 : {
815 0 : return sysfs_merge_group(&dev->kobj,
816 : &pm_qos_latency_tolerance_attr_group);
817 : }
818 :
819 0 : void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
820 : {
821 0 : sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
822 0 : }
823 :
824 0 : void rpm_sysfs_remove(struct device *dev)
825 : {
826 5 : sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
827 0 : }
828 :
829 5 : void dpm_sysfs_remove(struct device *dev)
830 : {
831 5 : if (device_pm_not_required(dev))
832 : return;
833 5 : sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
834 5 : dev_pm_qos_constraints_destroy(dev);
835 5 : rpm_sysfs_remove(dev);
836 5 : sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
837 5 : sysfs_remove_group(&dev->kobj, &pm_attr_group);
838 : }
|
