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