PM / Runtime: Add runtime PM statistics (v3)
[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 <asm/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  *      wakeup_count - Report the number of wakeup events related to the device
79  */
80
81 static const char enabled[] = "enabled";
82 static const char disabled[] = "disabled";
83
84 #ifdef CONFIG_PM_RUNTIME
85 static const char ctrl_auto[] = "auto";
86 static const char ctrl_on[] = "on";
87
88 static ssize_t control_show(struct device *dev, struct device_attribute *attr,
89                             char *buf)
90 {
91         return sprintf(buf, "%s\n",
92                                 dev->power.runtime_auto ? ctrl_auto : ctrl_on);
93 }
94
95 static ssize_t control_store(struct device * dev, struct device_attribute *attr,
96                              const char * buf, size_t n)
97 {
98         char *cp;
99         int len = n;
100
101         cp = memchr(buf, '\n', n);
102         if (cp)
103                 len = cp - buf;
104         if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
105                 pm_runtime_allow(dev);
106         else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
107                 pm_runtime_forbid(dev);
108         else
109                 return -EINVAL;
110         return n;
111 }
112
113 static DEVICE_ATTR(control, 0644, control_show, control_store);
114
115 static ssize_t rtpm_active_time_show(struct device *dev,
116                                 struct device_attribute *attr, char *buf)
117 {
118         int ret;
119         spin_lock_irq(&dev->power.lock);
120         update_pm_runtime_accounting(dev);
121         ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
122         spin_unlock_irq(&dev->power.lock);
123         return ret;
124 }
125
126 static DEVICE_ATTR(runtime_active_time, 0444, rtpm_active_time_show, NULL);
127
128 static ssize_t rtpm_suspended_time_show(struct device *dev,
129                                 struct device_attribute *attr, char *buf)
130 {
131         int ret;
132         spin_lock_irq(&dev->power.lock);
133         update_pm_runtime_accounting(dev);
134         ret = sprintf(buf, "%i\n",
135                 jiffies_to_msecs(dev->power.suspended_jiffies));
136         spin_unlock_irq(&dev->power.lock);
137         return ret;
138 }
139
140 static DEVICE_ATTR(runtime_suspended_time, 0444, rtpm_suspended_time_show, NULL);
141
142 static ssize_t rtpm_status_show(struct device *dev,
143                                 struct device_attribute *attr, char *buf)
144 {
145         const char *p;
146
147         if (dev->power.runtime_error) {
148                 p = "error\n";
149         } else if (dev->power.disable_depth) {
150                 p = "unsupported\n";
151         } else {
152                 switch (dev->power.runtime_status) {
153                 case RPM_SUSPENDED:
154                         p = "suspended\n";
155                         break;
156                 case RPM_SUSPENDING:
157                         p = "suspending\n";
158                         break;
159                 case RPM_RESUMING:
160                         p = "resuming\n";
161                         break;
162                 case RPM_ACTIVE:
163                         p = "active\n";
164                         break;
165                 default:
166                         return -EIO;
167                 }
168         }
169         return sprintf(buf, p);
170 }
171
172 static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
173 #endif
174
175 static ssize_t
176 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
177 {
178         return sprintf(buf, "%s\n", device_can_wakeup(dev)
179                 ? (device_may_wakeup(dev) ? enabled : disabled)
180                 : "");
181 }
182
183 static ssize_t
184 wake_store(struct device * dev, struct device_attribute *attr,
185         const char * buf, size_t n)
186 {
187         char *cp;
188         int len = n;
189
190         if (!device_can_wakeup(dev))
191                 return -EINVAL;
192
193         cp = memchr(buf, '\n', n);
194         if (cp)
195                 len = cp - buf;
196         if (len == sizeof enabled - 1
197                         && strncmp(buf, enabled, sizeof enabled - 1) == 0)
198                 device_set_wakeup_enable(dev, 1);
199         else if (len == sizeof disabled - 1
200                         && strncmp(buf, disabled, sizeof disabled - 1) == 0)
201                 device_set_wakeup_enable(dev, 0);
202         else
203                 return -EINVAL;
204         return n;
205 }
206
207 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
208
209 #ifdef CONFIG_PM_SLEEP
210 static ssize_t wakeup_count_show(struct device *dev,
211                                 struct device_attribute *attr, char *buf)
212 {
213         return sprintf(buf, "%lu\n", dev->power.wakeup_count);
214 }
215
216 static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
217 #endif
218
219 #ifdef CONFIG_PM_ADVANCED_DEBUG
220 #ifdef CONFIG_PM_RUNTIME
221
222 static ssize_t rtpm_usagecount_show(struct device *dev,
223                                     struct device_attribute *attr, char *buf)
224 {
225         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
226 }
227
228 static ssize_t rtpm_children_show(struct device *dev,
229                                   struct device_attribute *attr, char *buf)
230 {
231         return sprintf(buf, "%d\n", dev->power.ignore_children ?
232                 0 : atomic_read(&dev->power.child_count));
233 }
234
235 static ssize_t rtpm_enabled_show(struct device *dev,
236                                  struct device_attribute *attr, char *buf)
237 {
238         if ((dev->power.disable_depth) && (dev->power.runtime_auto == false))
239                 return sprintf(buf, "disabled & forbidden\n");
240         else if (dev->power.disable_depth)
241                 return sprintf(buf, "disabled\n");
242         else if (dev->power.runtime_auto == false)
243                 return sprintf(buf, "forbidden\n");
244         return sprintf(buf, "enabled\n");
245 }
246
247 static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
248 static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
249 static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
250
251 #endif
252
253 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
254                           char *buf)
255 {
256         return sprintf(buf, "%s\n",
257                         device_async_suspend_enabled(dev) ? enabled : disabled);
258 }
259
260 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
261                            const char *buf, size_t n)
262 {
263         char *cp;
264         int len = n;
265
266         cp = memchr(buf, '\n', n);
267         if (cp)
268                 len = cp - buf;
269         if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
270                 device_enable_async_suspend(dev);
271         else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
272                 device_disable_async_suspend(dev);
273         else
274                 return -EINVAL;
275         return n;
276 }
277
278 static DEVICE_ATTR(async, 0644, async_show, async_store);
279 #endif /* CONFIG_PM_ADVANCED_DEBUG */
280
281 static struct attribute * power_attrs[] = {
282 #ifdef CONFIG_PM_RUNTIME
283         &dev_attr_control.attr,
284         &dev_attr_runtime_status.attr,
285         &dev_attr_runtime_suspended_time.attr,
286         &dev_attr_runtime_active_time.attr,
287 #endif
288         &dev_attr_wakeup.attr,
289 #ifdef CONFIG_PM_SLEEP
290         &dev_attr_wakeup_count.attr,
291 #endif
292 #ifdef CONFIG_PM_ADVANCED_DEBUG
293         &dev_attr_async.attr,
294 #ifdef CONFIG_PM_RUNTIME
295         &dev_attr_runtime_usage.attr,
296         &dev_attr_runtime_active_kids.attr,
297         &dev_attr_runtime_enabled.attr,
298 #endif
299 #endif
300         NULL,
301 };
302 static struct attribute_group pm_attr_group = {
303         .name   = "power",
304         .attrs  = power_attrs,
305 };
306
307 int dpm_sysfs_add(struct device * dev)
308 {
309         return sysfs_create_group(&dev->kobj, &pm_attr_group);
310 }
311
312 void dpm_sysfs_remove(struct device * dev)
313 {
314         sysfs_remove_group(&dev->kobj, &pm_attr_group);
315 }