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> |
Alexey Dobriyan | 80ba80a | 2007-07-30 23:08:46 +0400 | [diff] [blame] | 28 | #include <asm/errno.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
| 30 | /* |
| 31 | * Power management requests... these are passed to pm_send_all() and friends. |
| 32 | * |
| 33 | * these functions are old and deprecated, see below. |
| 34 | */ |
| 35 | typedef int __bitwise pm_request_t; |
| 36 | |
| 37 | #define PM_SUSPEND ((__force pm_request_t) 1) /* enter D1-D3 */ |
| 38 | #define PM_RESUME ((__force pm_request_t) 2) /* enter D0 */ |
| 39 | |
| 40 | |
| 41 | /* |
| 42 | * Device types... these are passed to pm_register |
| 43 | */ |
| 44 | typedef int __bitwise pm_dev_t; |
| 45 | |
| 46 | #define PM_UNKNOWN_DEV ((__force pm_dev_t) 0) /* generic */ |
| 47 | #define PM_SYS_DEV ((__force pm_dev_t) 1) /* system device (fan, KB controller, ...) */ |
| 48 | #define PM_PCI_DEV ((__force pm_dev_t) 2) /* PCI device */ |
| 49 | #define PM_USB_DEV ((__force pm_dev_t) 3) /* USB device */ |
| 50 | #define PM_SCSI_DEV ((__force pm_dev_t) 4) /* SCSI device */ |
| 51 | #define PM_ISA_DEV ((__force pm_dev_t) 5) /* ISA device */ |
| 52 | #define PM_MTD_DEV ((__force pm_dev_t) 6) /* Memory Technology Device */ |
| 53 | |
| 54 | /* |
| 55 | * System device hardware ID (PnP) values |
| 56 | */ |
| 57 | enum |
| 58 | { |
| 59 | PM_SYS_UNKNOWN = 0x00000000, /* generic */ |
| 60 | PM_SYS_KBC = 0x41d00303, /* keyboard controller */ |
| 61 | PM_SYS_COM = 0x41d00500, /* serial port */ |
| 62 | PM_SYS_IRDA = 0x41d00510, /* IRDA controller */ |
| 63 | PM_SYS_FDC = 0x41d00700, /* floppy controller */ |
| 64 | PM_SYS_VGA = 0x41d00900, /* VGA controller */ |
| 65 | PM_SYS_PCMCIA = 0x41d00e00, /* PCMCIA controller */ |
| 66 | }; |
| 67 | |
| 68 | /* |
| 69 | * Device identifier |
| 70 | */ |
| 71 | #define PM_PCI_ID(dev) ((dev)->bus->number << 16 | (dev)->devfn) |
| 72 | |
| 73 | /* |
| 74 | * Request handler callback |
| 75 | */ |
| 76 | struct pm_dev; |
| 77 | |
| 78 | typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data); |
| 79 | |
| 80 | /* |
| 81 | * Dynamic device information |
| 82 | */ |
| 83 | struct pm_dev |
| 84 | { |
| 85 | pm_dev_t type; |
| 86 | unsigned long id; |
| 87 | pm_callback callback; |
| 88 | void *data; |
| 89 | |
| 90 | unsigned long flags; |
| 91 | unsigned long state; |
| 92 | unsigned long prev_state; |
| 93 | |
| 94 | struct list_head entry; |
| 95 | }; |
| 96 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | /* Functions above this comment are list-based old-style power |
| 98 | * managment. Please avoid using them. */ |
| 99 | |
| 100 | /* |
| 101 | * Callbacks for platform drivers to implement. |
| 102 | */ |
| 103 | extern void (*pm_idle)(void); |
| 104 | extern void (*pm_power_off)(void); |
Rafael J. Wysocki | bd804eb | 2007-07-19 01:47:40 -0700 | [diff] [blame] | 105 | extern void (*pm_power_off_prepare)(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | /* |
| 108 | * Device power management |
| 109 | */ |
| 110 | |
| 111 | struct device; |
| 112 | |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 113 | typedef struct pm_message { |
| 114 | int event; |
| 115 | } pm_message_t; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | |
| 117 | /* |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 118 | * Several driver power state transitions are externally visible, affecting |
| 119 | * the state of pending I/O queues and (for drivers that touch hardware) |
| 120 | * interrupts, wakeups, DMA, and other hardware state. There may also be |
| 121 | * internal transitions to various low power modes, which are transparent |
| 122 | * to the rest of the driver stack (such as a driver that's ON gating off |
| 123 | * clocks which are not in active use). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | * |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 125 | * One transition is triggered by resume(), after a suspend() call; the |
| 126 | * message is implicit: |
| 127 | * |
| 128 | * ON Driver starts working again, responding to hardware events |
| 129 | * and software requests. The hardware may have gone through |
| 130 | * a power-off reset, or it may have maintained state from the |
| 131 | * previous suspend() which the driver will rely on while |
| 132 | * resuming. On most platforms, there are no restrictions on |
| 133 | * availability of resources like clocks during resume(). |
| 134 | * |
| 135 | * Other transitions are triggered by messages sent using suspend(). All |
| 136 | * these transitions quiesce the driver, so that I/O queues are inactive. |
| 137 | * That commonly entails turning off IRQs and DMA; there may be rules |
| 138 | * about how to quiesce that are specific to the bus or the device's type. |
| 139 | * (For example, network drivers mark the link state.) Other details may |
| 140 | * differ according to the message: |
| 141 | * |
| 142 | * SUSPEND Quiesce, enter a low power device state appropriate for |
| 143 | * the upcoming system state (such as PCI_D3hot), and enable |
| 144 | * wakeup events as appropriate. |
| 145 | * |
| 146 | * FREEZE Quiesce operations so that a consistent image can be saved; |
| 147 | * but do NOT otherwise enter a low power device state, and do |
| 148 | * NOT emit system wakeup events. |
| 149 | * |
| 150 | * PRETHAW Quiesce as if for FREEZE; additionally, prepare for restoring |
| 151 | * the system from a snapshot taken after an earlier FREEZE. |
| 152 | * Some drivers will need to reset their hardware state instead |
| 153 | * of preserving it, to ensure that it's never mistaken for the |
| 154 | * state which that earlier snapshot had set up. |
| 155 | * |
| 156 | * A minimally power-aware driver treats all messages as SUSPEND, fully |
| 157 | * reinitializes its device during resume() -- whether or not it was reset |
| 158 | * during the suspend/resume cycle -- and can't issue wakeup events. |
| 159 | * |
| 160 | * More power-aware drivers may also use low power states at runtime as |
| 161 | * well as during system sleep states like PM_SUSPEND_STANDBY. They may |
| 162 | * be able to use wakeup events to exit from runtime low-power states, |
| 163 | * 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] | 164 | */ |
| 165 | |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 166 | #define PM_EVENT_ON 0 |
| 167 | #define PM_EVENT_FREEZE 1 |
| 168 | #define PM_EVENT_SUSPEND 2 |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 169 | #define PM_EVENT_PRETHAW 3 |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 170 | |
| 171 | #define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, }) |
David Brownell | 82bb67f | 2006-08-14 23:11:04 -0700 | [diff] [blame] | 172 | #define PMSG_PRETHAW ((struct pm_message){ .event = PM_EVENT_PRETHAW, }) |
Pavel Machek | ca078ba | 2005-09-03 15:56:57 -0700 | [diff] [blame] | 173 | #define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, }) |
| 174 | #define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, }) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | |
| 176 | struct dev_pm_info { |
| 177 | pm_message_t power_state; |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 178 | unsigned can_wakeup:1; |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 179 | #ifdef CONFIG_PM_SLEEP |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 180 | unsigned should_wakeup:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | struct list_head entry; |
| 182 | #endif |
| 183 | }; |
| 184 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | extern int device_power_down(pm_message_t state); |
| 186 | extern void device_power_up(void); |
| 187 | extern void device_resume(void); |
| 188 | |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 189 | #ifdef CONFIG_PM_SLEEP |
Pavel Machek | 620b032 | 2005-06-25 14:55:11 -0700 | [diff] [blame] | 190 | extern int device_suspend(pm_message_t state); |
Linus Torvalds | 7c8265f | 2006-06-24 14:50:29 -0700 | [diff] [blame] | 191 | extern int device_prepare_suspend(pm_message_t state); |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 192 | |
| 193 | #define device_set_wakeup_enable(dev,val) \ |
| 194 | ((dev)->power.should_wakeup = !!(val)) |
| 195 | #define device_may_wakeup(dev) \ |
| 196 | (device_can_wakeup(dev) && (dev)->power.should_wakeup) |
| 197 | |
Andrew Morton | 0266949 | 2006-03-23 01:38:34 -0800 | [diff] [blame] | 198 | extern void __suspend_report_result(const char *function, void *fn, int ret); |
| 199 | |
| 200 | #define suspend_report_result(fn, ret) \ |
| 201 | do { \ |
| 202 | __suspend_report_result(__FUNCTION__, fn, ret); \ |
| 203 | } while (0) |
Andrew Morton | 9a7834d | 2005-10-23 23:02:20 -0700 | [diff] [blame] | 204 | |
David Brownell | 075c177 | 2007-04-26 00:12:06 -0700 | [diff] [blame] | 205 | /* |
| 206 | * Platform hook to activate device wakeup capability, if that's not already |
| 207 | * handled by enable_irq_wake() etc. |
| 208 | * Returns zero on success, else negative errno |
| 209 | */ |
| 210 | extern int (*platform_enable_wakeup)(struct device *dev, int is_on); |
| 211 | |
| 212 | static inline int call_platform_enable_wakeup(struct device *dev, int is_on) |
| 213 | { |
| 214 | if (platform_enable_wakeup) |
| 215 | return (*platform_enable_wakeup)(dev, is_on); |
| 216 | return 0; |
| 217 | } |
| 218 | |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 219 | #else /* !CONFIG_PM_SLEEP */ |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 220 | |
Pavel Machek | 620b032 | 2005-06-25 14:55:11 -0700 | [diff] [blame] | 221 | static inline int device_suspend(pm_message_t state) |
| 222 | { |
| 223 | return 0; |
| 224 | } |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 225 | |
| 226 | #define device_set_wakeup_enable(dev,val) do{}while(0) |
| 227 | #define device_may_wakeup(dev) (0) |
| 228 | |
Andrew Morton | 0266949 | 2006-03-23 01:38:34 -0800 | [diff] [blame] | 229 | #define suspend_report_result(fn, ret) do { } while (0) |
| 230 | |
David Brownell | 075c177 | 2007-04-26 00:12:06 -0700 | [diff] [blame] | 231 | static inline int call_platform_enable_wakeup(struct device *dev, int is_on) |
| 232 | { |
David Rientjes | 14e38ac | 2007-04-30 15:09:56 -0700 | [diff] [blame] | 233 | return 0; |
David Brownell | 075c177 | 2007-04-26 00:12:06 -0700 | [diff] [blame] | 234 | } |
| 235 | |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 236 | #endif /* !CONFIG_PM_SLEEP */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
David Brownell | 0ac8524 | 2005-09-12 19:39:34 -0700 | [diff] [blame] | 238 | /* changes to device_may_wakeup take effect on the next pm state change. |
| 239 | * by default, devices should wakeup if they can. |
| 240 | */ |
| 241 | #define device_can_wakeup(dev) \ |
| 242 | ((dev)->power.can_wakeup) |
| 243 | #define device_init_wakeup(dev,val) \ |
| 244 | do { \ |
| 245 | device_can_wakeup(dev) = !!(val); \ |
| 246 | device_set_wakeup_enable(dev,val); \ |
| 247 | } while(0) |
| 248 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | #endif /* __KERNEL__ */ |
| 250 | |
| 251 | #endif /* _LINUX_PM_H */ |