blob: c79edcb8e842101b7e20807d6f2ee8b224dfe9e1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * sleep.c - ACPI sleep support.
3 *
Alexey Starikovskiye2a5b422005-03-18 16:20:46 -05004 * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com>
6 * Copyright (c) 2000-2003 Patrick Mochel
7 * Copyright (c) 2003 Open Source Development Lab
8 *
9 * This file is released under the GPLv2.
10 *
11 */
12
13#include <linux/delay.h>
14#include <linux/irq.h>
15#include <linux/dmi.h>
16#include <linux/device.h>
17#include <linux/suspend.h>
Alexey Starikovskiyf216cc32007-09-20 21:32:35 +040018
19#include <asm/io.h>
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <acpi/acpi_bus.h>
22#include <acpi/acpi_drivers.h>
23#include "sleep.h"
24
25u8 sleep_states[ACPI_S_STATE_COUNT];
26
Rafael J. Wysocki296699d2007-07-29 23:27:18 +020027static u32 acpi_target_sleep_state = ACPI_STATE_S0;
28
Alexey Starikovskiy2f3f22262007-09-24 14:33:21 +020029int acpi_sleep_prepare(u32 acpi_state)
30{
31#ifdef CONFIG_ACPI_SLEEP
32 /* do we have a wakeup address for S2 and S3? */
33 if (acpi_state == ACPI_STATE_S3) {
34 if (!acpi_wakeup_address) {
35 return -EFAULT;
36 }
37 acpi_set_firmware_waking_vector((acpi_physical_address)
38 virt_to_phys((void *)
39 acpi_wakeup_address));
40
41 }
42 ACPI_FLUSH_CPU_CACHE();
43 acpi_enable_wakeup_device_prep(acpi_state);
44#endif
45 acpi_gpe_sleep_prepare(acpi_state);
46 acpi_enter_sleep_state_prep(acpi_state);
47 return 0;
48}
49
Rafael J. Wysocki296699d2007-07-29 23:27:18 +020050#ifdef CONFIG_SUSPEND
Linus Torvalds1da177e2005-04-16 15:20:36 -070051static struct pm_ops acpi_pm_ops;
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053extern void do_suspend_lowlevel(void);
54
55static u32 acpi_suspend_states[] = {
Alexey Starikovskiye2a5b422005-03-18 16:20:46 -050056 [PM_SUSPEND_ON] = ACPI_STATE_S0,
57 [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
58 [PM_SUSPEND_MEM] = ACPI_STATE_S3,
Alexey Starikovskiye2a5b422005-03-18 16:20:46 -050059 [PM_SUSPEND_MAX] = ACPI_STATE_S5
Linus Torvalds1da177e2005-04-16 15:20:36 -070060};
61
62static int init_8259A_after_S1;
63
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +020064/**
65 * acpi_pm_set_target - Set the target system sleep state to the state
66 * associated with given @pm_state, if supported.
67 */
68
69static int acpi_pm_set_target(suspend_state_t pm_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
71 u32 acpi_state = acpi_suspend_states[pm_state];
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +020072 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +020074 if (sleep_states[acpi_state]) {
75 acpi_target_sleep_state = acpi_state;
76 } else {
77 printk(KERN_ERR "ACPI does not support this state: %d\n",
78 pm_state);
79 error = -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 }
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +020081 return error;
82}
83
84/**
85 * acpi_pm_prepare - Do preliminary suspend work.
86 * @pm_state: ignored
87 *
88 * If necessary, set the firmware waking vector and do arch-specific
89 * nastiness to get the wakeup code to the waking vector.
90 */
91
92static int acpi_pm_prepare(suspend_state_t pm_state)
93{
94 int error = acpi_sleep_prepare(acpi_target_sleep_state);
95
96 if (error)
97 acpi_target_sleep_state = ACPI_STATE_S0;
98
99 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100}
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102/**
103 * acpi_pm_enter - Actually enter a sleep state.
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200104 * @pm_state: ignored
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 *
Rafael J. Wysocki50ad1472007-07-24 11:58:39 +0200106 * Flush caches and go to sleep. For STR we have to call arch-specific
107 * assembly, which in turn call acpi_enter_sleep_state().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 * It's unfortunate, but it works. Please fix if you're feeling frisky.
109 */
110
111static int acpi_pm_enter(suspend_state_t pm_state)
112{
113 acpi_status status = AE_OK;
114 unsigned long flags = 0;
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200115 u32 acpi_state = acpi_target_sleep_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117 ACPI_FLUSH_CPU_CACHE();
118
119 /* Do arch specific saving of state. */
Rafael J. Wysocki50ad1472007-07-24 11:58:39 +0200120 if (acpi_state == ACPI_STATE_S3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 int error = acpi_save_state_mem();
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200122
123 if (error) {
124 acpi_target_sleep_state = ACPI_STATE_S0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 return error;
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200126 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 }
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 local_irq_save(flags);
130 acpi_enable_wakeup_device(acpi_state);
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200131 switch (acpi_state) {
132 case ACPI_STATE_S1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 barrier();
134 status = acpi_enter_sleep_state(acpi_state);
135 break;
136
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200137 case ACPI_STATE_S3:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 do_suspend_lowlevel();
139 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 }
Arnaud Patard872d83d2006-04-27 05:25:00 -0400141
142 /* ACPI 3.0 specs (P62) says that it's the responsabilty
143 * of the OSPM to clear the status bit [ implying that the
144 * POWER_BUTTON event should not reach userspace ]
145 */
146 if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3))
147 acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 local_irq_restore(flags);
150 printk(KERN_DEBUG "Back to C!\n");
151
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200152 /* restore processor state */
Rafael J. Wysocki50ad1472007-07-24 11:58:39 +0200153 if (acpi_state == ACPI_STATE_S3)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 acpi_restore_state_mem();
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
157}
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159/**
160 * acpi_pm_finish - Finish up suspend sequence.
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200161 * @pm_state: ignored
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 *
163 * This is called after we wake back up (or if entering the sleep state
164 * failed).
165 */
166
167static int acpi_pm_finish(suspend_state_t pm_state)
168{
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200169 u32 acpi_state = acpi_target_sleep_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 acpi_leave_sleep_state(acpi_state);
172 acpi_disable_wakeup_device(acpi_state);
173
174 /* reset firmware waking vector */
175 acpi_set_firmware_waking_vector((acpi_physical_address) 0);
176
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200177 acpi_target_sleep_state = ACPI_STATE_S0;
178
Len Browne8b2fd02007-07-24 22:26:33 -0400179#ifdef CONFIG_X86
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 if (init_8259A_after_S1) {
181 printk("Broken toshiba laptop -> kicking interrupts\n");
182 init_8259A(0);
183 }
Len Browne8b2fd02007-07-24 22:26:33 -0400184#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 return 0;
186}
187
Shaohua Lieb9289e2005-10-30 15:00:01 -0800188static int acpi_pm_state_valid(suspend_state_t pm_state)
189{
Johannes Berge8c9c502007-04-30 15:09:54 -0700190 u32 acpi_state;
Shaohua Lieb9289e2005-10-30 15:00:01 -0800191
Johannes Berge8c9c502007-04-30 15:09:54 -0700192 switch (pm_state) {
193 case PM_SUSPEND_ON:
194 case PM_SUSPEND_STANDBY:
195 case PM_SUSPEND_MEM:
196 acpi_state = acpi_suspend_states[pm_state];
197
198 return sleep_states[acpi_state];
199 default:
200 return 0;
201 }
Shaohua Lieb9289e2005-10-30 15:00:01 -0800202}
203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204static struct pm_ops acpi_pm_ops = {
Shaohua Lieb9289e2005-10-30 15:00:01 -0800205 .valid = acpi_pm_state_valid,
Rafael J. Wysockie9b3aba2007-07-17 22:40:06 +0200206 .set_target = acpi_pm_set_target,
Alexey Starikovskiye2a5b422005-03-18 16:20:46 -0500207 .prepare = acpi_pm_prepare,
208 .enter = acpi_pm_enter,
209 .finish = acpi_pm_finish,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210};
211
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200212/*
213 * Toshiba fails to preserve interrupts over S1, reinitialization
214 * of 8259 is needed after S1 resume.
215 */
216static int __init init_ints_after_s1(struct dmi_system_id *d)
217{
218 printk(KERN_WARNING "%s with broken S1 detected.\n", d->ident);
219 init_8259A_after_S1 = 1;
220 return 0;
221}
222
223static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
224 {
225 .callback = init_ints_after_s1,
226 .ident = "Toshiba Satellite 4030cdt",
227 .matches = {DMI_MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"),},
228 },
229 {},
230};
231#endif /* CONFIG_SUSPEND */
232
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200233#ifdef CONFIG_HIBERNATION
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700234static int acpi_hibernation_prepare(void)
235{
236 return acpi_sleep_prepare(ACPI_STATE_S4);
237}
238
239static int acpi_hibernation_enter(void)
240{
241 acpi_status status = AE_OK;
242 unsigned long flags = 0;
243
244 ACPI_FLUSH_CPU_CACHE();
245
246 local_irq_save(flags);
247 acpi_enable_wakeup_device(ACPI_STATE_S4);
248 /* This shouldn't return. If it returns, we have a problem */
249 status = acpi_enter_sleep_state(ACPI_STATE_S4);
250 local_irq_restore(flags);
251
252 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
253}
254
255static void acpi_hibernation_finish(void)
256{
257 acpi_leave_sleep_state(ACPI_STATE_S4);
258 acpi_disable_wakeup_device(ACPI_STATE_S4);
259
260 /* reset firmware waking vector */
261 acpi_set_firmware_waking_vector((acpi_physical_address) 0);
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700262}
263
Rafael J. Wysockia634cc12007-07-19 01:47:30 -0700264static int acpi_hibernation_pre_restore(void)
265{
266 acpi_status status;
267
268 status = acpi_hw_disable_all_gpes();
269
270 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
271}
272
273static void acpi_hibernation_restore_cleanup(void)
274{
275 acpi_hw_enable_all_runtime_gpes();
276}
277
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700278static struct hibernation_ops acpi_hibernation_ops = {
279 .prepare = acpi_hibernation_prepare,
280 .enter = acpi_hibernation_enter,
281 .finish = acpi_hibernation_finish,
Rafael J. Wysockia634cc12007-07-19 01:47:30 -0700282 .pre_restore = acpi_hibernation_pre_restore,
283 .restore_cleanup = acpi_hibernation_restore_cleanup,
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700284};
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200285#endif /* CONFIG_HIBERNATION */
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700286
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200287int acpi_suspend(u32 acpi_state)
288{
289 suspend_state_t states[] = {
290 [1] = PM_SUSPEND_STANDBY,
291 [3] = PM_SUSPEND_MEM,
292 [5] = PM_SUSPEND_MAX
293 };
294
295 if (acpi_state < 6 && states[acpi_state])
296 return pm_suspend(states[acpi_state]);
297 if (acpi_state == 4)
298 return hibernate();
299 return -EINVAL;
300}
301
Shaohua Lifd4aff12007-07-17 22:40:25 +0200302/**
303 * acpi_pm_device_sleep_state - return preferred power state of ACPI device
304 * in the system sleep state given by %acpi_target_sleep_state
305 * @dev: device to examine
306 * @wake: if set, the device should be able to wake up the system
307 * @d_min_p: used to store the upper limit of allowed states range
308 * Return value: preferred power state of the device on success, -ENODEV on
309 * failure (ie. if there's no 'struct acpi_device' for @dev)
310 *
311 * Find the lowest power (highest number) ACPI device power state that
312 * device @dev can be in while the system is in the sleep state represented
313 * by %acpi_target_sleep_state. If @wake is nonzero, the device should be
314 * able to wake up the system from this sleep state. If @d_min_p is set,
315 * the highest power (lowest number) device power state of @dev allowed
316 * in this system sleep state is stored at the location pointed to by it.
317 *
318 * The caller must ensure that @dev is valid before using this function.
319 * The caller is also responsible for figuring out if the device is
320 * supposed to be able to wake up the system and passing this information
321 * via @wake.
322 */
323
324int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
325{
326 acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
327 struct acpi_device *adev;
328 char acpi_method[] = "_SxD";
329 unsigned long d_min, d_max;
330
331 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
Shaohua Liead77592007-08-23 15:01:13 +0800332 printk(KERN_DEBUG "ACPI handle has no context!\n");
Shaohua Lifd4aff12007-07-17 22:40:25 +0200333 return -ENODEV;
334 }
335
336 acpi_method[2] = '0' + acpi_target_sleep_state;
337 /*
338 * If the sleep state is S0, we will return D3, but if the device has
339 * _S0W, we will use the value from _S0W
340 */
341 d_min = ACPI_STATE_D0;
342 d_max = ACPI_STATE_D3;
343
344 /*
345 * If present, _SxD methods return the minimum D-state (highest power
346 * state) we can use for the corresponding S-states. Otherwise, the
347 * minimum D-state is D0 (ACPI 3.x).
348 *
349 * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
350 * provided -- that's our fault recovery, we ignore retval.
351 */
352 if (acpi_target_sleep_state > ACPI_STATE_S0)
353 acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);
354
355 /*
356 * If _PRW says we can wake up the system from the target sleep state,
357 * the D-state returned by _SxD is sufficient for that (we assume a
358 * wakeup-aware driver if wake is set). Still, if _SxW exists
359 * (ACPI 3.x), it should return the maximum (lowest power) D-state that
360 * can wake the system. _S0W may be valid, too.
361 */
362 if (acpi_target_sleep_state == ACPI_STATE_S0 ||
363 (wake && adev->wakeup.state.enabled &&
364 adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
365 acpi_method[3] = 'W';
366 acpi_evaluate_integer(handle, acpi_method, NULL, &d_max);
367 /* Sanity check */
368 if (d_max < d_min)
369 d_min = d_max;
370 }
371
372 if (d_min_p)
373 *d_min_p = d_min;
374 return d_max;
375}
376
Alexey Starikovskiyf216cc32007-09-20 21:32:35 +0400377static void acpi_power_off_prepare(void)
378{
379 /* Prepare to power off the system */
380 acpi_sleep_prepare(ACPI_STATE_S5);
381}
382
383static void acpi_power_off(void)
384{
385 /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
386 printk("%s called\n", __FUNCTION__);
387 local_irq_disable();
388 acpi_enter_sleep_state(ACPI_STATE_S5);
389}
390
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500391int __init acpi_sleep_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200393 acpi_status status;
394 u8 type_a, type_b;
395#ifdef CONFIG_SUSPEND
Alexey Starikovskiye2a5b422005-03-18 16:20:46 -0500396 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398 dmi_check_system(acpisleep_dmi_table);
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200399#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 if (acpi_disabled)
402 return 0;
403
Frans Pop5a50fe72007-09-20 22:27:44 +0200404 sleep_states[ACPI_STATE_S0] = 1;
405 printk(KERN_INFO PREFIX "(supports S0");
406
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200407#ifdef CONFIG_SUSPEND
Frans Pop5a50fe72007-09-20 22:27:44 +0200408 for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 status = acpi_get_sleep_type_data(i, &type_a, &type_b);
410 if (ACPI_SUCCESS(status)) {
411 sleep_states[i] = 1;
412 printk(" S%d", i);
413 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
416 pm_set_ops(&acpi_pm_ops);
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200417#endif
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700418
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200419#ifdef CONFIG_HIBERNATION
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200420 status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
421 if (ACPI_SUCCESS(status)) {
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700422 hibernation_set_ops(&acpi_hibernation_ops);
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200423 sleep_states[ACPI_STATE_S4] = 1;
Alexey Starikovskiyf216cc32007-09-20 21:32:35 +0400424 printk(" S4");
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200425 }
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700426#endif
Alexey Starikovskiyf216cc32007-09-20 21:32:35 +0400427 status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
428 if (ACPI_SUCCESS(status)) {
429 sleep_states[ACPI_STATE_S5] = 1;
430 printk(" S5");
431 pm_power_off_prepare = acpi_power_off_prepare;
432 pm_power_off = acpi_power_off;
433 }
434 printk(")\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 return 0;
436}