pm.h revision d288e47c471e1090e80c62ad95882fafbf3f499d 
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#include <asm/errno.h>
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 */
35typedef 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 */
44typedef 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 */
57enum
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 */
76struct pm_dev;
77
78typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data);
79
80/*
81 * Dynamic device information
82 */
83struct 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
97/* Functions above this comment are list-based old-style power
98 * management. Please avoid using them.  */
99
100/*
101 * Callbacks for platform drivers to implement.
102 */
103extern void (*pm_idle)(void);
104extern void (*pm_power_off)(void);
105extern void (*pm_power_off_prepare)(void);
106
107/*
108 * Device power management
109 */
110
111struct device;
112
113typedef struct pm_message {
114	int event;
115} pm_message_t;
116
117/*
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).
124 *
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 * HIBERNATE	Enter a low power device state appropriate for the hibernation
147 * 		state (eg. ACPI S4) and enable wakeup events as appropriate.
148 *
149 * FREEZE	Quiesce operations so that a consistent image can be saved;
150 * 		but do NOT otherwise enter a low power device state, and do
151 * 		NOT emit system wakeup events.
152 *
153 * PRETHAW	Quiesce as if for FREEZE; additionally, prepare for restoring
154 * 		the system from a snapshot taken after an earlier FREEZE.
155 * 		Some drivers will need to reset their hardware state instead
156 * 		of preserving it, to ensure that it's never mistaken for the
157 * 		state which that earlier snapshot had set up.
158 *
159 * A minimally power-aware driver treats all messages as SUSPEND, fully
160 * reinitializes its device during resume() -- whether or not it was reset
161 * during the suspend/resume cycle -- and can't issue wakeup events.
162 *
163 * More power-aware drivers may also use low power states at runtime as
164 * well as during system sleep states like PM_SUSPEND_STANDBY.  They may
165 * be able to use wakeup events to exit from runtime low-power states,
166 * or from system low-power states such as standby or suspend-to-RAM.
167 */
168
169#define PM_EVENT_ON 0
170#define PM_EVENT_FREEZE 1
171#define PM_EVENT_SUSPEND 2
172#define PM_EVENT_HIBERNATE 4
173#define PM_EVENT_PRETHAW 8
174
175#define PM_EVENT_SLEEP	(PM_EVENT_SUSPEND | PM_EVENT_HIBERNATE)
176
177#define PMSG_FREEZE	((struct pm_message){ .event = PM_EVENT_FREEZE, })
178#define PMSG_PRETHAW	((struct pm_message){ .event = PM_EVENT_PRETHAW, })
179#define PMSG_SUSPEND	((struct pm_message){ .event = PM_EVENT_SUSPEND, })
180#define PMSG_HIBERNATE	((struct pm_message){ .event = PM_EVENT_HIBERNATE, })
181#define PMSG_ON		((struct pm_message){ .event = PM_EVENT_ON, })
182
183struct dev_pm_info {
184	pm_message_t		power_state;
185	unsigned		can_wakeup:1;
186	unsigned		should_wakeup:1;
187	bool			sleeping:1;	/* Owned by the PM core */
188#ifdef	CONFIG_PM_SLEEP
189	struct list_head	entry;
190#endif
191};
192
193extern int device_power_down(pm_message_t state);
194extern void device_power_up(void);
195extern void device_resume(void);
196
197#ifdef CONFIG_PM_SLEEP
198extern int device_suspend(pm_message_t state);
199extern int device_prepare_suspend(pm_message_t state);
200
201extern void __suspend_report_result(const char *function, void *fn, int ret);
202
203#define suspend_report_result(fn, ret)					\
204	do {								\
205		__suspend_report_result(__FUNCTION__, fn, ret);		\
206	} while (0)
207
208#else /* !CONFIG_PM_SLEEP */
209
210static inline int device_suspend(pm_message_t state)
211{
212	return 0;
213}
214
215#define suspend_report_result(fn, ret) do { } while (0)
216
217#endif /* !CONFIG_PM_SLEEP */
218
219#ifdef CONFIG_PM
220
221#define device_set_wakeup_enable(dev,val) \
222	((dev)->power.should_wakeup = !!(val))
223#define device_may_wakeup(dev) \
224	(device_can_wakeup(dev) && (dev)->power.should_wakeup)
225
226/*
227 * Platform hook to activate device wakeup capability, if that's not already
228 * handled by enable_irq_wake() etc.
229 * Returns zero on success, else negative errno
230 */
231extern int (*platform_enable_wakeup)(struct device *dev, int is_on);
232
233static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
234{
235	if (platform_enable_wakeup)
236		return (*platform_enable_wakeup)(dev, is_on);
237	return 0;
238}
239
240#else /* !CONFIG_PM */
241
242#define device_set_wakeup_enable(dev,val)	do{}while(0)
243#define device_may_wakeup(dev)			(0)
244
245static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
246{
247	return 0;
248}
249
250#endif /* !CONFIG_PM */
251
252/* changes to device_may_wakeup take effect on the next pm state change.
253 * by default, devices should wakeup if they can.
254 */
255#define device_can_wakeup(dev) \
256	((dev)->power.can_wakeup)
257#define device_init_wakeup(dev,val) \
258	do { \
259		device_can_wakeup(dev) = !!(val); \
260		device_set_wakeup_enable(dev,val); \
261	} while(0)
262
263/*
264 * Global Power Management flags
265 * Used to keep APM and ACPI from both being active
266 */
267extern unsigned int	pm_flags;
268
269#define PM_APM	1
270#define PM_ACPI	2
271
272#endif /* __KERNEL__ */
273
274#endif /* _LINUX_PM_H */
275