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 | static ssize_t control_show(struct device *dev, struct device_attribute *attr, |
102 | char *buf) |
103 | { |
104 | return sysfs_emit(buf, fmt: "%s\n" , |
105 | dev->power.runtime_auto ? ctrl_auto : ctrl_on); |
106 | } |
107 | |
108 | static ssize_t control_store(struct device * dev, struct device_attribute *attr, |
109 | const char * buf, size_t n) |
110 | { |
111 | device_lock(dev); |
112 | if (sysfs_streq(s1: buf, s2: ctrl_auto)) |
113 | pm_runtime_allow(dev); |
114 | else if (sysfs_streq(s1: buf, s2: ctrl_on)) |
115 | pm_runtime_forbid(dev); |
116 | else |
117 | n = -EINVAL; |
118 | device_unlock(dev); |
119 | return n; |
120 | } |
121 | |
122 | static DEVICE_ATTR_RW(control); |
123 | |
124 | static ssize_t runtime_active_time_show(struct device *dev, |
125 | struct device_attribute *attr, |
126 | char *buf) |
127 | { |
128 | u64 tmp = pm_runtime_active_time(dev); |
129 | |
130 | do_div(tmp, NSEC_PER_MSEC); |
131 | |
132 | return sysfs_emit(buf, fmt: "%llu\n" , tmp); |
133 | } |
134 | |
135 | static DEVICE_ATTR_RO(runtime_active_time); |
136 | |
137 | static ssize_t runtime_suspended_time_show(struct device *dev, |
138 | struct device_attribute *attr, |
139 | char *buf) |
140 | { |
141 | u64 tmp = pm_runtime_suspended_time(dev); |
142 | |
143 | do_div(tmp, NSEC_PER_MSEC); |
144 | |
145 | return sysfs_emit(buf, fmt: "%llu\n" , tmp); |
146 | } |
147 | |
148 | static DEVICE_ATTR_RO(runtime_suspended_time); |
149 | |
150 | static ssize_t runtime_status_show(struct device *dev, |
151 | struct device_attribute *attr, char *buf) |
152 | { |
153 | const char *output; |
154 | |
155 | if (dev->power.runtime_error) { |
156 | output = "error" ; |
157 | } else if (dev->power.disable_depth) { |
158 | output = "unsupported" ; |
159 | } else { |
160 | switch (dev->power.runtime_status) { |
161 | case RPM_SUSPENDED: |
162 | output = "suspended" ; |
163 | break; |
164 | case RPM_SUSPENDING: |
165 | output = "suspending" ; |
166 | break; |
167 | case RPM_RESUMING: |
168 | output = "resuming" ; |
169 | break; |
170 | case RPM_ACTIVE: |
171 | output = "active" ; |
172 | break; |
173 | default: |
174 | return -EIO; |
175 | } |
176 | } |
177 | return sysfs_emit(buf, fmt: "%s\n" , output); |
178 | } |
179 | |
180 | static DEVICE_ATTR_RO(runtime_status); |
181 | |
182 | static ssize_t autosuspend_delay_ms_show(struct device *dev, |
183 | struct device_attribute *attr, |
184 | char *buf) |
185 | { |
186 | if (!dev->power.use_autosuspend) |
187 | return -EIO; |
188 | |
189 | return sysfs_emit(buf, fmt: "%d\n" , dev->power.autosuspend_delay); |
190 | } |
191 | |
192 | 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 | if (!dev->power.use_autosuspend) |
198 | return -EIO; |
199 | |
200 | if (kstrtol(s: buf, base: 10, res: &delay) != 0 || delay != (int) delay) |
201 | return -EINVAL; |
202 | |
203 | device_lock(dev); |
204 | pm_runtime_set_autosuspend_delay(dev, delay); |
205 | device_unlock(dev); |
206 | return n; |
207 | } |
208 | |
209 | static DEVICE_ATTR_RW(autosuspend_delay_ms); |
210 | |
211 | static ssize_t pm_qos_resume_latency_us_show(struct device *dev, |
212 | struct device_attribute *attr, |
213 | char *buf) |
214 | { |
215 | s32 value = dev_pm_qos_requested_resume_latency(dev); |
216 | |
217 | if (value == 0) |
218 | return sysfs_emit(buf, fmt: "n/a\n" ); |
219 | if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT) |
220 | value = 0; |
221 | |
222 | return sysfs_emit(buf, fmt: "%d\n" , value); |
223 | } |
224 | |
225 | 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 | if (!kstrtos32(s: buf, base: 0, res: &value)) { |
233 | /* |
234 | * Prevent users from writing negative or "no constraint" values |
235 | * directly. |
236 | */ |
237 | if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT) |
238 | return -EINVAL; |
239 | |
240 | if (value == 0) |
241 | value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT; |
242 | } else if (sysfs_streq(s1: buf, s2: "n/a" )) { |
243 | value = 0; |
244 | } else { |
245 | return -EINVAL; |
246 | } |
247 | |
248 | ret = dev_pm_qos_update_request(req: dev->power.qos->resume_latency_req, |
249 | new_value: value); |
250 | return ret < 0 ? ret : n; |
251 | } |
252 | |
253 | static DEVICE_ATTR_RW(pm_qos_resume_latency_us); |
254 | |
255 | static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev, |
256 | struct device_attribute *attr, |
257 | char *buf) |
258 | { |
259 | s32 value = dev_pm_qos_get_user_latency_tolerance(dev); |
260 | |
261 | if (value < 0) |
262 | return sysfs_emit(buf, fmt: "%s\n" , "auto" ); |
263 | if (value == PM_QOS_LATENCY_ANY) |
264 | return sysfs_emit(buf, fmt: "%s\n" , "any" ); |
265 | |
266 | return sysfs_emit(buf, fmt: "%d\n" , value); |
267 | } |
268 | |
269 | 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 | if (kstrtos32(s: buf, base: 0, res: &value) == 0) { |
277 | /* Users can't write negative values directly */ |
278 | if (value < 0) |
279 | return -EINVAL; |
280 | } else { |
281 | if (sysfs_streq(s1: buf, s2: "auto" )) |
282 | value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT; |
283 | else if (sysfs_streq(s1: buf, s2: "any" )) |
284 | value = PM_QOS_LATENCY_ANY; |
285 | else |
286 | return -EINVAL; |
287 | } |
288 | ret = dev_pm_qos_update_user_latency_tolerance(dev, val: value); |
289 | return ret < 0 ? ret : n; |
290 | } |
291 | |
292 | static DEVICE_ATTR_RW(pm_qos_latency_tolerance_us); |
293 | |
294 | static ssize_t pm_qos_no_power_off_show(struct device *dev, |
295 | struct device_attribute *attr, |
296 | char *buf) |
297 | { |
298 | return sysfs_emit(buf, fmt: "%d\n" , !!(dev_pm_qos_requested_flags(dev) |
299 | & PM_QOS_FLAG_NO_POWER_OFF)); |
300 | } |
301 | |
302 | 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 | if (kstrtoint(s: buf, base: 0, res: &ret)) |
309 | return -EINVAL; |
310 | |
311 | if (ret != 0 && ret != 1) |
312 | return -EINVAL; |
313 | |
314 | ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, set: ret); |
315 | 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 | static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr, |
325 | char *buf) |
326 | { |
327 | return sysfs_emit(buf, fmt: "%s\n" , device_can_wakeup(dev) |
328 | ? (device_may_wakeup(dev) ? _enabled : _disabled) |
329 | : "" ); |
330 | } |
331 | |
332 | static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr, |
333 | const char *buf, size_t n) |
334 | { |
335 | if (!device_can_wakeup(dev)) |
336 | return -EINVAL; |
337 | |
338 | if (sysfs_streq(s1: buf, s2: _enabled)) |
339 | device_set_wakeup_enable(dev, enable: 1); |
340 | else if (sysfs_streq(s1: buf, s2: _disabled)) |
341 | device_set_wakeup_enable(dev, enable: 0); |
342 | else |
343 | return -EINVAL; |
344 | return n; |
345 | } |
346 | |
347 | static DEVICE_ATTR_RW(wakeup); |
348 | |
349 | static ssize_t wakeup_count_show(struct device *dev, |
350 | struct device_attribute *attr, char *buf) |
351 | { |
352 | unsigned long count; |
353 | bool enabled = false; |
354 | |
355 | spin_lock_irq(lock: &dev->power.lock); |
356 | if (dev->power.wakeup) { |
357 | count = dev->power.wakeup->wakeup_count; |
358 | enabled = true; |
359 | } |
360 | spin_unlock_irq(lock: &dev->power.lock); |
361 | |
362 | if (!enabled) |
363 | return sysfs_emit(buf, fmt: "\n" ); |
364 | return sysfs_emit(buf, fmt: "%lu\n" , count); |
365 | } |
366 | |
367 | static DEVICE_ATTR_RO(wakeup_count); |
368 | |
369 | static ssize_t wakeup_active_count_show(struct device *dev, |
370 | struct device_attribute *attr, |
371 | char *buf) |
372 | { |
373 | unsigned long count; |
374 | bool enabled = false; |
375 | |
376 | spin_lock_irq(lock: &dev->power.lock); |
377 | if (dev->power.wakeup) { |
378 | count = dev->power.wakeup->active_count; |
379 | enabled = true; |
380 | } |
381 | spin_unlock_irq(lock: &dev->power.lock); |
382 | |
383 | if (!enabled) |
384 | return sysfs_emit(buf, fmt: "\n" ); |
385 | return sysfs_emit(buf, fmt: "%lu\n" , count); |
386 | } |
387 | |
388 | static DEVICE_ATTR_RO(wakeup_active_count); |
389 | |
390 | static ssize_t wakeup_abort_count_show(struct device *dev, |
391 | struct device_attribute *attr, |
392 | char *buf) |
393 | { |
394 | unsigned long count; |
395 | bool enabled = false; |
396 | |
397 | spin_lock_irq(lock: &dev->power.lock); |
398 | if (dev->power.wakeup) { |
399 | count = dev->power.wakeup->wakeup_count; |
400 | enabled = true; |
401 | } |
402 | spin_unlock_irq(lock: &dev->power.lock); |
403 | |
404 | if (!enabled) |
405 | return sysfs_emit(buf, fmt: "\n" ); |
406 | return sysfs_emit(buf, fmt: "%lu\n" , count); |
407 | } |
408 | |
409 | static DEVICE_ATTR_RO(wakeup_abort_count); |
410 | |
411 | static ssize_t wakeup_expire_count_show(struct device *dev, |
412 | struct device_attribute *attr, |
413 | char *buf) |
414 | { |
415 | unsigned long count; |
416 | bool enabled = false; |
417 | |
418 | spin_lock_irq(lock: &dev->power.lock); |
419 | if (dev->power.wakeup) { |
420 | count = dev->power.wakeup->expire_count; |
421 | enabled = true; |
422 | } |
423 | spin_unlock_irq(lock: &dev->power.lock); |
424 | |
425 | if (!enabled) |
426 | return sysfs_emit(buf, fmt: "\n" ); |
427 | return sysfs_emit(buf, fmt: "%lu\n" , count); |
428 | } |
429 | |
430 | static DEVICE_ATTR_RO(wakeup_expire_count); |
431 | |
432 | static ssize_t wakeup_active_show(struct device *dev, |
433 | struct device_attribute *attr, char *buf) |
434 | { |
435 | unsigned int active; |
436 | bool enabled = false; |
437 | |
438 | spin_lock_irq(lock: &dev->power.lock); |
439 | if (dev->power.wakeup) { |
440 | active = dev->power.wakeup->active; |
441 | enabled = true; |
442 | } |
443 | spin_unlock_irq(lock: &dev->power.lock); |
444 | |
445 | if (!enabled) |
446 | return sysfs_emit(buf, fmt: "\n" ); |
447 | return sysfs_emit(buf, fmt: "%u\n" , active); |
448 | } |
449 | |
450 | static DEVICE_ATTR_RO(wakeup_active); |
451 | |
452 | static ssize_t wakeup_total_time_ms_show(struct device *dev, |
453 | struct device_attribute *attr, |
454 | char *buf) |
455 | { |
456 | s64 msec; |
457 | bool enabled = false; |
458 | |
459 | spin_lock_irq(lock: &dev->power.lock); |
460 | if (dev->power.wakeup) { |
461 | msec = ktime_to_ms(kt: dev->power.wakeup->total_time); |
462 | enabled = true; |
463 | } |
464 | spin_unlock_irq(lock: &dev->power.lock); |
465 | |
466 | if (!enabled) |
467 | return sysfs_emit(buf, fmt: "\n" ); |
468 | return sysfs_emit(buf, fmt: "%lld\n" , msec); |
469 | } |
470 | |
471 | static DEVICE_ATTR_RO(wakeup_total_time_ms); |
472 | |
473 | static ssize_t wakeup_max_time_ms_show(struct device *dev, |
474 | struct device_attribute *attr, char *buf) |
475 | { |
476 | s64 msec; |
477 | bool enabled = false; |
478 | |
479 | spin_lock_irq(lock: &dev->power.lock); |
480 | if (dev->power.wakeup) { |
481 | msec = ktime_to_ms(kt: dev->power.wakeup->max_time); |
482 | enabled = true; |
483 | } |
484 | spin_unlock_irq(lock: &dev->power.lock); |
485 | |
486 | if (!enabled) |
487 | return sysfs_emit(buf, fmt: "\n" ); |
488 | return sysfs_emit(buf, fmt: "%lld\n" , msec); |
489 | } |
490 | |
491 | static DEVICE_ATTR_RO(wakeup_max_time_ms); |
492 | |
493 | static ssize_t wakeup_last_time_ms_show(struct device *dev, |
494 | struct device_attribute *attr, |
495 | char *buf) |
496 | { |
497 | s64 msec; |
498 | bool enabled = false; |
499 | |
500 | spin_lock_irq(lock: &dev->power.lock); |
501 | if (dev->power.wakeup) { |
502 | msec = ktime_to_ms(kt: dev->power.wakeup->last_time); |
503 | enabled = true; |
504 | } |
505 | spin_unlock_irq(lock: &dev->power.lock); |
506 | |
507 | if (!enabled) |
508 | return sysfs_emit(buf, fmt: "\n" ); |
509 | return sysfs_emit(buf, fmt: "%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 | if (dev->power.wakeup && dev->power.wakeup->dev) |
516 | return device_change_owner(dev: 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(lock: &dev->power.lock); |
531 | if (dev->power.wakeup) { |
532 | msec = ktime_to_ms(kt: dev->power.wakeup->prevent_sleep_time); |
533 | enabled = true; |
534 | } |
535 | spin_unlock_irq(lock: &dev->power.lock); |
536 | |
537 | if (!enabled) |
538 | return sysfs_emit(buf, fmt: "\n" ); |
539 | return sysfs_emit(buf, fmt: "%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, fmt: "%d\n" , atomic_read(v: &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, fmt: "%d\n" , dev->power.ignore_children ? |
565 | 0 : atomic_read(v: &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, fmt: "%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, fmt: "%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(s1: buf, s2: _enabled)) |
600 | device_enable_async_suspend(dev); |
601 | else if (sysfs_streq(s1: buf, s2: _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 | int dpm_sysfs_add(struct device *dev) |
695 | { |
696 | int rc; |
697 | |
698 | /* No need to create PM sysfs if explicitly disabled. */ |
699 | if (device_pm_not_required(dev)) |
700 | return 0; |
701 | |
702 | rc = sysfs_create_group(kobj: &dev->kobj, grp: &pm_attr_group); |
703 | if (rc) |
704 | return rc; |
705 | |
706 | if (!pm_runtime_has_no_callbacks(dev)) { |
707 | rc = sysfs_merge_group(kobj: &dev->kobj, grp: &pm_runtime_attr_group); |
708 | if (rc) |
709 | goto err_out; |
710 | } |
711 | if (device_can_wakeup(dev)) { |
712 | rc = sysfs_merge_group(kobj: &dev->kobj, grp: &pm_wakeup_attr_group); |
713 | if (rc) |
714 | goto err_runtime; |
715 | } |
716 | if (dev->power.set_latency_tolerance) { |
717 | rc = sysfs_merge_group(kobj: &dev->kobj, |
718 | grp: &pm_qos_latency_tolerance_attr_group); |
719 | if (rc) |
720 | goto err_wakeup; |
721 | } |
722 | rc = pm_wakeup_source_sysfs_add(parent: dev); |
723 | if (rc) |
724 | goto err_latency; |
725 | return 0; |
726 | |
727 | err_latency: |
728 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_qos_latency_tolerance_attr_group); |
729 | err_wakeup: |
730 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_wakeup_attr_group); |
731 | err_runtime: |
732 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_runtime_attr_group); |
733 | err_out: |
734 | sysfs_remove_group(kobj: &dev->kobj, grp: &pm_attr_group); |
735 | return rc; |
736 | } |
737 | |
738 | int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) |
739 | { |
740 | int rc; |
741 | |
742 | if (device_pm_not_required(dev)) |
743 | return 0; |
744 | |
745 | rc = sysfs_group_change_owner(kobj: &dev->kobj, groups: &pm_attr_group, kuid, kgid); |
746 | if (rc) |
747 | return rc; |
748 | |
749 | if (!pm_runtime_has_no_callbacks(dev)) { |
750 | rc = sysfs_group_change_owner( |
751 | kobj: &dev->kobj, groups: &pm_runtime_attr_group, kuid, kgid); |
752 | if (rc) |
753 | return rc; |
754 | } |
755 | |
756 | if (device_can_wakeup(dev)) { |
757 | rc = sysfs_group_change_owner(kobj: &dev->kobj, groups: &pm_wakeup_attr_group, |
758 | kuid, kgid); |
759 | if (rc) |
760 | return rc; |
761 | |
762 | rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid); |
763 | if (rc) |
764 | return rc; |
765 | } |
766 | |
767 | if (dev->power.set_latency_tolerance) { |
768 | rc = sysfs_group_change_owner( |
769 | kobj: &dev->kobj, groups: &pm_qos_latency_tolerance_attr_group, kuid, |
770 | kgid); |
771 | if (rc) |
772 | return rc; |
773 | } |
774 | return 0; |
775 | } |
776 | |
777 | int wakeup_sysfs_add(struct device *dev) |
778 | { |
779 | int ret = sysfs_merge_group(kobj: &dev->kobj, grp: &pm_wakeup_attr_group); |
780 | |
781 | if (!ret) |
782 | kobject_uevent(kobj: &dev->kobj, action: KOBJ_CHANGE); |
783 | |
784 | return ret; |
785 | } |
786 | |
787 | void wakeup_sysfs_remove(struct device *dev) |
788 | { |
789 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_wakeup_attr_group); |
790 | kobject_uevent(kobj: &dev->kobj, action: KOBJ_CHANGE); |
791 | } |
792 | |
793 | int pm_qos_sysfs_add_resume_latency(struct device *dev) |
794 | { |
795 | return sysfs_merge_group(kobj: &dev->kobj, grp: &pm_qos_resume_latency_attr_group); |
796 | } |
797 | |
798 | void pm_qos_sysfs_remove_resume_latency(struct device *dev) |
799 | { |
800 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_qos_resume_latency_attr_group); |
801 | } |
802 | |
803 | int pm_qos_sysfs_add_flags(struct device *dev) |
804 | { |
805 | return sysfs_merge_group(kobj: &dev->kobj, grp: &pm_qos_flags_attr_group); |
806 | } |
807 | |
808 | void pm_qos_sysfs_remove_flags(struct device *dev) |
809 | { |
810 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_qos_flags_attr_group); |
811 | } |
812 | |
813 | int pm_qos_sysfs_add_latency_tolerance(struct device *dev) |
814 | { |
815 | return sysfs_merge_group(kobj: &dev->kobj, |
816 | grp: &pm_qos_latency_tolerance_attr_group); |
817 | } |
818 | |
819 | void pm_qos_sysfs_remove_latency_tolerance(struct device *dev) |
820 | { |
821 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_qos_latency_tolerance_attr_group); |
822 | } |
823 | |
824 | void rpm_sysfs_remove(struct device *dev) |
825 | { |
826 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_runtime_attr_group); |
827 | } |
828 | |
829 | void dpm_sysfs_remove(struct device *dev) |
830 | { |
831 | if (device_pm_not_required(dev)) |
832 | return; |
833 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_qos_latency_tolerance_attr_group); |
834 | dev_pm_qos_constraints_destroy(dev); |
835 | rpm_sysfs_remove(dev); |
836 | sysfs_unmerge_group(kobj: &dev->kobj, grp: &pm_wakeup_attr_group); |
837 | sysfs_remove_group(kobj: &dev->kobj, grp: &pm_attr_group); |
838 | } |
839 | |