1
2
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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95static const char enabled[] = "enabled";
96static const char disabled[] = "disabled";
97
98const char power_group_name[] = "power";
99EXPORT_SYMBOL_GPL(power_group_name);
100
101#ifdef CONFIG_PM_RUNTIME
102static const char ctrl_auto[] = "auto";
103static const char ctrl_on[] = "on";
104
105static 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
112static 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
132static DEVICE_ATTR(control, 0644, control_show, control_store);
133
134static 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
145static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
146
147static 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
159static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
160
161static 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
191static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
192
193static 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
201static 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
218static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
219 autosuspend_delay_ms_store);
220
221static 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
227static 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
244static DEVICE_ATTR(pm_qos_resume_latency_us, 0644,
245 pm_qos_latency_show, pm_qos_latency_store);
246
247static 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
255static 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
271static DEVICE_ATTR(pm_qos_no_power_off, 0644,
272 pm_qos_no_power_off_show, pm_qos_no_power_off_store);
273
274static 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
282static 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
298static DEVICE_ATTR(pm_qos_remote_wakeup, 0644,
299 pm_qos_remote_wakeup_show, pm_qos_remote_wakeup_store);
300#endif
301
302#ifdef CONFIG_PM_SLEEP
303static ssize_t
304wake_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
311static ssize_t
312wake_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
335static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
336
337static 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
352static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
353
354static 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
369static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
370
371static 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
387static DEVICE_ATTR(wakeup_abort_count, 0444, wakeup_abort_count_show, NULL);
388
389static 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
405static DEVICE_ATTR(wakeup_expire_count, 0444, wakeup_expire_count_show, NULL);
406
407static 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
422static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
423
424static 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
439static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
440
441static 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
456static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
457
458static 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
473static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
474
475#ifdef CONFIG_PM_AUTOSLEEP
476static 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
492static DEVICE_ATTR(wakeup_prevent_sleep_time_ms, 0444,
493 wakeup_prevent_sleep_time_show, NULL);
494#endif
495#endif
496
497#ifdef CONFIG_PM_ADVANCED_DEBUG
498#ifdef CONFIG_PM_RUNTIME
499
500static 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
506static 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
513static 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
525static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
526static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
527static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
528
529#endif
530
531#ifdef CONFIG_PM_SLEEP
532
533static 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
540static 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
558static DEVICE_ATTR(async, 0644, async_show, async_store);
559
560#endif
561#endif
562
563static 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
575 NULL,
576};
577static struct attribute_group pm_attr_group = {
578 .name = power_group_name,
579 .attrs = power_attrs,
580};
581
582static 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};
599static struct attribute_group pm_wakeup_attr_group = {
600 .name = power_group_name,
601 .attrs = wakeup_attrs,
602};
603
604static 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
614 NULL,
615};
616static struct attribute_group pm_runtime_attr_group = {
617 .name = power_group_name,
618 .attrs = runtime_attrs,
619};
620
621static struct attribute *pm_qos_latency_attrs[] = {
622#ifdef CONFIG_PM_RUNTIME
623 &dev_attr_pm_qos_resume_latency_us.attr,
624#endif
625 NULL,
626};
627static struct attribute_group pm_qos_latency_attr_group = {
628 .name = power_group_name,
629 .attrs = pm_qos_latency_attrs,
630};
631
632static 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
637 NULL,
638};
639static struct attribute_group pm_qos_flags_attr_group = {
640 .name = power_group_name,
641 .attrs = pm_qos_flags_attrs,
642};
643
644int 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
674int wakeup_sysfs_add(struct device *dev)
675{
676 return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
677}
678
679void wakeup_sysfs_remove(struct device *dev)
680{
681 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
682}
683
684int pm_qos_sysfs_add_latency(struct device *dev)
685{
686 return sysfs_merge_group(&dev->kobj, &pm_qos_latency_attr_group);
687}
688
689void pm_qos_sysfs_remove_latency(struct device *dev)
690{
691 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_attr_group);
692}
693
694int pm_qos_sysfs_add_flags(struct device *dev)
695{
696 return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
697}
698
699void pm_qos_sysfs_remove_flags(struct device *dev)
700{
701 sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
702}
703
704void rpm_sysfs_remove(struct device *dev)
705{
706 sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
707}
708
709void 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