pm.h revision 296699de6bdc717189a331ab6bbe90e05c94db06
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 */ 34typedef 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 */ 43typedef 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 */ 56enum 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 */ 75struct pm_dev; 76 77typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data); 78 79/* 80 * Dynamic device information 81 */ 82struct 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 */ 102extern void (*pm_idle)(void); 103extern void (*pm_power_off)(void); 104extern void (*pm_power_off_prepare)(void); 105 106typedef int __bitwise suspend_state_t; 107 108#define PM_SUSPEND_ON ((__force suspend_state_t) 0) 109#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 1) 110#define PM_SUSPEND_MEM ((__force suspend_state_t) 3) 111#define PM_SUSPEND_MAX ((__force suspend_state_t) 4) 112 113/** 114 * struct pm_ops - Callbacks for managing platform dependent system sleep 115 * states. 116 * 117 * @valid: Callback to determine if given system sleep state is supported by 118 * the platform. 119 * Valid (ie. supported) states are advertised in /sys/power/state. Note 120 * that it still may be impossible to enter given system sleep state if the 121 * conditions aren't right. 122 * There is the %pm_valid_only_mem function available that can be assigned 123 * to this if the platform only supports mem sleep. 124 * 125 * @set_target: Tell the platform which system sleep state is going to be 126 * entered. 127 * @set_target() is executed right prior to suspending devices. The 128 * information conveyed to the platform code by @set_target() should be 129 * disregarded by the platform as soon as @finish() is executed and if 130 * @prepare() fails. If @set_target() fails (ie. returns nonzero), 131 * @prepare(), @enter() and @finish() will not be called by the PM core. 132 * This callback is optional. However, if it is implemented, the argument 133 * passed to @prepare(), @enter() and @finish() is meaningless and should 134 * be ignored. 135 * 136 * @prepare: Prepare the platform for entering the system sleep state indicated 137 * by @set_target() or represented by the argument if @set_target() is not 138 * implemented. 139 * @prepare() is called right after devices have been suspended (ie. the 140 * appropriate .suspend() method has been executed for each device) and 141 * before the nonboot CPUs are disabled (it is executed with IRQs enabled). 142 * This callback is optional. It returns 0 on success or a negative 143 * error code otherwise, in which case the system cannot enter the desired 144 * sleep state (@enter() and @finish() will not be called in that case). 145 * 146 * @enter: Enter the system sleep state indicated by @set_target() or 147 * represented by the argument if @set_target() is not implemented. 148 * This callback is mandatory. It returns 0 on success or a negative 149 * error code otherwise, in which case the system cannot enter the desired 150 * sleep state. 151 * 152 * @finish: Called when the system has just left a sleep state, right after 153 * the nonboot CPUs have been enabled and before devices are resumed (it is 154 * executed with IRQs enabled). If @set_target() is not implemented, the 155 * argument represents the sleep state being left. 156 * This callback is optional, but should be implemented by the platforms 157 * that implement @prepare(). If implemented, it is always called after 158 * @enter() (even if @enter() fails). 159 */ 160struct pm_ops { 161 int (*valid)(suspend_state_t state); 162 int (*set_target)(suspend_state_t state); 163 int (*prepare)(suspend_state_t state); 164 int (*enter)(suspend_state_t state); 165 int (*finish)(suspend_state_t state); 166}; 167 168#ifdef CONFIG_SUSPEND 169extern struct pm_ops *pm_ops; 170 171/** 172 * pm_set_ops - set platform dependent power management ops 173 * @pm_ops: The new power management operations to set. 174 */ 175extern void pm_set_ops(struct pm_ops *pm_ops); 176extern int pm_valid_only_mem(suspend_state_t state); 177 178/** 179 * arch_suspend_disable_irqs - disable IRQs for suspend 180 * 181 * Disables IRQs (in the default case). This is a weak symbol in the common 182 * code and thus allows architectures to override it if more needs to be 183 * done. Not called for suspend to disk. 184 */ 185extern void arch_suspend_disable_irqs(void); 186 187/** 188 * arch_suspend_enable_irqs - enable IRQs after suspend 189 * 190 * Enables IRQs (in the default case). This is a weak symbol in the common 191 * code and thus allows architectures to override it if more needs to be 192 * done. Not called for suspend to disk. 193 */ 194extern void arch_suspend_enable_irqs(void); 195 196extern int pm_suspend(suspend_state_t state); 197#else /* !CONFIG_SUSPEND */ 198#define suspend_valid_only_mem NULL 199 200static inline void pm_set_ops(struct pm_ops *pm_ops) {} 201static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; } 202#endif /* !CONFIG_SUSPEND */ 203 204/* 205 * Device power management 206 */ 207 208struct device; 209 210typedef struct pm_message { 211 int event; 212} pm_message_t; 213 214/* 215 * Several driver power state transitions are externally visible, affecting 216 * the state of pending I/O queues and (for drivers that touch hardware) 217 * interrupts, wakeups, DMA, and other hardware state. There may also be 218 * internal transitions to various low power modes, which are transparent 219 * to the rest of the driver stack (such as a driver that's ON gating off 220 * clocks which are not in active use). 221 * 222 * One transition is triggered by resume(), after a suspend() call; the 223 * message is implicit: 224 * 225 * ON Driver starts working again, responding to hardware events 226 * and software requests. The hardware may have gone through 227 * a power-off reset, or it may have maintained state from the 228 * previous suspend() which the driver will rely on while 229 * resuming. On most platforms, there are no restrictions on 230 * availability of resources like clocks during resume(). 231 * 232 * Other transitions are triggered by messages sent using suspend(). All 233 * these transitions quiesce the driver, so that I/O queues are inactive. 234 * That commonly entails turning off IRQs and DMA; there may be rules 235 * about how to quiesce that are specific to the bus or the device's type. 236 * (For example, network drivers mark the link state.) Other details may 237 * differ according to the message: 238 * 239 * SUSPEND Quiesce, enter a low power device state appropriate for 240 * the upcoming system state (such as PCI_D3hot), and enable 241 * wakeup events as appropriate. 242 * 243 * FREEZE Quiesce operations so that a consistent image can be saved; 244 * but do NOT otherwise enter a low power device state, and do 245 * NOT emit system wakeup events. 246 * 247 * PRETHAW Quiesce as if for FREEZE; additionally, prepare for restoring 248 * the system from a snapshot taken after an earlier FREEZE. 249 * Some drivers will need to reset their hardware state instead 250 * of preserving it, to ensure that it's never mistaken for the 251 * state which that earlier snapshot had set up. 252 * 253 * A minimally power-aware driver treats all messages as SUSPEND, fully 254 * reinitializes its device during resume() -- whether or not it was reset 255 * during the suspend/resume cycle -- and can't issue wakeup events. 256 * 257 * More power-aware drivers may also use low power states at runtime as 258 * well as during system sleep states like PM_SUSPEND_STANDBY. They may 259 * be able to use wakeup events to exit from runtime low-power states, 260 * or from system low-power states such as standby or suspend-to-RAM. 261 */ 262 263#define PM_EVENT_ON 0 264#define PM_EVENT_FREEZE 1 265#define PM_EVENT_SUSPEND 2 266#define PM_EVENT_PRETHAW 3 267 268#define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, }) 269#define PMSG_PRETHAW ((struct pm_message){ .event = PM_EVENT_PRETHAW, }) 270#define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, }) 271#define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, }) 272 273struct dev_pm_info { 274 pm_message_t power_state; 275 unsigned can_wakeup:1; 276#ifdef CONFIG_PM_SLEEP 277 unsigned should_wakeup:1; 278 struct list_head entry; 279#endif 280}; 281 282extern int device_power_down(pm_message_t state); 283extern void device_power_up(void); 284extern void device_resume(void); 285 286#ifdef CONFIG_PM_SLEEP 287extern int device_suspend(pm_message_t state); 288extern int device_prepare_suspend(pm_message_t state); 289 290#define device_set_wakeup_enable(dev,val) \ 291 ((dev)->power.should_wakeup = !!(val)) 292#define device_may_wakeup(dev) \ 293 (device_can_wakeup(dev) && (dev)->power.should_wakeup) 294 295extern void __suspend_report_result(const char *function, void *fn, int ret); 296 297#define suspend_report_result(fn, ret) \ 298 do { \ 299 __suspend_report_result(__FUNCTION__, fn, ret); \ 300 } while (0) 301 302/* 303 * Platform hook to activate device wakeup capability, if that's not already 304 * handled by enable_irq_wake() etc. 305 * Returns zero on success, else negative errno 306 */ 307extern int (*platform_enable_wakeup)(struct device *dev, int is_on); 308 309static inline int call_platform_enable_wakeup(struct device *dev, int is_on) 310{ 311 if (platform_enable_wakeup) 312 return (*platform_enable_wakeup)(dev, is_on); 313 return 0; 314} 315 316#else /* !CONFIG_PM_SLEEP */ 317 318static inline int device_suspend(pm_message_t state) 319{ 320 return 0; 321} 322 323#define device_set_wakeup_enable(dev,val) do{}while(0) 324#define device_may_wakeup(dev) (0) 325 326#define suspend_report_result(fn, ret) do { } while (0) 327 328static inline int call_platform_enable_wakeup(struct device *dev, int is_on) 329{ 330 return 0; 331} 332 333#endif /* !CONFIG_PM_SLEEP */ 334 335/* changes to device_may_wakeup take effect on the next pm state change. 336 * by default, devices should wakeup if they can. 337 */ 338#define device_can_wakeup(dev) \ 339 ((dev)->power.can_wakeup) 340#define device_init_wakeup(dev,val) \ 341 do { \ 342 device_can_wakeup(dev) = !!(val); \ 343 device_set_wakeup_enable(dev,val); \ 344 } while(0) 345 346#endif /* __KERNEL__ */ 347 348#endif /* _LINUX_PM_H */ 349