]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * drivers/base/power/sysfs.c - sysfs entries for device PM | |
3 | */ | |
4 | ||
5 | #include <linux/device.h> | |
8c65b4a6 | 6 | #include <linux/string.h> |
53823639 | 7 | #include <linux/pm_runtime.h> |
c92445fa | 8 | #include <asm/atomic.h> |
1da177e4 LT |
9 | #include "power.h" |
10 | ||
0ac85241 | 11 | /* |
53823639 RW |
12 | * control - Report/change current runtime PM setting of the device |
13 | * | |
14 | * Runtime power management of a device can be blocked with the help of | |
15 | * this attribute. All devices have one of the following two values for | |
16 | * the power/control file: | |
17 | * | |
18 | * + "auto\n" to allow the device to be power managed at run time; | |
19 | * + "on\n" to prevent the device from being power managed at run time; | |
20 | * | |
21 | * The default for all devices is "auto", which means that devices may be | |
22 | * subject to automatic power management, depending on their drivers. | |
23 | * Changing this attribute to "on" prevents the driver from power managing | |
24 | * the device at run time. Doing that while the device is suspended causes | |
25 | * it to be woken up. | |
26 | * | |
0ac85241 DB |
27 | * wakeup - Report/change current wakeup option for device |
28 | * | |
29 | * Some devices support "wakeup" events, which are hardware signals | |
30 | * used to activate devices from suspended or low power states. Such | |
31 | * devices have one of three values for the sysfs power/wakeup file: | |
32 | * | |
33 | * + "enabled\n" to issue the events; | |
34 | * + "disabled\n" not to do so; or | |
35 | * + "\n" for temporary or permanent inability to issue wakeup. | |
36 | * | |
37 | * (For example, unconfigured USB devices can't issue wakeups.) | |
38 | * | |
39 | * Familiar examples of devices that can issue wakeup events include | |
40 | * keyboards and mice (both PS2 and USB styles), power buttons, modems, | |
41 | * "Wake-On-LAN" Ethernet links, GPIO lines, and more. Some events | |
42 | * will wake the entire system from a suspend state; others may just | |
43 | * wake up the device (if the system as a whole is already active). | |
44 | * Some wakeup events use normal IRQ lines; other use special out | |
45 | * of band signaling. | |
46 | * | |
47 | * It is the responsibility of device drivers to enable (or disable) | |
48 | * wakeup signaling as part of changing device power states, respecting | |
49 | * the policy choices provided through the driver model. | |
50 | * | |
51 | * Devices may not be able to generate wakeup events from all power | |
52 | * states. Also, the events may be ignored in some configurations; | |
53 | * for example, they might need help from other devices that aren't | |
54 | * active, or which may have wakeup disabled. Some drivers rely on | |
55 | * wakeup events internally (unless they are disabled), keeping | |
56 | * their hardware in low power modes whenever they're unused. This | |
57 | * saves runtime power, without requiring system-wide sleep states. | |
5a2eb858 RW |
58 | * |
59 | * async - Report/change current async suspend setting for the device | |
60 | * | |
61 | * Asynchronous suspend and resume of the device during system-wide power | |
62 | * state transitions can be enabled by writing "enabled" to this file. | |
63 | * Analogously, if "disabled" is written to this file, the device will be | |
64 | * suspended and resumed synchronously. | |
65 | * | |
66 | * All devices have one of the following two values for power/async: | |
67 | * | |
68 | * + "enabled\n" to permit the asynchronous suspend/resume of the device; | |
69 | * + "disabled\n" to forbid it; | |
70 | * | |
71 | * NOTE: It generally is unsafe to permit the asynchronous suspend/resume | |
72 | * of a device unless it is certain that all of the PM dependencies of the | |
73 | * device are known to the PM core. However, for some devices this | |
74 | * attribute is set to "enabled" by bus type code or device drivers and in | |
75 | * that cases it should be safe to leave the default value. | |
0ac85241 DB |
76 | */ |
77 | ||
78 | static const char enabled[] = "enabled"; | |
79 | static const char disabled[] = "disabled"; | |
80 | ||
53823639 RW |
81 | #ifdef CONFIG_PM_RUNTIME |
82 | static const char ctrl_auto[] = "auto"; | |
83 | static const char ctrl_on[] = "on"; | |
84 | ||
85 | static ssize_t control_show(struct device *dev, struct device_attribute *attr, | |
86 | char *buf) | |
87 | { | |
88 | return sprintf(buf, "%s\n", | |
89 | dev->power.runtime_auto ? ctrl_auto : ctrl_on); | |
90 | } | |
91 | ||
92 | static ssize_t control_store(struct device * dev, struct device_attribute *attr, | |
93 | const char * buf, size_t n) | |
94 | { | |
95 | char *cp; | |
96 | int len = n; | |
97 | ||
98 | cp = memchr(buf, '\n', n); | |
99 | if (cp) | |
100 | len = cp - buf; | |
101 | if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0) | |
102 | pm_runtime_allow(dev); | |
103 | else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0) | |
104 | pm_runtime_forbid(dev); | |
105 | else | |
106 | return -EINVAL; | |
107 | return n; | |
108 | } | |
109 | ||
110 | static DEVICE_ATTR(control, 0644, control_show, control_store); | |
111 | #endif | |
112 | ||
0ac85241 DB |
113 | static ssize_t |
114 | wake_show(struct device * dev, struct device_attribute *attr, char * buf) | |
115 | { | |
116 | return sprintf(buf, "%s\n", device_can_wakeup(dev) | |
117 | ? (device_may_wakeup(dev) ? enabled : disabled) | |
118 | : ""); | |
119 | } | |
120 | ||
121 | static ssize_t | |
122 | wake_store(struct device * dev, struct device_attribute *attr, | |
123 | const char * buf, size_t n) | |
124 | { | |
125 | char *cp; | |
126 | int len = n; | |
127 | ||
128 | if (!device_can_wakeup(dev)) | |
129 | return -EINVAL; | |
130 | ||
131 | cp = memchr(buf, '\n', n); | |
132 | if (cp) | |
133 | len = cp - buf; | |
134 | if (len == sizeof enabled - 1 | |
135 | && strncmp(buf, enabled, sizeof enabled - 1) == 0) | |
136 | device_set_wakeup_enable(dev, 1); | |
137 | else if (len == sizeof disabled - 1 | |
138 | && strncmp(buf, disabled, sizeof disabled - 1) == 0) | |
139 | device_set_wakeup_enable(dev, 0); | |
140 | else | |
141 | return -EINVAL; | |
142 | return n; | |
143 | } | |
144 | ||
145 | static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store); | |
146 | ||
c92445fa DB |
147 | #ifdef CONFIG_PM_ADVANCED_DEBUG |
148 | #ifdef CONFIG_PM_RUNTIME | |
149 | ||
150 | static ssize_t rtpm_usagecount_show(struct device *dev, | |
151 | struct device_attribute *attr, char *buf) | |
152 | { | |
153 | return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count)); | |
154 | } | |
155 | ||
156 | static ssize_t rtpm_children_show(struct device *dev, | |
157 | struct device_attribute *attr, char *buf) | |
158 | { | |
159 | return sprintf(buf, "%d\n", dev->power.ignore_children ? | |
160 | 0 : atomic_read(&dev->power.child_count)); | |
161 | } | |
162 | ||
163 | static ssize_t rtpm_enabled_show(struct device *dev, | |
164 | struct device_attribute *attr, char *buf) | |
165 | { | |
166 | if ((dev->power.disable_depth) && (dev->power.runtime_auto == false)) | |
167 | return sprintf(buf, "disabled & forbidden\n"); | |
168 | else if (dev->power.disable_depth) | |
169 | return sprintf(buf, "disabled\n"); | |
170 | else if (dev->power.runtime_auto == false) | |
171 | return sprintf(buf, "forbidden\n"); | |
172 | return sprintf(buf, "enabled\n"); | |
173 | } | |
174 | ||
175 | static ssize_t rtpm_status_show(struct device *dev, | |
176 | struct device_attribute *attr, char *buf) | |
177 | { | |
178 | if (dev->power.runtime_error) | |
179 | return sprintf(buf, "error\n"); | |
180 | switch (dev->power.runtime_status) { | |
181 | case RPM_SUSPENDED: | |
182 | return sprintf(buf, "suspended\n"); | |
183 | case RPM_SUSPENDING: | |
184 | return sprintf(buf, "suspending\n"); | |
185 | case RPM_RESUMING: | |
186 | return sprintf(buf, "resuming\n"); | |
187 | case RPM_ACTIVE: | |
188 | return sprintf(buf, "active\n"); | |
189 | } | |
190 | return -EIO; | |
191 | } | |
192 | ||
193 | static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL); | |
194 | static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL); | |
195 | static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL); | |
196 | static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL); | |
197 | ||
198 | #endif | |
199 | ||
5a2eb858 RW |
200 | static ssize_t async_show(struct device *dev, struct device_attribute *attr, |
201 | char *buf) | |
202 | { | |
203 | return sprintf(buf, "%s\n", | |
204 | device_async_suspend_enabled(dev) ? enabled : disabled); | |
205 | } | |
206 | ||
207 | static ssize_t async_store(struct device *dev, struct device_attribute *attr, | |
208 | const char *buf, size_t n) | |
209 | { | |
210 | char *cp; | |
211 | int len = n; | |
212 | ||
213 | cp = memchr(buf, '\n', n); | |
214 | if (cp) | |
215 | len = cp - buf; | |
216 | if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0) | |
217 | device_enable_async_suspend(dev); | |
218 | else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0) | |
219 | device_disable_async_suspend(dev); | |
220 | else | |
221 | return -EINVAL; | |
222 | return n; | |
223 | } | |
224 | ||
225 | static DEVICE_ATTR(async, 0644, async_show, async_store); | |
c92445fa | 226 | #endif /* CONFIG_PM_ADVANCED_DEBUG */ |
0ac85241 | 227 | |
1da177e4 | 228 | static struct attribute * power_attrs[] = { |
53823639 RW |
229 | #ifdef CONFIG_PM_RUNTIME |
230 | &dev_attr_control.attr, | |
231 | #endif | |
0ac85241 | 232 | &dev_attr_wakeup.attr, |
c92445fa | 233 | #ifdef CONFIG_PM_ADVANCED_DEBUG |
5a2eb858 | 234 | &dev_attr_async.attr, |
c92445fa DB |
235 | #ifdef CONFIG_PM_RUNTIME |
236 | &dev_attr_runtime_usage.attr, | |
237 | &dev_attr_runtime_active_kids.attr, | |
238 | &dev_attr_runtime_status.attr, | |
239 | &dev_attr_runtime_enabled.attr, | |
240 | #endif | |
5a2eb858 | 241 | #endif |
1da177e4 LT |
242 | NULL, |
243 | }; | |
244 | static struct attribute_group pm_attr_group = { | |
245 | .name = "power", | |
246 | .attrs = power_attrs, | |
247 | }; | |
248 | ||
249 | int dpm_sysfs_add(struct device * dev) | |
250 | { | |
251 | return sysfs_create_group(&dev->kobj, &pm_attr_group); | |
252 | } | |
253 | ||
254 | void dpm_sysfs_remove(struct device * dev) | |
255 | { | |
256 | sysfs_remove_group(&dev->kobj, &pm_attr_group); | |
257 | } |