Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) |
Rafael J. Wysocki | a3d25c2 | 2007-05-09 02:33:18 -0700 | [diff] [blame] | 110 | #define PM_SUSPEND_MAX ((__force suspend_state_t) 4) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | |
Johannes Berg | 2a9df49 | 2007-02-16 01:38:30 -0800 | [diff] [blame] | 112 | /** |
| 113 | * struct pm_ops - Callbacks for managing platform dependent suspend states. |
| 114 | * @valid: Callback to determine whether the given state can be entered. |
Johannes Berg | 9684e51 | 2007-04-30 15:09:55 -0700 | [diff] [blame] | 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. |
Johannes Berg | 2a9df49 | 2007-02-16 01:38:30 -0800 | [diff] [blame] | 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. |
Johannes Berg | 2a9df49 | 2007-02-16 01:38:30 -0800 | [diff] [blame] | 128 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | struct pm_ops { |
Shaohua Li | eb9289e | 2005-10-30 15:00:01 -0800 | [diff] [blame] | 130 | int (*valid)(suspend_state_t state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | int (*prepare)(suspend_state_t state); |
| 132 | int (*enter)(suspend_state_t state); |
| 133 | int (*finish)(suspend_state_t state); |
| 134 | }; |
| 135 | |
Johannes Berg | 2a9df49 | 2007-02-16 01:38:30 -0800 | [diff] [blame] | 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); |
Alexey Starikovskiy | e2a5b42 | 2005-03-18 16:20:46 -0500 | [diff] [blame] | 141 | extern struct pm_ops *pm_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | extern int pm_suspend(suspend_state_t state); |
| 143 | |
Johannes Berg | e8c9c50 | 2007-04-30 15:09:54 -0700 | [diff] [blame] | 144 | extern int pm_valid_only_mem(suspend_state_t state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | |
Johannes Berg | a53c46d | 2007-04-26 11:43:58 +0200 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | /* |
| 165 | * Device power management |
| 166 | */ |
| 167 | |
| 168 | struct device; |
| 169 | |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 170 | typedef struct pm_message { |
| 171 | int event; |
| 172 | } pm_message_t; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | |
| 174 | /* |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 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). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | * |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 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. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | */ |
| 222 | |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 223 | #define PM_EVENT_ON 0 |
| 224 | #define PM_EVENT_FREEZE 1 |
| 225 | #define PM_EVENT_SUSPEND 2 |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 226 | #define PM_EVENT_PRETHAW 3 |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 227 | |
| 228 | #define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, }) |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 229 | #define PMSG_PRETHAW ((struct pm_message){ .event = PM_EVENT_PRETHAW, }) |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 230 | #define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, }) |
| 231 | #define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, }) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | |
| 233 | struct dev_pm_info { |
| 234 | pm_message_t power_state; |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 235 | unsigned can_wakeup:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | #ifdef CONFIG_PM |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 237 | unsigned should_wakeup:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | pm_message_t prev_state; |
| 239 | void * saved_state; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | extern int device_power_down(pm_message_t state); |
| 248 | extern void device_power_up(void); |
| 249 | extern void device_resume(void); |
| 250 | |
Pavel Machek | 620b032 | 2005-06-25 14:55:11 -0700 | [diff] [blame] | 251 | #ifdef CONFIG_PM |
| 252 | extern int device_suspend(pm_message_t state); |
Linus Torvalds | 7c8265f | 2006-06-24 14:50:29 -0700 | [diff] [blame] | 253 | extern int device_prepare_suspend(pm_message_t state); |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 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 | |
Andrew Morton | 9a7834d | 2005-10-23 23:02:20 -0700 | [diff] [blame] | 260 | extern int dpm_runtime_suspend(struct device *, pm_message_t); |
| 261 | extern void dpm_runtime_resume(struct device *); |
Andrew Morton | 0266949 | 2006-03-23 01:38:34 -0800 | [diff] [blame] | 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) |
Andrew Morton | 9a7834d | 2005-10-23 23:02:20 -0700 | [diff] [blame] | 268 | |
David Brownell | 075c177 | 2007-04-26 00:12:06 -0700 | [diff] [blame] | 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 | |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 283 | #else /* !CONFIG_PM */ |
| 284 | |
Pavel Machek | 620b032 | 2005-06-25 14:55:11 -0700 | [diff] [blame] | 285 | static inline int device_suspend(pm_message_t state) |
| 286 | { |
| 287 | return 0; |
| 288 | } |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 289 | |
| 290 | #define device_set_wakeup_enable(dev,val) do{}while(0) |
| 291 | #define device_may_wakeup(dev) (0) |
| 292 | |
Andrew Morton | 9a7834d | 2005-10-23 23:02:20 -0700 | [diff] [blame] | 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 | { |
Andrew Morton | 9a7834d | 2005-10-23 23:02:20 -0700 | [diff] [blame] | 300 | } |
| 301 | |
Andrew Morton | 0266949 | 2006-03-23 01:38:34 -0800 | [diff] [blame] | 302 | #define suspend_report_result(fn, ret) do { } while (0) |
| 303 | |
David Brownell | 075c177 | 2007-04-26 00:12:06 -0700 | [diff] [blame] | 304 | static inline int call_platform_enable_wakeup(struct device *dev, int is_on) |
| 305 | { |
David Rientjes | 14e38ac | 2007-04-30 15:09:56 -0700 | [diff] [blame] | 306 | return 0; |
David Brownell | 075c177 | 2007-04-26 00:12:06 -0700 | [diff] [blame] | 307 | } |
| 308 | |
Pavel Machek | 620b032 | 2005-06-25 14:55:11 -0700 | [diff] [blame] | 309 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 310 | |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | #endif /* __KERNEL__ */ |
| 323 | |
| 324 | #endif /* _LINUX_PM_H */ |