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> |
1da177e4 LT |
7 | #include "power.h" |
8 | ||
9 | ||
10 | /** | |
11 | * state - Control current power state of device | |
12 | * | |
13 | * show() returns the current power state of the device. '0' indicates | |
14 | * the device is on. Other values (1-3) indicate the device is in a low | |
15 | * power state. | |
16 | * | |
17 | * store() sets the current power state, which is an integer value | |
18 | * between 0-3. If the device is on ('0'), and the value written is | |
19 | * greater than 0, then the device is placed directly into the low-power | |
20 | * state (via its driver's ->suspend() method). | |
21 | * If the device is currently in a low-power state, and the value is 0, | |
22 | * the device is powered back on (via the ->resume() method). | |
23 | * If the device is in a low-power state, and a different low-power state | |
24 | * is requested, the device is first resumed, then suspended into the new | |
25 | * low-power state. | |
26 | */ | |
27 | ||
74880c06 | 28 | static ssize_t state_show(struct device * dev, struct device_attribute *attr, char * buf) |
1da177e4 | 29 | { |
022f7b07 PM |
30 | if (dev->power.power_state.event) |
31 | return sprintf(buf, "2\n"); | |
32 | else | |
33 | return sprintf(buf, "0\n"); | |
1da177e4 LT |
34 | } |
35 | ||
74880c06 | 36 | static ssize_t state_store(struct device * dev, struct device_attribute *attr, const char * buf, size_t n) |
1da177e4 | 37 | { |
ca078bae | 38 | pm_message_t state; |
022f7b07 | 39 | int error = -EINVAL; |
1da177e4 | 40 | |
022f7b07 PM |
41 | state.event = PM_EVENT_SUSPEND; |
42 | /* Older apps expected to write "3" here - confused with PCI D3 */ | |
43 | if ((n == 1) && !strcmp(buf, "3")) | |
1da177e4 | 44 | error = dpm_runtime_suspend(dev, state); |
022f7b07 PM |
45 | |
46 | if ((n == 1) && !strcmp(buf, "2")) | |
47 | error = dpm_runtime_suspend(dev, state); | |
48 | ||
49 | if ((n == 1) && !strcmp(buf, "0")) { | |
1da177e4 | 50 | dpm_runtime_resume(dev); |
022f7b07 PM |
51 | error = 0; |
52 | } | |
53 | ||
1da177e4 LT |
54 | return error ? error : n; |
55 | } | |
56 | ||
57 | static DEVICE_ATTR(state, 0644, state_show, state_store); | |
58 | ||
59 | ||
0ac85241 DB |
60 | /* |
61 | * wakeup - Report/change current wakeup option for device | |
62 | * | |
63 | * Some devices support "wakeup" events, which are hardware signals | |
64 | * used to activate devices from suspended or low power states. Such | |
65 | * devices have one of three values for the sysfs power/wakeup file: | |
66 | * | |
67 | * + "enabled\n" to issue the events; | |
68 | * + "disabled\n" not to do so; or | |
69 | * + "\n" for temporary or permanent inability to issue wakeup. | |
70 | * | |
71 | * (For example, unconfigured USB devices can't issue wakeups.) | |
72 | * | |
73 | * Familiar examples of devices that can issue wakeup events include | |
74 | * keyboards and mice (both PS2 and USB styles), power buttons, modems, | |
75 | * "Wake-On-LAN" Ethernet links, GPIO lines, and more. Some events | |
76 | * will wake the entire system from a suspend state; others may just | |
77 | * wake up the device (if the system as a whole is already active). | |
78 | * Some wakeup events use normal IRQ lines; other use special out | |
79 | * of band signaling. | |
80 | * | |
81 | * It is the responsibility of device drivers to enable (or disable) | |
82 | * wakeup signaling as part of changing device power states, respecting | |
83 | * the policy choices provided through the driver model. | |
84 | * | |
85 | * Devices may not be able to generate wakeup events from all power | |
86 | * states. Also, the events may be ignored in some configurations; | |
87 | * for example, they might need help from other devices that aren't | |
88 | * active, or which may have wakeup disabled. Some drivers rely on | |
89 | * wakeup events internally (unless they are disabled), keeping | |
90 | * their hardware in low power modes whenever they're unused. This | |
91 | * saves runtime power, without requiring system-wide sleep states. | |
92 | */ | |
93 | ||
94 | static const char enabled[] = "enabled"; | |
95 | static const char disabled[] = "disabled"; | |
96 | ||
97 | static ssize_t | |
98 | wake_show(struct device * dev, struct device_attribute *attr, char * buf) | |
99 | { | |
100 | return sprintf(buf, "%s\n", device_can_wakeup(dev) | |
101 | ? (device_may_wakeup(dev) ? enabled : disabled) | |
102 | : ""); | |
103 | } | |
104 | ||
105 | static ssize_t | |
106 | wake_store(struct device * dev, struct device_attribute *attr, | |
107 | const char * buf, size_t n) | |
108 | { | |
109 | char *cp; | |
110 | int len = n; | |
111 | ||
112 | if (!device_can_wakeup(dev)) | |
113 | return -EINVAL; | |
114 | ||
115 | cp = memchr(buf, '\n', n); | |
116 | if (cp) | |
117 | len = cp - buf; | |
118 | if (len == sizeof enabled - 1 | |
119 | && strncmp(buf, enabled, sizeof enabled - 1) == 0) | |
120 | device_set_wakeup_enable(dev, 1); | |
121 | else if (len == sizeof disabled - 1 | |
122 | && strncmp(buf, disabled, sizeof disabled - 1) == 0) | |
123 | device_set_wakeup_enable(dev, 0); | |
124 | else | |
125 | return -EINVAL; | |
126 | return n; | |
127 | } | |
128 | ||
129 | static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store); | |
130 | ||
131 | ||
1da177e4 LT |
132 | static struct attribute * power_attrs[] = { |
133 | &dev_attr_state.attr, | |
0ac85241 | 134 | &dev_attr_wakeup.attr, |
1da177e4 LT |
135 | NULL, |
136 | }; | |
137 | static struct attribute_group pm_attr_group = { | |
138 | .name = "power", | |
139 | .attrs = power_attrs, | |
140 | }; | |
141 | ||
142 | int dpm_sysfs_add(struct device * dev) | |
143 | { | |
144 | return sysfs_create_group(&dev->kobj, &pm_attr_group); | |
145 | } | |
146 | ||
147 | void dpm_sysfs_remove(struct device * dev) | |
148 | { | |
149 | sysfs_remove_group(&dev->kobj, &pm_attr_group); | |
150 | } |