blob: 87545e0f0b5814bdf6dc115165851b062a3df8b6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 Torvalds1da177e2005-04-16 15:20:36 -070026#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070096/* 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);
104
105typedef 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. Wysockia3d25c22007-05-09 02:33:18 -0700110#define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Johannes Berg2a9df492007-02-16 01:38:30 -0800112/**
113 * struct pm_ops - Callbacks for managing platform dependent suspend states.
114 * @valid: Callback to determine whether the given state can be entered.
Johannes Berg9684e512007-04-30 15:09:55 -0700115 * 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 Berg2a9df492007-02-16 01:38:30 -0800119 *
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 Berg2a9df492007-02-16 01:38:30 -0800128 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129struct pm_ops {
Shaohua Lieb9289e2005-10-30 15:00:01 -0800130 int (*valid)(suspend_state_t state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 int (*prepare)(suspend_state_t state);
132 int (*enter)(suspend_state_t state);
133 int (*finish)(suspend_state_t state);
134};
135
Johannes Berg2a9df492007-02-16 01:38:30 -0800136/**
137 * pm_set_ops - set platform dependent power management ops
138 * @pm_ops: The new power management operations to set.
139 */
140extern void pm_set_ops(struct pm_ops *pm_ops);
Alexey Starikovskiye2a5b422005-03-18 16:20:46 -0500141extern struct pm_ops *pm_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142extern int pm_suspend(suspend_state_t state);
143
Johannes Berge8c9c502007-04-30 15:09:54 -0700144extern int pm_valid_only_mem(suspend_state_t state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Johannes Berga53c46d2007-04-26 11:43:58 +0200146/**
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 */
153extern 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 */
162extern void arch_suspend_enable_irqs(void);
163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164/*
165 * Device power management
166 */
167
168struct device;
169
Pavel Machekca078ba2005-09-03 15:56:57 -0700170typedef struct pm_message {
171 int event;
172} pm_message_t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
174/*
David Brownell82bb67f2006-08-14 23:11:04 -0700175 * 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 Torvalds1da177e2005-04-16 15:20:36 -0700181 *
David Brownell82bb67f2006-08-14 23:11:04 -0700182 * 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 Torvalds1da177e2005-04-16 15:20:36 -0700221 */
222
Pavel Machekca078ba2005-09-03 15:56:57 -0700223#define PM_EVENT_ON 0
224#define PM_EVENT_FREEZE 1
225#define PM_EVENT_SUSPEND 2
David Brownell82bb67f2006-08-14 23:11:04 -0700226#define PM_EVENT_PRETHAW 3
Pavel Machekca078ba2005-09-03 15:56:57 -0700227
228#define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, })
David Brownell82bb67f2006-08-14 23:11:04 -0700229#define PMSG_PRETHAW ((struct pm_message){ .event = PM_EVENT_PRETHAW, })
Pavel Machekca078ba2005-09-03 15:56:57 -0700230#define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, })
231#define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233struct dev_pm_info {
234 pm_message_t power_state;
David Brownell0ac85242005-09-12 19:39:34 -0700235 unsigned can_wakeup:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236#ifdef CONFIG_PM
David Brownell0ac85242005-09-12 19:39:34 -0700237 unsigned should_wakeup:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 pm_message_t prev_state;
239 void * saved_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 struct device * pm_parent;
241 struct list_head entry;
242#endif
243};
244
245extern void device_pm_set_parent(struct device * dev, struct device * parent);
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247extern int device_power_down(pm_message_t state);
248extern void device_power_up(void);
249extern void device_resume(void);
250
Pavel Machek620b0322005-06-25 14:55:11 -0700251#ifdef CONFIG_PM
252extern int device_suspend(pm_message_t state);
Linus Torvalds7c8265f2006-06-24 14:50:29 -0700253extern int device_prepare_suspend(pm_message_t state);
David Brownell0ac85242005-09-12 19:39:34 -0700254
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 Morton9a7834d2005-10-23 23:02:20 -0700260extern int dpm_runtime_suspend(struct device *, pm_message_t);
261extern void dpm_runtime_resume(struct device *);
Andrew Morton02669492006-03-23 01:38:34 -0800262extern 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 Morton9a7834d2005-10-23 23:02:20 -0700268
David Brownell075c1772007-04-26 00:12:06 -0700269/*
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 */
274extern int (*platform_enable_wakeup)(struct device *dev, int is_on);
275
276static 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 Brownell0ac85242005-09-12 19:39:34 -0700283#else /* !CONFIG_PM */
284
Pavel Machek620b0322005-06-25 14:55:11 -0700285static inline int device_suspend(pm_message_t state)
286{
287 return 0;
288}
David Brownell0ac85242005-09-12 19:39:34 -0700289
290#define device_set_wakeup_enable(dev,val) do{}while(0)
291#define device_may_wakeup(dev) (0)
292
Andrew Morton9a7834d2005-10-23 23:02:20 -0700293static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state)
294{
295 return 0;
296}
297
298static inline void dpm_runtime_resume(struct device * dev)
299{
Andrew Morton9a7834d2005-10-23 23:02:20 -0700300}
301
Andrew Morton02669492006-03-23 01:38:34 -0800302#define suspend_report_result(fn, ret) do { } while (0)
303
David Brownell075c1772007-04-26 00:12:06 -0700304static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
305{
David Rientjes14e38ac2007-04-30 15:09:56 -0700306 return 0;
David Brownell075c1772007-04-26 00:12:06 -0700307}
308
Pavel Machek620b0322005-06-25 14:55:11 -0700309#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
David Brownell0ac85242005-09-12 19:39:34 -0700311/* 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 Torvalds1da177e2005-04-16 15:20:36 -0700322#endif /* __KERNEL__ */
323
324#endif /* _LINUX_PM_H */