PM / Runtime: Replace dev_dbg() with trace_rpm_*()
[linux-2.6.git] / drivers / base / power / sysfs.c
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/pm_runtime.h>
8 #include <linux/atomic.h>
9 #include <linux/jiffies.h>
10 #include "power.h"
11
12 /*
13  *      control - Report/change current runtime PM setting of the device
14  *
15  *      Runtime power management of a device can be blocked with the help of
16  *      this attribute.  All devices have one of the following two values for
17  *      the power/control file:
18  *
19  *       + "auto\n" to allow the device to be power managed at run time;
20  *       + "on\n" to prevent the device from being power managed at run time;
21  *
22  *      The default for all devices is "auto", which means that devices may be
23  *      subject to automatic power management, depending on their drivers.
24  *      Changing this attribute to "on" prevents the driver from power managing
25  *      the device at run time.  Doing that while the device is suspended causes
26  *      it to be woken up.
27  *
28  *      wakeup - Report/change current wakeup option for device
29  *
30  *      Some devices support "wakeup" events, which are hardware signals
31  *      used to activate devices from suspended or low power states.  Such
32  *      devices have one of three values for the sysfs power/wakeup file:
33  *
34  *       + "enabled\n" to issue the events;
35  *       + "disabled\n" not to do so; or
36  *       + "\n" for temporary or permanent inability to issue wakeup.
37  *
38  *      (For example, unconfigured USB devices can't issue wakeups.)
39  *
40  *      Familiar examples of devices that can issue wakeup events include
41  *      keyboards and mice (both PS2 and USB styles), power buttons, modems,
42  *      "Wake-On-LAN" Ethernet links, GPIO lines, and more.  Some events
43  *      will wake the entire system from a suspend state; others may just
44  *      wake up the device (if the system as a whole is already active).
45  *      Some wakeup events use normal IRQ lines; other use special out
46  *      of band signaling.
47  *
48  *      It is the responsibility of device drivers to enable (or disable)
49  *      wakeup signaling as part of changing device power states, respecting
50  *      the policy choices provided through the driver model.
51  *
52  *      Devices may not be able to generate wakeup events from all power
53  *      states.  Also, the events may be ignored in some configurations;
54  *      for example, they might need help from other devices that aren't
55  *      active, or which may have wakeup disabled.  Some drivers rely on
56  *      wakeup events internally (unless they are disabled), keeping
57  *      their hardware in low power modes whenever they're unused.  This
58  *      saves runtime power, without requiring system-wide sleep states.
59  *
60  *      async - Report/change current async suspend setting for the device
61  *
62  *      Asynchronous suspend and resume of the device during system-wide power
63  *      state transitions can be enabled by writing "enabled" to this file.
64  *      Analogously, if "disabled" is written to this file, the device will be
65  *      suspended and resumed synchronously.
66  *
67  *      All devices have one of the following two values for power/async:
68  *
69  *       + "enabled\n" to permit the asynchronous suspend/resume of the device;
70  *       + "disabled\n" to forbid it;
71  *
72  *      NOTE: It generally is unsafe to permit the asynchronous suspend/resume
73  *      of a device unless it is certain that all of the PM dependencies of the
74  *      device are known to the PM core.  However, for some devices this
75  *      attribute is set to "enabled" by bus type code or device drivers and in
76  *      that cases it should be safe to leave the default value.
77  *
78  *      autosuspend_delay_ms - Report/change a device's autosuspend_delay value
79  *
80  *      Some drivers don't want to carry out a runtime suspend as soon as a
81  *      device becomes idle; they want it always to remain idle for some period
82  *      of time before suspending it.  This period is the autosuspend_delay
83  *      value (expressed in milliseconds) and it can be controlled by the user.
84  *      If the value is negative then the device will never be runtime
85  *      suspended.
86  *
87  *      NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay
88  *      value are used only if the driver calls pm_runtime_use_autosuspend().
89  *
90  *      wakeup_count - Report the number of wakeup events related to the device
91  */
92
93 static const char enabled[] = "enabled";
94 static const char disabled[] = "disabled";
95
96 const char power_group_name[] = "power";
97 EXPORT_SYMBOL_GPL(power_group_name);
98
99 #ifdef CONFIG_PM_RUNTIME
100 static const char ctrl_auto[] = "auto";
101 static const char ctrl_on[] = "on";
102
103 static ssize_t control_show(struct device *dev, struct device_attribute *attr,
104                             char *buf)
105 {
106         return sprintf(buf, "%s\n",
107                                 dev->power.runtime_auto ? ctrl_auto : ctrl_on);
108 }
109
110 static ssize_t control_store(struct device * dev, struct device_attribute *attr,
111                              const char * buf, size_t n)
112 {
113         char *cp;
114         int len = n;
115
116         cp = memchr(buf, '\n', n);
117         if (cp)
118                 len = cp - buf;
119         device_lock(dev);
120         if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
121                 pm_runtime_allow(dev);
122         else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
123                 pm_runtime_forbid(dev);
124         else
125                 n = -EINVAL;
126         device_unlock(dev);
127         return n;
128 }
129
130 static DEVICE_ATTR(control, 0644, control_show, control_store);
131
132 static ssize_t rtpm_active_time_show(struct device *dev,
133                                 struct device_attribute *attr, char *buf)
134 {
135         int ret;
136         spin_lock_irq(&dev->power.lock);
137         update_pm_runtime_accounting(dev);
138         ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
139         spin_unlock_irq(&dev->power.lock);
140         return ret;
141 }
142
143 static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
144
145 static ssize_t rtpm_suspended_time_show(struct device *dev,
146                                 struct device_attribute *attr, char *buf)
147 {
148         int ret;
149         spin_lock_irq(&dev->power.lock);
150         update_pm_runtime_accounting(dev);
151         ret = sprintf(buf, "%i\n",
152                 jiffies_to_msecs(dev->power.suspended_jiffies));
153         spin_unlock_irq(&dev->power.lock);
154         return ret;
155 }
156
157 static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
158
159 static ssize_t rtpm_status_show(struct device *dev,
160                                 struct device_attribute *attr, char *buf)
161 {
162         const char *p;
163
164         if (dev->power.runtime_error) {
165                 p = "error\n";
166         } else if (dev->power.disable_depth) {
167                 p = "unsupported\n";
168         } else {
169                 switch (dev->power.runtime_status) {
170                 case RPM_SUSPENDED:
171                         p = "suspended\n";
172                         break;
173                 case RPM_SUSPENDING:
174                         p = "suspending\n";
175                         break;
176                 case RPM_RESUMING:
177                         p = "resuming\n";
178                         break;
179                 case RPM_ACTIVE:
180                         p = "active\n";
181                         break;
182                 default:
183                         return -EIO;
184                 }
185         }
186         return sprintf(buf, p);
187 }
188
189 static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
190
191 static ssize_t autosuspend_delay_ms_show(struct device *dev,
192                 struct device_attribute *attr, char *buf)
193 {
194         if (!dev->power.use_autosuspend)
195                 return -EIO;
196         return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
197 }
198
199 static ssize_t autosuspend_delay_ms_store(struct device *dev,
200                 struct device_attribute *attr, const char *buf, size_t n)
201 {
202         long delay;
203
204         if (!dev->power.use_autosuspend)
205                 return -EIO;
206
207         if (strict_strtol(buf, 10, &delay) != 0 || delay != (int) delay)
208                 return -EINVAL;
209
210         device_lock(dev);
211         pm_runtime_set_autosuspend_delay(dev, delay);
212         device_unlock(dev);
213         return n;
214 }
215
216 static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
217                 autosuspend_delay_ms_store);
218
219 #endif /* CONFIG_PM_RUNTIME */
220
221 #ifdef CONFIG_PM_SLEEP
222 static ssize_t
223 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
224 {
225         return sprintf(buf, "%s\n", device_can_wakeup(dev)
226                 ? (device_may_wakeup(dev) ? enabled : disabled)
227                 : "");
228 }
229
230 static ssize_t
231 wake_store(struct device * dev, struct device_attribute *attr,
232         const char * buf, size_t n)
233 {
234         char *cp;
235         int len = n;
236
237         if (!device_can_wakeup(dev))
238                 return -EINVAL;
239
240         cp = memchr(buf, '\n', n);
241         if (cp)
242                 len = cp - buf;
243         if (len == sizeof enabled - 1
244                         && strncmp(buf, enabled, sizeof enabled - 1) == 0)
245                 device_set_wakeup_enable(dev, 1);
246         else if (len == sizeof disabled - 1
247                         && strncmp(buf, disabled, sizeof disabled - 1) == 0)
248                 device_set_wakeup_enable(dev, 0);
249         else
250                 return -EINVAL;
251         return n;
252 }
253
254 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
255
256 static ssize_t wakeup_count_show(struct device *dev,
257                                 struct device_attribute *attr, char *buf)
258 {
259         unsigned long count = 0;
260         bool enabled = false;
261
262         spin_lock_irq(&dev->power.lock);
263         if (dev->power.wakeup) {
264                 count = dev->power.wakeup->event_count;
265                 enabled = true;
266         }
267         spin_unlock_irq(&dev->power.lock);
268         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
269 }
270
271 static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
272
273 static ssize_t wakeup_active_count_show(struct device *dev,
274                                 struct device_attribute *attr, char *buf)
275 {
276         unsigned long count = 0;
277         bool enabled = false;
278
279         spin_lock_irq(&dev->power.lock);
280         if (dev->power.wakeup) {
281                 count = dev->power.wakeup->active_count;
282                 enabled = true;
283         }
284         spin_unlock_irq(&dev->power.lock);
285         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
286 }
287
288 static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
289
290 static ssize_t wakeup_hit_count_show(struct device *dev,
291                                 struct device_attribute *attr, char *buf)
292 {
293         unsigned long count = 0;
294         bool enabled = false;
295
296         spin_lock_irq(&dev->power.lock);
297         if (dev->power.wakeup) {
298                 count = dev->power.wakeup->hit_count;
299                 enabled = true;
300         }
301         spin_unlock_irq(&dev->power.lock);
302         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
303 }
304
305 static DEVICE_ATTR(wakeup_hit_count, 0444, wakeup_hit_count_show, NULL);
306
307 static ssize_t wakeup_active_show(struct device *dev,
308                                 struct device_attribute *attr, char *buf)
309 {
310         unsigned int active = 0;
311         bool enabled = false;
312
313         spin_lock_irq(&dev->power.lock);
314         if (dev->power.wakeup) {
315                 active = dev->power.wakeup->active;
316                 enabled = true;
317         }
318         spin_unlock_irq(&dev->power.lock);
319         return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
320 }
321
322 static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
323
324 static ssize_t wakeup_total_time_show(struct device *dev,
325                                 struct device_attribute *attr, char *buf)
326 {
327         s64 msec = 0;
328         bool enabled = false;
329
330         spin_lock_irq(&dev->power.lock);
331         if (dev->power.wakeup) {
332                 msec = ktime_to_ms(dev->power.wakeup->total_time);
333                 enabled = true;
334         }
335         spin_unlock_irq(&dev->power.lock);
336         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
337 }
338
339 static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
340
341 static ssize_t wakeup_max_time_show(struct device *dev,
342                                 struct device_attribute *attr, char *buf)
343 {
344         s64 msec = 0;
345         bool enabled = false;
346
347         spin_lock_irq(&dev->power.lock);
348         if (dev->power.wakeup) {
349                 msec = ktime_to_ms(dev->power.wakeup->max_time);
350                 enabled = true;
351         }
352         spin_unlock_irq(&dev->power.lock);
353         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
354 }
355
356 static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
357
358 static ssize_t wakeup_last_time_show(struct device *dev,
359                                 struct device_attribute *attr, char *buf)
360 {
361         s64 msec = 0;
362         bool enabled = false;
363
364         spin_lock_irq(&dev->power.lock);
365         if (dev->power.wakeup) {
366                 msec = ktime_to_ms(dev->power.wakeup->last_time);
367                 enabled = true;
368         }
369         spin_unlock_irq(&dev->power.lock);
370         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
371 }
372
373 static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
374 #endif /* CONFIG_PM_SLEEP */
375
376 #ifdef CONFIG_PM_ADVANCED_DEBUG
377 #ifdef CONFIG_PM_RUNTIME
378
379 static ssize_t rtpm_usagecount_show(struct device *dev,
380                                     struct device_attribute *attr, char *buf)
381 {
382         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
383 }
384
385 static ssize_t rtpm_children_show(struct device *dev,
386                                   struct device_attribute *attr, char *buf)
387 {
388         return sprintf(buf, "%d\n", dev->power.ignore_children ?
389                 0 : atomic_read(&dev->power.child_count));
390 }
391
392 static ssize_t rtpm_enabled_show(struct device *dev,
393                                  struct device_attribute *attr, char *buf)
394 {
395         if ((dev->power.disable_depth) && (dev->power.runtime_auto == false))
396                 return sprintf(buf, "disabled & forbidden\n");
397         else if (dev->power.disable_depth)
398                 return sprintf(buf, "disabled\n");
399         else if (dev->power.runtime_auto == false)
400                 return sprintf(buf, "forbidden\n");
401         return sprintf(buf, "enabled\n");
402 }
403
404 static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
405 static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
406 static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
407
408 #endif
409
410 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
411                           char *buf)
412 {
413         return sprintf(buf, "%s\n",
414                         device_async_suspend_enabled(dev) ? enabled : disabled);
415 }
416
417 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
418                            const char *buf, size_t n)
419 {
420         char *cp;
421         int len = n;
422
423         cp = memchr(buf, '\n', n);
424         if (cp)
425                 len = cp - buf;
426         if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
427                 device_enable_async_suspend(dev);
428         else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
429                 device_disable_async_suspend(dev);
430         else
431                 return -EINVAL;
432         return n;
433 }
434
435 static DEVICE_ATTR(async, 0644, async_show, async_store);
436 #endif /* CONFIG_PM_ADVANCED_DEBUG */
437
438 static struct attribute *power_attrs[] = {
439 #ifdef CONFIG_PM_ADVANCED_DEBUG
440 #ifdef CONFIG_PM_SLEEP
441         &dev_attr_async.attr,
442 #endif
443 #ifdef CONFIG_PM_RUNTIME
444         &dev_attr_runtime_status.attr,
445         &dev_attr_runtime_usage.attr,
446         &dev_attr_runtime_active_kids.attr,
447         &dev_attr_runtime_enabled.attr,
448 #endif
449 #endif /* CONFIG_PM_ADVANCED_DEBUG */
450         NULL,
451 };
452 static struct attribute_group pm_attr_group = {
453         .name   = power_group_name,
454         .attrs  = power_attrs,
455 };
456
457 static struct attribute *wakeup_attrs[] = {
458 #ifdef CONFIG_PM_SLEEP
459         &dev_attr_wakeup.attr,
460         &dev_attr_wakeup_count.attr,
461         &dev_attr_wakeup_active_count.attr,
462         &dev_attr_wakeup_hit_count.attr,
463         &dev_attr_wakeup_active.attr,
464         &dev_attr_wakeup_total_time_ms.attr,
465         &dev_attr_wakeup_max_time_ms.attr,
466         &dev_attr_wakeup_last_time_ms.attr,
467 #endif
468         NULL,
469 };
470 static struct attribute_group pm_wakeup_attr_group = {
471         .name   = power_group_name,
472         .attrs  = wakeup_attrs,
473 };
474
475 static struct attribute *runtime_attrs[] = {
476 #ifdef CONFIG_PM_RUNTIME
477 #ifndef CONFIG_PM_ADVANCED_DEBUG
478         &dev_attr_runtime_status.attr,
479 #endif
480         &dev_attr_control.attr,
481         &dev_attr_runtime_suspended_time.attr,
482         &dev_attr_runtime_active_time.attr,
483         &dev_attr_autosuspend_delay_ms.attr,
484 #endif /* CONFIG_PM_RUNTIME */
485         NULL,
486 };
487 static struct attribute_group pm_runtime_attr_group = {
488         .name   = power_group_name,
489         .attrs  = runtime_attrs,
490 };
491
492 int dpm_sysfs_add(struct device *dev)
493 {
494         int rc;
495
496         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
497         if (rc)
498                 return rc;
499
500         if (pm_runtime_callbacks_present(dev)) {
501                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
502                 if (rc)
503                         goto err_out;
504         }
505
506         if (device_can_wakeup(dev)) {
507                 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
508                 if (rc) {
509                         if (pm_runtime_callbacks_present(dev))
510                                 sysfs_unmerge_group(&dev->kobj,
511                                                     &pm_runtime_attr_group);
512                         goto err_out;
513                 }
514         }
515         return 0;
516
517  err_out:
518         sysfs_remove_group(&dev->kobj, &pm_attr_group);
519         return rc;
520 }
521
522 int wakeup_sysfs_add(struct device *dev)
523 {
524         return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
525 }
526
527 void wakeup_sysfs_remove(struct device *dev)
528 {
529         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
530 }
531
532 void rpm_sysfs_remove(struct device *dev)
533 {
534         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
535 }
536
537 void dpm_sysfs_remove(struct device *dev)
538 {
539         rpm_sysfs_remove(dev);
540         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
541         sysfs_remove_group(&dev->kobj, &pm_attr_group);
542 }