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 "power.h" 9 10 /* 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 * 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. 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. 75 */ 76 77 static const char enabled[] = "enabled"; 78 static const char disabled[] = "disabled"; 79 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 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 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 */ 174 175 static struct attribute * power_attrs[] = { 176 #ifdef CONFIG_PM_RUNTIME 177 &dev_attr_control.attr, 178 #endif 179 &dev_attr_wakeup.attr, 180 #ifdef CONFIG_PM_SLEEP_ADVANCED_DEBUG 181 &dev_attr_async.attr, 182 #endif 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 } 199