X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=include%2Flinux%2Fpm.h;h=070394e846d008f2be06da51263677a63dc7e220;hb=refs%2Fheads%2Fvserver;hp=7bfd2d43963e09989fa2a692e556e1c04343546b;hpb=c7b5ebbddf7bcd3651947760f423e3783bbe6573;p=linux-2.6.git diff --git a/include/linux/pm.h b/include/linux/pm.h index 7bfd2d439..070394e84 100644 --- a/include/linux/pm.h +++ b/include/linux/pm.h @@ -23,49 +23,32 @@ #ifdef __KERNEL__ -#include #include #include /* - * Power management requests + * Power management requests... these are passed to pm_send_all() and friends. + * + * these functions are old and deprecated, see below. */ -enum -{ - PM_SUSPEND, /* enter D1-D3 */ - PM_RESUME, /* enter D0 */ - - PM_SAVE_STATE, /* save device's state */ - - /* enable wake-on */ - PM_SET_WAKEUP, - - /* bus resource management */ - PM_GET_RESOURCES, - PM_SET_RESOURCES, +typedef int __bitwise pm_request_t; - /* base station management */ - PM_EJECT, - PM_LOCK, -}; +#define PM_SUSPEND ((__force pm_request_t) 1) /* enter D1-D3 */ +#define PM_RESUME ((__force pm_request_t) 2) /* enter D0 */ -typedef int pm_request_t; /* - * Device types + * Device types... these are passed to pm_register */ -enum -{ - PM_UNKNOWN_DEV = 0, /* generic */ - PM_SYS_DEV, /* system device (fan, KB controller, ...) */ - PM_PCI_DEV, /* PCI device */ - PM_USB_DEV, /* USB device */ - PM_SCSI_DEV, /* SCSI device */ - PM_ISA_DEV, /* ISA device */ - PM_MTD_DEV, /* Memory Technology Device */ -}; +typedef int __bitwise pm_dev_t; -typedef int pm_dev_t; +#define PM_UNKNOWN_DEV ((__force pm_dev_t) 0) /* generic */ +#define PM_SYS_DEV ((__force pm_dev_t) 1) /* system device (fan, KB controller, ...) */ +#define PM_PCI_DEV ((__force pm_dev_t) 2) /* PCI device */ +#define PM_USB_DEV ((__force pm_dev_t) 3) /* USB device */ +#define PM_SCSI_DEV ((__force pm_dev_t) 4) /* SCSI device */ +#define PM_ISA_DEV ((__force pm_dev_t) 5) /* ISA device */ +#define PM_MTD_DEV ((__force pm_dev_t) 6) /* Memory Technology Device */ /* * System device hardware ID (PnP) values @@ -110,82 +93,8 @@ struct pm_dev struct list_head entry; }; -#ifdef CONFIG_PM - -extern int pm_active; - -#define PM_IS_ACTIVE() (pm_active != 0) - -/* - * Register a device with power management - */ -struct pm_dev *pm_register(pm_dev_t type, - unsigned long id, - pm_callback callback); - -/* - * Unregister a device with power management - */ -void pm_unregister(struct pm_dev *dev); - -/* - * Unregister all devices with matching callback - */ -void pm_unregister_all(pm_callback callback); - -/* - * Send a request to a single device - */ -int pm_send(struct pm_dev *dev, pm_request_t rqst, void *data); - -/* - * Send a request to all devices - */ -int pm_send_all(pm_request_t rqst, void *data); - -/* - * Find a device - */ -struct pm_dev *pm_find(pm_dev_t type, struct pm_dev *from); - -static inline void pm_access(struct pm_dev *dev) {} -static inline void pm_dev_idle(struct pm_dev *dev) {} - -#else /* CONFIG_PM */ - -#define PM_IS_ACTIVE() 0 - -static inline struct pm_dev *pm_register(pm_dev_t type, - unsigned long id, - pm_callback callback) -{ - return NULL; -} - -static inline void pm_unregister(struct pm_dev *dev) {} - -static inline void pm_unregister_all(pm_callback callback) {} - -static inline int pm_send(struct pm_dev *dev, pm_request_t rqst, void *data) -{ - return 0; -} - -static inline int pm_send_all(pm_request_t rqst, void *data) -{ - return 0; -} - -static inline struct pm_dev *pm_find(pm_dev_t type, struct pm_dev *from) -{ - return 0; -} - -static inline void pm_access(struct pm_dev *dev) {} -static inline void pm_dev_idle(struct pm_dev *dev) {} - -#endif /* CONFIG_PM */ - +/* Functions above this comment are list-based old-style power + * managment. Please avoid using them. */ /* * Callbacks for platform drivers to implement. @@ -193,34 +102,35 @@ static inline void pm_dev_idle(struct pm_dev *dev) {} extern void (*pm_idle)(void); extern void (*pm_power_off)(void); -enum { - PM_SUSPEND_ON = 0, - PM_SUSPEND_STANDBY = 1, - /* NOTE: PM_SUSPEND_MEM == PCI_D3hot */ - PM_SUSPEND_MEM = 3, - PM_SUSPEND_DISK = 4, - PM_SUSPEND_MAX = 5, -}; +typedef int __bitwise suspend_state_t; -enum { - PM_DISK_FIRMWARE = 1, - PM_DISK_PLATFORM, - PM_DISK_SHUTDOWN, - PM_DISK_REBOOT, - PM_DISK_MAX, -}; +#define PM_SUSPEND_ON ((__force suspend_state_t) 0) +#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 1) +#define PM_SUSPEND_MEM ((__force suspend_state_t) 3) +#define PM_SUSPEND_DISK ((__force suspend_state_t) 4) +#define PM_SUSPEND_MAX ((__force suspend_state_t) 5) + +typedef int __bitwise suspend_disk_method_t; +#define PM_DISK_FIRMWARE ((__force suspend_disk_method_t) 1) +#define PM_DISK_PLATFORM ((__force suspend_disk_method_t) 2) +#define PM_DISK_SHUTDOWN ((__force suspend_disk_method_t) 3) +#define PM_DISK_REBOOT ((__force suspend_disk_method_t) 4) +#define PM_DISK_TEST ((__force suspend_disk_method_t) 5) +#define PM_DISK_TESTPROC ((__force suspend_disk_method_t) 6) +#define PM_DISK_MAX ((__force suspend_disk_method_t) 7) struct pm_ops { - u32 pm_disk_mode; - int (*prepare)(u32 state); - int (*enter)(u32 state); - int (*finish)(u32 state); + suspend_disk_method_t pm_disk_mode; + int (*valid)(suspend_state_t state); + int (*prepare)(suspend_state_t state); + int (*enter)(suspend_state_t state); + int (*finish)(suspend_state_t state); }; extern void pm_set_ops(struct pm_ops *); - -extern int pm_suspend(u32 state); +extern struct pm_ops *pm_ops; +extern int pm_suspend(suspend_state_t state); /* @@ -229,12 +139,76 @@ extern int pm_suspend(u32 state); struct device; +typedef struct pm_message { + int event; +} pm_message_t; + +/* + * Several driver power state transitions are externally visible, affecting + * the state of pending I/O queues and (for drivers that touch hardware) + * interrupts, wakeups, DMA, and other hardware state. There may also be + * internal transitions to various low power modes, which are transparent + * to the rest of the driver stack (such as a driver that's ON gating off + * clocks which are not in active use). + * + * One transition is triggered by resume(), after a suspend() call; the + * message is implicit: + * + * ON Driver starts working again, responding to hardware events + * and software requests. The hardware may have gone through + * a power-off reset, or it may have maintained state from the + * previous suspend() which the driver will rely on while + * resuming. On most platforms, there are no restrictions on + * availability of resources like clocks during resume(). + * + * Other transitions are triggered by messages sent using suspend(). All + * these transitions quiesce the driver, so that I/O queues are inactive. + * That commonly entails turning off IRQs and DMA; there may be rules + * about how to quiesce that are specific to the bus or the device's type. + * (For example, network drivers mark the link state.) Other details may + * differ according to the message: + * + * SUSPEND Quiesce, enter a low power device state appropriate for + * the upcoming system state (such as PCI_D3hot), and enable + * wakeup events as appropriate. + * + * FREEZE Quiesce operations so that a consistent image can be saved; + * but do NOT otherwise enter a low power device state, and do + * NOT emit system wakeup events. + * + * PRETHAW Quiesce as if for FREEZE; additionally, prepare for restoring + * the system from a snapshot taken after an earlier FREEZE. + * Some drivers will need to reset their hardware state instead + * of preserving it, to ensure that it's never mistaken for the + * state which that earlier snapshot had set up. + * + * A minimally power-aware driver treats all messages as SUSPEND, fully + * reinitializes its device during resume() -- whether or not it was reset + * during the suspend/resume cycle -- and can't issue wakeup events. + * + * More power-aware drivers may also use low power states at runtime as + * well as during system sleep states like PM_SUSPEND_STANDBY. They may + * be able to use wakeup events to exit from runtime low-power states, + * or from system low-power states such as standby or suspend-to-RAM. + */ + +#define PM_EVENT_ON 0 +#define PM_EVENT_FREEZE 1 +#define PM_EVENT_SUSPEND 2 +#define PM_EVENT_PRETHAW 3 + +#define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, }) +#define PMSG_PRETHAW ((struct pm_message){ .event = PM_EVENT_PRETHAW, }) +#define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, }) +#define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, }) + struct dev_pm_info { - u32 power_state; + pm_message_t power_state; + unsigned can_wakeup:1; #ifdef CONFIG_PM - u32 prev_state; - u8 * saved_state; - atomic_t pm_users; + unsigned should_wakeup:1; + pm_message_t prev_state; + void * saved_state; struct device * pm_parent; struct list_head entry; #endif @@ -242,11 +216,63 @@ struct dev_pm_info { extern void device_pm_set_parent(struct device * dev, struct device * parent); -extern int device_suspend(u32 state); -extern int device_power_down(u32 state); +extern int device_power_down(pm_message_t state); extern void device_power_up(void); extern void device_resume(void); +#ifdef CONFIG_PM +extern suspend_disk_method_t pm_disk_mode; + +extern int device_suspend(pm_message_t state); +extern int device_prepare_suspend(pm_message_t state); + +#define device_set_wakeup_enable(dev,val) \ + ((dev)->power.should_wakeup = !!(val)) +#define device_may_wakeup(dev) \ + (device_can_wakeup(dev) && (dev)->power.should_wakeup) + +extern int dpm_runtime_suspend(struct device *, pm_message_t); +extern void dpm_runtime_resume(struct device *); +extern void __suspend_report_result(const char *function, void *fn, int ret); + +#define suspend_report_result(fn, ret) \ + do { \ + __suspend_report_result(__FUNCTION__, fn, ret); \ + } while (0) + +#else /* !CONFIG_PM */ + +static inline int device_suspend(pm_message_t state) +{ + return 0; +} + +#define device_set_wakeup_enable(dev,val) do{}while(0) +#define device_may_wakeup(dev) (0) + +static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state) +{ + return 0; +} + +static inline void dpm_runtime_resume(struct device * dev) +{ +} + +#define suspend_report_result(fn, ret) do { } while (0) + +#endif + +/* changes to device_may_wakeup take effect on the next pm state change. + * by default, devices should wakeup if they can. + */ +#define device_can_wakeup(dev) \ + ((dev)->power.can_wakeup) +#define device_init_wakeup(dev,val) \ + do { \ + device_can_wakeup(dev) = !!(val); \ + device_set_wakeup_enable(dev,val); \ + } while(0) #endif /* __KERNEL__ */