1 /* 2 * pm.h - Power management interface 3 * 4 * Copyright (C) 2000 Andrew Henroid 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #ifndef _LINUX_PM_H 22 #define _LINUX_PM_H 23 24 #ifdef __KERNEL__ 25 26 #include <linux/list.h> 27 #include <asm/atomic.h> 28 29 /* 30 * Power management requests... these are passed to pm_send_all() and friends. 31 * 32 * these functions are old and deprecated, see below. 33 */ 34 typedef int __bitwise pm_request_t; 35 36 #define PM_SUSPEND ((__force pm_request_t) 1) /* enter D1-D3 */ 37 #define PM_RESUME ((__force pm_request_t) 2) /* enter D0 */ 38 39 40 /* 41 * Device types... these are passed to pm_register 42 */ 43 typedef int __bitwise pm_dev_t; 44 45 #define PM_UNKNOWN_DEV ((__force pm_dev_t) 0) /* generic */ 46 #define PM_SYS_DEV ((__force pm_dev_t) 1) /* system device (fan, KB controller, ...) */ 47 #define PM_PCI_DEV ((__force pm_dev_t) 2) /* PCI device */ 48 #define PM_USB_DEV ((__force pm_dev_t) 3) /* USB device */ 49 #define PM_SCSI_DEV ((__force pm_dev_t) 4) /* SCSI device */ 50 #define PM_ISA_DEV ((__force pm_dev_t) 5) /* ISA device */ 51 #define PM_MTD_DEV ((__force pm_dev_t) 6) /* Memory Technology Device */ 52 53 /* 54 * System device hardware ID (PnP) values 55 */ 56 enum 57 { 58 PM_SYS_UNKNOWN = 0x00000000, /* generic */ 59 PM_SYS_KBC = 0x41d00303, /* keyboard controller */ 60 PM_SYS_COM = 0x41d00500, /* serial port */ 61 PM_SYS_IRDA = 0x41d00510, /* IRDA controller */ 62 PM_SYS_FDC = 0x41d00700, /* floppy controller */ 63 PM_SYS_VGA = 0x41d00900, /* VGA controller */ 64 PM_SYS_PCMCIA = 0x41d00e00, /* PCMCIA controller */ 65 }; 66 67 /* 68 * Device identifier 69 */ 70 #define PM_PCI_ID(dev) ((dev)->bus->number << 16 | (dev)->devfn) 71 72 /* 73 * Request handler callback 74 */ 75 struct pm_dev; 76 77 typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data); 78 79 /* 80 * Dynamic device information 81 */ 82 struct pm_dev 83 { 84 pm_dev_t type; 85 unsigned long id; 86 pm_callback callback; 87 void *data; 88 89 unsigned long flags; 90 unsigned long state; 91 unsigned long prev_state; 92 93 struct list_head entry; 94 }; 95 96 /* Functions above this comment are list-based old-style power 97 * managment. Please avoid using them. */ 98 99 /* 100 * Callbacks for platform drivers to implement. 101 */ 102 extern void (*pm_idle)(void); 103 extern void (*pm_power_off)(void); 104 105 typedef int __bitwise suspend_state_t; 106 107 #define PM_SUSPEND_ON ((__force suspend_state_t) 0) 108 #define PM_SUSPEND_STANDBY ((__force suspend_state_t) 1) 109 #define PM_SUSPEND_MEM ((__force suspend_state_t) 3) 110 #define PM_SUSPEND_MAX ((__force suspend_state_t) 4) 111 112 /** 113 * struct pm_ops - Callbacks for managing platform dependent suspend states. 114 * @valid: Callback to determine whether the given state can be entered. 115 * Valid states are advertised in /sys/power/state but can still 116 * be rejected by prepare or enter if the conditions aren't right. 117 * There is a %pm_valid_only_mem function available that can be assigned 118 * to this if you only implement mem sleep. 119 * 120 * @prepare: Prepare the platform for the given suspend state. Can return a 121 * negative error code if necessary. 122 * 123 * @enter: Enter the given suspend state, must be assigned. Can return a 124 * negative error code if necessary. 125 * 126 * @finish: Called when the system has left the given state and all devices 127 * are resumed. The return value is ignored. 128 */ 129 struct pm_ops { 130 int (*valid)(suspend_state_t state); 131 int (*prepare)(suspend_state_t state); 132 int (*enter)(suspend_state_t state); 133 int (*finish)(suspend_state_t state); 134 }; 135 136 /** 137 * pm_set_ops - set platform dependent power management ops 138 * @pm_ops: The new power management operations to set. 139 */ 140 extern void pm_set_ops(struct pm_ops *pm_ops); 141 extern struct pm_ops *pm_ops; 142 extern int pm_suspend(suspend_state_t state); 143 144 extern int pm_valid_only_mem(suspend_state_t state); 145 146 /** 147 * arch_suspend_disable_irqs - disable IRQs for suspend 148 * 149 * Disables IRQs (in the default case). This is a weak symbol in the common 150 * code and thus allows architectures to override it if more needs to be 151 * done. Not called for suspend to disk. 152 */ 153 extern void arch_suspend_disable_irqs(void); 154 155 /** 156 * arch_suspend_enable_irqs - enable IRQs after suspend 157 * 158 * Enables IRQs (in the default case). This is a weak symbol in the common 159 * code and thus allows architectures to override it if more needs to be 160 * done. Not called for suspend to disk. 161 */ 162 extern void arch_suspend_enable_irqs(void); 163 164 /* 165 * Device power management 166 */ 167 168 struct device; 169 170 typedef struct pm_message { 171 int event; 172 } pm_message_t; 173 174 /* 175 * Several driver power state transitions are externally visible, affecting 176 * the state of pending I/O queues and (for drivers that touch hardware) 177 * interrupts, wakeups, DMA, and other hardware state. There may also be 178 * internal transitions to various low power modes, which are transparent 179 * to the rest of the driver stack (such as a driver that's ON gating off 180 * clocks which are not in active use). 181 * 182 * One transition is triggered by resume(), after a suspend() call; the 183 * message is implicit: 184 * 185 * ON Driver starts working again, responding to hardware events 186 * and software requests. The hardware may have gone through 187 * a power-off reset, or it may have maintained state from the 188 * previous suspend() which the driver will rely on while 189 * resuming. On most platforms, there are no restrictions on 190 * availability of resources like clocks during resume(). 191 * 192 * Other transitions are triggered by messages sent using suspend(). All 193 * these transitions quiesce the driver, so that I/O queues are inactive. 194 * That commonly entails turning off IRQs and DMA; there may be rules 195 * about how to quiesce that are specific to the bus or the device's type. 196 * (For example, network drivers mark the link state.) Other details may 197 * differ according to the message: 198 * 199 * SUSPEND Quiesce, enter a low power device state appropriate for 200 * the upcoming system state (such as PCI_D3hot), and enable 201 * wakeup events as appropriate. 202 * 203 * FREEZE Quiesce operations so that a consistent image can be saved; 204 * but do NOT otherwise enter a low power device state, and do 205 * NOT emit system wakeup events. 206 * 207 * PRETHAW Quiesce as if for FREEZE; additionally, prepare for restoring 208 * the system from a snapshot taken after an earlier FREEZE. 209 * Some drivers will need to reset their hardware state instead 210 * of preserving it, to ensure that it's never mistaken for the 211 * state which that earlier snapshot had set up. 212 * 213 * A minimally power-aware driver treats all messages as SUSPEND, fully 214 * reinitializes its device during resume() -- whether or not it was reset 215 * during the suspend/resume cycle -- and can't issue wakeup events. 216 * 217 * More power-aware drivers may also use low power states at runtime as 218 * well as during system sleep states like PM_SUSPEND_STANDBY. They may 219 * be able to use wakeup events to exit from runtime low-power states, 220 * or from system low-power states such as standby or suspend-to-RAM. 221 */ 222 223 #define PM_EVENT_ON 0 224 #define PM_EVENT_FREEZE 1 225 #define PM_EVENT_SUSPEND 2 226 #define PM_EVENT_PRETHAW 3 227 228 #define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, }) 229 #define PMSG_PRETHAW ((struct pm_message){ .event = PM_EVENT_PRETHAW, }) 230 #define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, }) 231 #define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, }) 232 233 struct dev_pm_info { 234 pm_message_t power_state; 235 unsigned can_wakeup:1; 236 #ifdef CONFIG_PM 237 unsigned should_wakeup:1; 238 pm_message_t prev_state; 239 void * saved_state; 240 struct device * pm_parent; 241 struct list_head entry; 242 #endif 243 }; 244 245 extern void device_pm_set_parent(struct device * dev, struct device * parent); 246 247 extern int device_power_down(pm_message_t state); 248 extern void device_power_up(void); 249 extern void device_resume(void); 250 251 #ifdef CONFIG_PM 252 extern int device_suspend(pm_message_t state); 253 extern int device_prepare_suspend(pm_message_t state); 254 255 #define device_set_wakeup_enable(dev,val) \ 256 ((dev)->power.should_wakeup = !!(val)) 257 #define device_may_wakeup(dev) \ 258 (device_can_wakeup(dev) && (dev)->power.should_wakeup) 259 260 extern int dpm_runtime_suspend(struct device *, pm_message_t); 261 extern void dpm_runtime_resume(struct device *); 262 extern void __suspend_report_result(const char *function, void *fn, int ret); 263 264 #define suspend_report_result(fn, ret) \ 265 do { \ 266 __suspend_report_result(__FUNCTION__, fn, ret); \ 267 } while (0) 268 269 /* 270 * Platform hook to activate device wakeup capability, if that's not already 271 * handled by enable_irq_wake() etc. 272 * Returns zero on success, else negative errno 273 */ 274 extern int (*platform_enable_wakeup)(struct device *dev, int is_on); 275 276 static inline int call_platform_enable_wakeup(struct device *dev, int is_on) 277 { 278 if (platform_enable_wakeup) 279 return (*platform_enable_wakeup)(dev, is_on); 280 return 0; 281 } 282 283 #else /* !CONFIG_PM */ 284 285 static inline int device_suspend(pm_message_t state) 286 { 287 return 0; 288 } 289 290 #define device_set_wakeup_enable(dev,val) do{}while(0) 291 #define device_may_wakeup(dev) (0) 292 293 static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state) 294 { 295 return 0; 296 } 297 298 static inline void dpm_runtime_resume(struct device * dev) 299 { 300 } 301 302 #define suspend_report_result(fn, ret) do { } while (0) 303 304 static inline int call_platform_enable_wakeup(struct device *dev, int is_on) 305 { 306 return 0; 307 } 308 309 #endif 310 311 /* changes to device_may_wakeup take effect on the next pm state change. 312 * by default, devices should wakeup if they can. 313 */ 314 #define device_can_wakeup(dev) \ 315 ((dev)->power.can_wakeup) 316 #define device_init_wakeup(dev,val) \ 317 do { \ 318 device_can_wakeup(dev) = !!(val); \ 319 device_set_wakeup_enable(dev,val); \ 320 } while(0) 321 322 #endif /* __KERNEL__ */ 323 324 #endif /* _LINUX_PM_H */ 325