Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 82911fe1988fadfc9c01673202cbc411aa803244

Authored by Rafael J. Wysocki
1 parent c41b93fb85
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

ACPI / PM: acpi_suspend_enter() need not switch interrupts off 

The function acpi_suspend_enter() is always called with interrupts
off, so it doesn't need to switch them off and on.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>

Showing 1 changed file with 0 additions and 3 deletions Inline Diff

drivers/acpi/sleep.c
Diff comments   View file @ 82911fe
1 /* 1 /*
2 * sleep.c - ACPI sleep support. 2 * sleep.c - ACPI sleep support.
3 * 3 *
4 * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com> 4 * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
5 * Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com> 5 * Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com>
6 * Copyright (c) 2000-2003 Patrick Mochel 6 * Copyright (c) 2000-2003 Patrick Mochel
7 * Copyright (c) 2003 Open Source Development Lab 7 * Copyright (c) 2003 Open Source Development Lab
8 * 8 *
9 * This file is released under the GPLv2. 9 * This file is released under the GPLv2.
10 * 10 *
11 */ 11 */
12 12
13 #include <linux/delay.h> 13 #include <linux/delay.h>
14 #include <linux/irq.h> 14 #include <linux/irq.h>
15 #include <linux/dmi.h> 15 #include <linux/dmi.h>
16 #include <linux/device.h> 16 #include <linux/device.h>
17 #include <linux/suspend.h> 17 #include <linux/suspend.h>
18 #include <linux/reboot.h> 18 #include <linux/reboot.h>
19 19
20 #include <asm/io.h> 20 #include <asm/io.h>
21 21
22 #include <acpi/acpi_bus.h> 22 #include <acpi/acpi_bus.h>
23 #include <acpi/acpi_drivers.h> 23 #include <acpi/acpi_drivers.h>
24 24
25 #include "internal.h" 25 #include "internal.h"
26 #include "sleep.h" 26 #include "sleep.h"
27 27
28 static u8 sleep_states[ACPI_S_STATE_COUNT]; 28 static u8 sleep_states[ACPI_S_STATE_COUNT];
29 29
30 static void acpi_sleep_tts_switch(u32 acpi_state) 30 static void acpi_sleep_tts_switch(u32 acpi_state)
31 { 31 {
32 union acpi_object in_arg = { ACPI_TYPE_INTEGER }; 32 union acpi_object in_arg = { ACPI_TYPE_INTEGER };
33 struct acpi_object_list arg_list = { 1, &in_arg }; 33 struct acpi_object_list arg_list = { 1, &in_arg };
34 acpi_status status = AE_OK; 34 acpi_status status = AE_OK;
35 35
36 in_arg.integer.value = acpi_state; 36 in_arg.integer.value = acpi_state;
37 status = acpi_evaluate_object(NULL, "\\_TTS", &arg_list, NULL); 37 status = acpi_evaluate_object(NULL, "\\_TTS", &arg_list, NULL);
38 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 38 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
39 /* 39 /*
40 * OS can't evaluate the _TTS object correctly. Some warning 40 * OS can't evaluate the _TTS object correctly. Some warning
41 * message will be printed. But it won't break anything. 41 * message will be printed. But it won't break anything.
42 */ 42 */
43 printk(KERN_NOTICE "Failure in evaluating _TTS object\n"); 43 printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
44 } 44 }
45 } 45 }
46 46
47 static int tts_notify_reboot(struct notifier_block *this, 47 static int tts_notify_reboot(struct notifier_block *this,
48 unsigned long code, void *x) 48 unsigned long code, void *x)
49 { 49 {
50 acpi_sleep_tts_switch(ACPI_STATE_S5); 50 acpi_sleep_tts_switch(ACPI_STATE_S5);
51 return NOTIFY_DONE; 51 return NOTIFY_DONE;
52 } 52 }
53 53
54 static struct notifier_block tts_notifier = { 54 static struct notifier_block tts_notifier = {
55 .notifier_call = tts_notify_reboot, 55 .notifier_call = tts_notify_reboot,
56 .next = NULL, 56 .next = NULL,
57 .priority = 0, 57 .priority = 0,
58 }; 58 };
59 59
60 static int acpi_sleep_prepare(u32 acpi_state) 60 static int acpi_sleep_prepare(u32 acpi_state)
61 { 61 {
62 #ifdef CONFIG_ACPI_SLEEP 62 #ifdef CONFIG_ACPI_SLEEP
63 /* do we have a wakeup address for S2 and S3? */ 63 /* do we have a wakeup address for S2 and S3? */
64 if (acpi_state == ACPI_STATE_S3) { 64 if (acpi_state == ACPI_STATE_S3) {
65 if (!acpi_wakeup_address) { 65 if (!acpi_wakeup_address) {
66 return -EFAULT; 66 return -EFAULT;
67 } 67 }
68 acpi_set_firmware_waking_vector( 68 acpi_set_firmware_waking_vector(
69 (acpi_physical_address)acpi_wakeup_address); 69 (acpi_physical_address)acpi_wakeup_address);
70 70
71 } 71 }
72 ACPI_FLUSH_CPU_CACHE(); 72 ACPI_FLUSH_CPU_CACHE();
73 #endif 73 #endif
74 printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n", 74 printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
75 acpi_state); 75 acpi_state);
76 acpi_enable_wakeup_devices(acpi_state); 76 acpi_enable_wakeup_devices(acpi_state);
77 acpi_enter_sleep_state_prep(acpi_state); 77 acpi_enter_sleep_state_prep(acpi_state);
78 return 0; 78 return 0;
79 } 79 }
80 80
81 #ifdef CONFIG_ACPI_SLEEP 81 #ifdef CONFIG_ACPI_SLEEP
82 static u32 acpi_target_sleep_state = ACPI_STATE_S0; 82 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
83 83
84 /* 84 /*
85 * The ACPI specification wants us to save NVS memory regions during hibernation 85 * The ACPI specification wants us to save NVS memory regions during hibernation
86 * and to restore them during the subsequent resume. Windows does that also for 86 * and to restore them during the subsequent resume. Windows does that also for
87 * suspend to RAM. However, it is known that this mechanism does not work on 87 * suspend to RAM. However, it is known that this mechanism does not work on
88 * all machines, so we allow the user to disable it with the help of the 88 * all machines, so we allow the user to disable it with the help of the
89 * 'acpi_sleep=nonvs' kernel command line option. 89 * 'acpi_sleep=nonvs' kernel command line option.
90 */ 90 */
91 static bool nvs_nosave; 91 static bool nvs_nosave;
92 92
93 void __init acpi_nvs_nosave(void) 93 void __init acpi_nvs_nosave(void)
94 { 94 {
95 nvs_nosave = true; 95 nvs_nosave = true;
96 } 96 }
97 97
98 /* 98 /*
99 * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the 99 * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
100 * user to request that behavior by using the 'acpi_old_suspend_ordering' 100 * user to request that behavior by using the 'acpi_old_suspend_ordering'
101 * kernel command line option that causes the following variable to be set. 101 * kernel command line option that causes the following variable to be set.
102 */ 102 */
103 static bool old_suspend_ordering; 103 static bool old_suspend_ordering;
104 104
105 void __init acpi_old_suspend_ordering(void) 105 void __init acpi_old_suspend_ordering(void)
106 { 106 {
107 old_suspend_ordering = true; 107 old_suspend_ordering = true;
108 } 108 }
109 109
110 /** 110 /**
111 * acpi_pm_freeze - Disable the GPEs and suspend EC transactions. 111 * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
112 */ 112 */
113 static int acpi_pm_freeze(void) 113 static int acpi_pm_freeze(void)
114 { 114 {
115 acpi_disable_all_gpes(); 115 acpi_disable_all_gpes();
116 acpi_os_wait_events_complete(NULL); 116 acpi_os_wait_events_complete(NULL);
117 acpi_ec_block_transactions(); 117 acpi_ec_block_transactions();
118 return 0; 118 return 0;
119 } 119 }
120 120
121 /** 121 /**
122 * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS. 122 * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
123 */ 123 */
124 static int acpi_pm_pre_suspend(void) 124 static int acpi_pm_pre_suspend(void)
125 { 125 {
126 acpi_pm_freeze(); 126 acpi_pm_freeze();
127 return suspend_nvs_save(); 127 return suspend_nvs_save();
128 } 128 }
129 129
130 /** 130 /**
131 * __acpi_pm_prepare - Prepare the platform to enter the target state. 131 * __acpi_pm_prepare - Prepare the platform to enter the target state.
132 * 132 *
133 * If necessary, set the firmware waking vector and do arch-specific 133 * If necessary, set the firmware waking vector and do arch-specific
134 * nastiness to get the wakeup code to the waking vector. 134 * nastiness to get the wakeup code to the waking vector.
135 */ 135 */
136 static int __acpi_pm_prepare(void) 136 static int __acpi_pm_prepare(void)
137 { 137 {
138 int error = acpi_sleep_prepare(acpi_target_sleep_state); 138 int error = acpi_sleep_prepare(acpi_target_sleep_state);
139 if (error) 139 if (error)
140 acpi_target_sleep_state = ACPI_STATE_S0; 140 acpi_target_sleep_state = ACPI_STATE_S0;
141 141
142 return error; 142 return error;
143 } 143 }
144 144
145 /** 145 /**
146 * acpi_pm_prepare - Prepare the platform to enter the target sleep 146 * acpi_pm_prepare - Prepare the platform to enter the target sleep
147 * state and disable the GPEs. 147 * state and disable the GPEs.
148 */ 148 */
149 static int acpi_pm_prepare(void) 149 static int acpi_pm_prepare(void)
150 { 150 {
151 int error = __acpi_pm_prepare(); 151 int error = __acpi_pm_prepare();
152 if (!error) 152 if (!error)
153 error = acpi_pm_pre_suspend(); 153 error = acpi_pm_pre_suspend();
154 154
155 return error; 155 return error;
156 } 156 }
157 157
158 /** 158 /**
159 * acpi_pm_finish - Instruct the platform to leave a sleep state. 159 * acpi_pm_finish - Instruct the platform to leave a sleep state.
160 * 160 *
161 * This is called after we wake back up (or if entering the sleep state 161 * This is called after we wake back up (or if entering the sleep state
162 * failed). 162 * failed).
163 */ 163 */
164 static void acpi_pm_finish(void) 164 static void acpi_pm_finish(void)
165 { 165 {
166 u32 acpi_state = acpi_target_sleep_state; 166 u32 acpi_state = acpi_target_sleep_state;
167 167
168 acpi_ec_unblock_transactions(); 168 acpi_ec_unblock_transactions();
169 suspend_nvs_free(); 169 suspend_nvs_free();
170 170
171 if (acpi_state == ACPI_STATE_S0) 171 if (acpi_state == ACPI_STATE_S0)
172 return; 172 return;
173 173
174 printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n", 174 printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
175 acpi_state); 175 acpi_state);
176 acpi_disable_wakeup_devices(acpi_state); 176 acpi_disable_wakeup_devices(acpi_state);
177 acpi_leave_sleep_state(acpi_state); 177 acpi_leave_sleep_state(acpi_state);
178 178
179 /* reset firmware waking vector */ 179 /* reset firmware waking vector */
180 acpi_set_firmware_waking_vector((acpi_physical_address) 0); 180 acpi_set_firmware_waking_vector((acpi_physical_address) 0);
181 181
182 acpi_target_sleep_state = ACPI_STATE_S0; 182 acpi_target_sleep_state = ACPI_STATE_S0;
183 } 183 }
184 184
185 /** 185 /**
186 * acpi_pm_end - Finish up suspend sequence. 186 * acpi_pm_end - Finish up suspend sequence.
187 */ 187 */
188 static void acpi_pm_end(void) 188 static void acpi_pm_end(void)
189 { 189 {
190 /* 190 /*
191 * This is necessary in case acpi_pm_finish() is not called during a 191 * This is necessary in case acpi_pm_finish() is not called during a
192 * failing transition to a sleep state. 192 * failing transition to a sleep state.
193 */ 193 */
194 acpi_target_sleep_state = ACPI_STATE_S0; 194 acpi_target_sleep_state = ACPI_STATE_S0;
195 acpi_sleep_tts_switch(acpi_target_sleep_state); 195 acpi_sleep_tts_switch(acpi_target_sleep_state);
196 } 196 }
197 #else /* !CONFIG_ACPI_SLEEP */ 197 #else /* !CONFIG_ACPI_SLEEP */
198 #define acpi_target_sleep_state ACPI_STATE_S0 198 #define acpi_target_sleep_state ACPI_STATE_S0
199 #endif /* CONFIG_ACPI_SLEEP */ 199 #endif /* CONFIG_ACPI_SLEEP */
200 200
201 #ifdef CONFIG_SUSPEND 201 #ifdef CONFIG_SUSPEND
202 extern void do_suspend_lowlevel(void); 202 extern void do_suspend_lowlevel(void);
203 203
204 static u32 acpi_suspend_states[] = { 204 static u32 acpi_suspend_states[] = {
205 [PM_SUSPEND_ON] = ACPI_STATE_S0, 205 [PM_SUSPEND_ON] = ACPI_STATE_S0,
206 [PM_SUSPEND_STANDBY] = ACPI_STATE_S1, 206 [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
207 [PM_SUSPEND_MEM] = ACPI_STATE_S3, 207 [PM_SUSPEND_MEM] = ACPI_STATE_S3,
208 [PM_SUSPEND_MAX] = ACPI_STATE_S5 208 [PM_SUSPEND_MAX] = ACPI_STATE_S5
209 }; 209 };
210 210
211 /** 211 /**
212 * acpi_suspend_begin - Set the target system sleep state to the state 212 * acpi_suspend_begin - Set the target system sleep state to the state
213 * associated with given @pm_state, if supported. 213 * associated with given @pm_state, if supported.
214 */ 214 */
215 static int acpi_suspend_begin(suspend_state_t pm_state) 215 static int acpi_suspend_begin(suspend_state_t pm_state)
216 { 216 {
217 u32 acpi_state = acpi_suspend_states[pm_state]; 217 u32 acpi_state = acpi_suspend_states[pm_state];
218 int error = 0; 218 int error = 0;
219 219
220 error = nvs_nosave ? 0 : suspend_nvs_alloc(); 220 error = nvs_nosave ? 0 : suspend_nvs_alloc();
221 if (error) 221 if (error)
222 return error; 222 return error;
223 223
224 if (sleep_states[acpi_state]) { 224 if (sleep_states[acpi_state]) {
225 acpi_target_sleep_state = acpi_state; 225 acpi_target_sleep_state = acpi_state;
226 acpi_sleep_tts_switch(acpi_target_sleep_state); 226 acpi_sleep_tts_switch(acpi_target_sleep_state);
227 } else { 227 } else {
228 printk(KERN_ERR "ACPI does not support this state: %d\n", 228 printk(KERN_ERR "ACPI does not support this state: %d\n",
229 pm_state); 229 pm_state);
230 error = -ENOSYS; 230 error = -ENOSYS;
231 } 231 }
232 return error; 232 return error;
233 } 233 }
234 234
235 /** 235 /**
236 * acpi_suspend_enter - Actually enter a sleep state. 236 * acpi_suspend_enter - Actually enter a sleep state.
237 * @pm_state: ignored 237 * @pm_state: ignored
238 * 238 *
239 * Flush caches and go to sleep. For STR we have to call arch-specific 239 * Flush caches and go to sleep. For STR we have to call arch-specific
240 * assembly, which in turn call acpi_enter_sleep_state(). 240 * assembly, which in turn call acpi_enter_sleep_state().
241 * It's unfortunate, but it works. Please fix if you're feeling frisky. 241 * It's unfortunate, but it works. Please fix if you're feeling frisky.
242 */ 242 */
243 static int acpi_suspend_enter(suspend_state_t pm_state) 243 static int acpi_suspend_enter(suspend_state_t pm_state)
244 { 244 {
245 acpi_status status = AE_OK; 245 acpi_status status = AE_OK;
246 unsigned long flags = 0;
247 u32 acpi_state = acpi_target_sleep_state; 246 u32 acpi_state = acpi_target_sleep_state;
248 247
249 ACPI_FLUSH_CPU_CACHE(); 248 ACPI_FLUSH_CPU_CACHE();
250 249
251 /* Do arch specific saving of state. */ 250 /* Do arch specific saving of state. */
252 if (acpi_state == ACPI_STATE_S3) { 251 if (acpi_state == ACPI_STATE_S3) {
253 int error = acpi_save_state_mem(); 252 int error = acpi_save_state_mem();
254 253
255 if (error) 254 if (error)
256 return error; 255 return error;
257 } 256 }
258 257
259 local_irq_save(flags);
260 switch (acpi_state) { 258 switch (acpi_state) {
261 case ACPI_STATE_S1: 259 case ACPI_STATE_S1:
262 barrier(); 260 barrier();
263 status = acpi_enter_sleep_state(acpi_state); 261 status = acpi_enter_sleep_state(acpi_state);
264 break; 262 break;
265 263
266 case ACPI_STATE_S3: 264 case ACPI_STATE_S3:
267 do_suspend_lowlevel(); 265 do_suspend_lowlevel();
268 break; 266 break;
269 } 267 }
270 268
271 /* This violates the spec but is required for bug compatibility. */ 269 /* This violates the spec but is required for bug compatibility. */
272 acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1); 270 acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
273 271
274 /* Reprogram control registers and execute _BFS */ 272 /* Reprogram control registers and execute _BFS */
275 acpi_leave_sleep_state_prep(acpi_state); 273 acpi_leave_sleep_state_prep(acpi_state);
276 274
277 /* ACPI 3.0 specs (P62) says that it's the responsibility 275 /* ACPI 3.0 specs (P62) says that it's the responsibility
278 * of the OSPM to clear the status bit [ implying that the 276 * of the OSPM to clear the status bit [ implying that the
279 * POWER_BUTTON event should not reach userspace ] 277 * POWER_BUTTON event should not reach userspace ]
280 */ 278 */
281 if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) 279 if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3))
282 acpi_clear_event(ACPI_EVENT_POWER_BUTTON); 280 acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
283 281
284 /* 282 /*
285 * Disable and clear GPE status before interrupt is enabled. Some GPEs 283 * Disable and clear GPE status before interrupt is enabled. Some GPEs
286 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire. 284 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
287 * acpi_leave_sleep_state will reenable specific GPEs later 285 * acpi_leave_sleep_state will reenable specific GPEs later
288 */ 286 */
289 acpi_disable_all_gpes(); 287 acpi_disable_all_gpes();
290 /* Allow EC transactions to happen. */ 288 /* Allow EC transactions to happen. */
291 acpi_ec_unblock_transactions_early(); 289 acpi_ec_unblock_transactions_early();
292 290
293 local_irq_restore(flags);
294 printk(KERN_DEBUG "Back to C!\n"); 291 printk(KERN_DEBUG "Back to C!\n");
295 292
296 suspend_nvs_restore(); 293 suspend_nvs_restore();
297 294
298 return ACPI_SUCCESS(status) ? 0 : -EFAULT; 295 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
299 } 296 }
300 297
301 static int acpi_suspend_state_valid(suspend_state_t pm_state) 298 static int acpi_suspend_state_valid(suspend_state_t pm_state)
302 { 299 {
303 u32 acpi_state; 300 u32 acpi_state;
304 301
305 switch (pm_state) { 302 switch (pm_state) {
306 case PM_SUSPEND_ON: 303 case PM_SUSPEND_ON:
307 case PM_SUSPEND_STANDBY: 304 case PM_SUSPEND_STANDBY:
308 case PM_SUSPEND_MEM: 305 case PM_SUSPEND_MEM:
309 acpi_state = acpi_suspend_states[pm_state]; 306 acpi_state = acpi_suspend_states[pm_state];
310 307
311 return sleep_states[acpi_state]; 308 return sleep_states[acpi_state];
312 default: 309 default:
313 return 0; 310 return 0;
314 } 311 }
315 } 312 }
316 313
317 static const struct platform_suspend_ops acpi_suspend_ops = { 314 static const struct platform_suspend_ops acpi_suspend_ops = {
318 .valid = acpi_suspend_state_valid, 315 .valid = acpi_suspend_state_valid,
319 .begin = acpi_suspend_begin, 316 .begin = acpi_suspend_begin,
320 .prepare_late = acpi_pm_prepare, 317 .prepare_late = acpi_pm_prepare,
321 .enter = acpi_suspend_enter, 318 .enter = acpi_suspend_enter,
322 .wake = acpi_pm_finish, 319 .wake = acpi_pm_finish,
323 .end = acpi_pm_end, 320 .end = acpi_pm_end,
324 }; 321 };
325 322
326 /** 323 /**
327 * acpi_suspend_begin_old - Set the target system sleep state to the 324 * acpi_suspend_begin_old - Set the target system sleep state to the
328 * state associated with given @pm_state, if supported, and 325 * state associated with given @pm_state, if supported, and
329 * execute the _PTS control method. This function is used if the 326 * execute the _PTS control method. This function is used if the
330 * pre-ACPI 2.0 suspend ordering has been requested. 327 * pre-ACPI 2.0 suspend ordering has been requested.
331 */ 328 */
332 static int acpi_suspend_begin_old(suspend_state_t pm_state) 329 static int acpi_suspend_begin_old(suspend_state_t pm_state)
333 { 330 {
334 int error = acpi_suspend_begin(pm_state); 331 int error = acpi_suspend_begin(pm_state);
335 if (!error) 332 if (!error)
336 error = __acpi_pm_prepare(); 333 error = __acpi_pm_prepare();
337 334
338 return error; 335 return error;
339 } 336 }
340 337
341 /* 338 /*
342 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has 339 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
343 * been requested. 340 * been requested.
344 */ 341 */
345 static const struct platform_suspend_ops acpi_suspend_ops_old = { 342 static const struct platform_suspend_ops acpi_suspend_ops_old = {
346 .valid = acpi_suspend_state_valid, 343 .valid = acpi_suspend_state_valid,
347 .begin = acpi_suspend_begin_old, 344 .begin = acpi_suspend_begin_old,
348 .prepare_late = acpi_pm_pre_suspend, 345 .prepare_late = acpi_pm_pre_suspend,
349 .enter = acpi_suspend_enter, 346 .enter = acpi_suspend_enter,
350 .wake = acpi_pm_finish, 347 .wake = acpi_pm_finish,
351 .end = acpi_pm_end, 348 .end = acpi_pm_end,
352 .recover = acpi_pm_finish, 349 .recover = acpi_pm_finish,
353 }; 350 };
354 351
355 static int __init init_old_suspend_ordering(const struct dmi_system_id *d) 352 static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
356 { 353 {
357 old_suspend_ordering = true; 354 old_suspend_ordering = true;
358 return 0; 355 return 0;
359 } 356 }
360 357
361 static int __init init_nvs_nosave(const struct dmi_system_id *d) 358 static int __init init_nvs_nosave(const struct dmi_system_id *d)
362 { 359 {
363 acpi_nvs_nosave(); 360 acpi_nvs_nosave();
364 return 0; 361 return 0;
365 } 362 }
366 363
367 static struct dmi_system_id __initdata acpisleep_dmi_table[] = { 364 static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
368 { 365 {
369 .callback = init_old_suspend_ordering, 366 .callback = init_old_suspend_ordering,
370 .ident = "Abit KN9 (nForce4 variant)", 367 .ident = "Abit KN9 (nForce4 variant)",
371 .matches = { 368 .matches = {
372 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"), 369 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
373 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"), 370 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
374 }, 371 },
375 }, 372 },
376 { 373 {
377 .callback = init_old_suspend_ordering, 374 .callback = init_old_suspend_ordering,
378 .ident = "HP xw4600 Workstation", 375 .ident = "HP xw4600 Workstation",
379 .matches = { 376 .matches = {
380 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 377 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
381 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"), 378 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
382 }, 379 },
383 }, 380 },
384 { 381 {
385 .callback = init_old_suspend_ordering, 382 .callback = init_old_suspend_ordering,
386 .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)", 383 .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
387 .matches = { 384 .matches = {
388 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."), 385 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
389 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"), 386 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
390 }, 387 },
391 }, 388 },
392 { 389 {
393 .callback = init_old_suspend_ordering, 390 .callback = init_old_suspend_ordering,
394 .ident = "Panasonic CF51-2L", 391 .ident = "Panasonic CF51-2L",
395 .matches = { 392 .matches = {
396 DMI_MATCH(DMI_BOARD_VENDOR, 393 DMI_MATCH(DMI_BOARD_VENDOR,
397 "Matsushita Electric Industrial Co.,Ltd."), 394 "Matsushita Electric Industrial Co.,Ltd."),
398 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"), 395 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
399 }, 396 },
400 }, 397 },
401 { 398 {
402 .callback = init_nvs_nosave, 399 .callback = init_nvs_nosave,
403 .ident = "Sony Vaio VGN-SR11M", 400 .ident = "Sony Vaio VGN-SR11M",
404 .matches = { 401 .matches = {
405 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 402 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
406 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"), 403 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
407 }, 404 },
408 }, 405 },
409 { 406 {
410 .callback = init_nvs_nosave, 407 .callback = init_nvs_nosave,
411 .ident = "Everex StepNote Series", 408 .ident = "Everex StepNote Series",
412 .matches = { 409 .matches = {
413 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."), 410 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
414 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"), 411 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
415 }, 412 },
416 }, 413 },
417 { 414 {
418 .callback = init_nvs_nosave, 415 .callback = init_nvs_nosave,
419 .ident = "Sony Vaio VPCEB1Z1E", 416 .ident = "Sony Vaio VPCEB1Z1E",
420 .matches = { 417 .matches = {
421 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 418 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
422 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"), 419 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
423 }, 420 },
424 }, 421 },
425 { 422 {
426 .callback = init_nvs_nosave, 423 .callback = init_nvs_nosave,
427 .ident = "Sony Vaio VGN-NW130D", 424 .ident = "Sony Vaio VGN-NW130D",
428 .matches = { 425 .matches = {
429 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 426 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
430 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"), 427 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
431 }, 428 },
432 }, 429 },
433 { 430 {
434 .callback = init_nvs_nosave, 431 .callback = init_nvs_nosave,
435 .ident = "Averatec AV1020-ED2", 432 .ident = "Averatec AV1020-ED2",
436 .matches = { 433 .matches = {
437 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"), 434 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
438 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"), 435 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
439 }, 436 },
440 }, 437 },
441 {}, 438 {},
442 }; 439 };
443 #endif /* CONFIG_SUSPEND */ 440 #endif /* CONFIG_SUSPEND */
444 441
445 #ifdef CONFIG_HIBERNATION 442 #ifdef CONFIG_HIBERNATION
446 static unsigned long s4_hardware_signature; 443 static unsigned long s4_hardware_signature;
447 static struct acpi_table_facs *facs; 444 static struct acpi_table_facs *facs;
448 static bool nosigcheck; 445 static bool nosigcheck;
449 446
450 void __init acpi_no_s4_hw_signature(void) 447 void __init acpi_no_s4_hw_signature(void)
451 { 448 {
452 nosigcheck = true; 449 nosigcheck = true;
453 } 450 }
454 451
455 static int acpi_hibernation_begin(void) 452 static int acpi_hibernation_begin(void)
456 { 453 {
457 int error; 454 int error;
458 455
459 error = nvs_nosave ? 0 : suspend_nvs_alloc(); 456 error = nvs_nosave ? 0 : suspend_nvs_alloc();
460 if (!error) { 457 if (!error) {
461 acpi_target_sleep_state = ACPI_STATE_S4; 458 acpi_target_sleep_state = ACPI_STATE_S4;
462 acpi_sleep_tts_switch(acpi_target_sleep_state); 459 acpi_sleep_tts_switch(acpi_target_sleep_state);
463 } 460 }
464 461
465 return error; 462 return error;
466 } 463 }
467 464
468 static int acpi_hibernation_enter(void) 465 static int acpi_hibernation_enter(void)
469 { 466 {
470 acpi_status status = AE_OK; 467 acpi_status status = AE_OK;
471 unsigned long flags = 0; 468 unsigned long flags = 0;
472 469
473 ACPI_FLUSH_CPU_CACHE(); 470 ACPI_FLUSH_CPU_CACHE();
474 471
475 local_irq_save(flags); 472 local_irq_save(flags);
476 /* This shouldn't return. If it returns, we have a problem */ 473 /* This shouldn't return. If it returns, we have a problem */
477 status = acpi_enter_sleep_state(ACPI_STATE_S4); 474 status = acpi_enter_sleep_state(ACPI_STATE_S4);
478 /* Reprogram control registers and execute _BFS */ 475 /* Reprogram control registers and execute _BFS */
479 acpi_leave_sleep_state_prep(ACPI_STATE_S4); 476 acpi_leave_sleep_state_prep(ACPI_STATE_S4);
480 local_irq_restore(flags); 477 local_irq_restore(flags);
481 478
482 return ACPI_SUCCESS(status) ? 0 : -EFAULT; 479 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
483 } 480 }
484 481
485 static void acpi_hibernation_leave(void) 482 static void acpi_hibernation_leave(void)
486 { 483 {
487 /* 484 /*
488 * If ACPI is not enabled by the BIOS and the boot kernel, we need to 485 * If ACPI is not enabled by the BIOS and the boot kernel, we need to
489 * enable it here. 486 * enable it here.
490 */ 487 */
491 acpi_enable(); 488 acpi_enable();
492 /* Reprogram control registers and execute _BFS */ 489 /* Reprogram control registers and execute _BFS */
493 acpi_leave_sleep_state_prep(ACPI_STATE_S4); 490 acpi_leave_sleep_state_prep(ACPI_STATE_S4);
494 /* Check the hardware signature */ 491 /* Check the hardware signature */
495 if (facs && s4_hardware_signature != facs->hardware_signature) { 492 if (facs && s4_hardware_signature != facs->hardware_signature) {
496 printk(KERN_EMERG "ACPI: Hardware changed while hibernated, " 493 printk(KERN_EMERG "ACPI: Hardware changed while hibernated, "
497 "cannot resume!\n"); 494 "cannot resume!\n");
498 panic("ACPI S4 hardware signature mismatch"); 495 panic("ACPI S4 hardware signature mismatch");
499 } 496 }
500 /* Restore the NVS memory area */ 497 /* Restore the NVS memory area */
501 suspend_nvs_restore(); 498 suspend_nvs_restore();
502 /* Allow EC transactions to happen. */ 499 /* Allow EC transactions to happen. */
503 acpi_ec_unblock_transactions_early(); 500 acpi_ec_unblock_transactions_early();
504 } 501 }
505 502
506 static void acpi_pm_thaw(void) 503 static void acpi_pm_thaw(void)
507 { 504 {
508 acpi_ec_unblock_transactions(); 505 acpi_ec_unblock_transactions();
509 acpi_enable_all_runtime_gpes(); 506 acpi_enable_all_runtime_gpes();
510 } 507 }
511 508
512 static const struct platform_hibernation_ops acpi_hibernation_ops = { 509 static const struct platform_hibernation_ops acpi_hibernation_ops = {
513 .begin = acpi_hibernation_begin, 510 .begin = acpi_hibernation_begin,
514 .end = acpi_pm_end, 511 .end = acpi_pm_end,
515 .pre_snapshot = acpi_pm_prepare, 512 .pre_snapshot = acpi_pm_prepare,
516 .finish = acpi_pm_finish, 513 .finish = acpi_pm_finish,
517 .prepare = acpi_pm_prepare, 514 .prepare = acpi_pm_prepare,
518 .enter = acpi_hibernation_enter, 515 .enter = acpi_hibernation_enter,
519 .leave = acpi_hibernation_leave, 516 .leave = acpi_hibernation_leave,
520 .pre_restore = acpi_pm_freeze, 517 .pre_restore = acpi_pm_freeze,
521 .restore_cleanup = acpi_pm_thaw, 518 .restore_cleanup = acpi_pm_thaw,
522 }; 519 };
523 520
524 /** 521 /**
525 * acpi_hibernation_begin_old - Set the target system sleep state to 522 * acpi_hibernation_begin_old - Set the target system sleep state to
526 * ACPI_STATE_S4 and execute the _PTS control method. This 523 * ACPI_STATE_S4 and execute the _PTS control method. This
527 * function is used if the pre-ACPI 2.0 suspend ordering has been 524 * function is used if the pre-ACPI 2.0 suspend ordering has been
528 * requested. 525 * requested.
529 */ 526 */
530 static int acpi_hibernation_begin_old(void) 527 static int acpi_hibernation_begin_old(void)
531 { 528 {
532 int error; 529 int error;
533 /* 530 /*
534 * The _TTS object should always be evaluated before the _PTS object. 531 * The _TTS object should always be evaluated before the _PTS object.
535 * When the old_suspended_ordering is true, the _PTS object is 532 * When the old_suspended_ordering is true, the _PTS object is
536 * evaluated in the acpi_sleep_prepare. 533 * evaluated in the acpi_sleep_prepare.
537 */ 534 */
538 acpi_sleep_tts_switch(ACPI_STATE_S4); 535 acpi_sleep_tts_switch(ACPI_STATE_S4);
539 536
540 error = acpi_sleep_prepare(ACPI_STATE_S4); 537 error = acpi_sleep_prepare(ACPI_STATE_S4);
541 538
542 if (!error) { 539 if (!error) {
543 if (!nvs_nosave) 540 if (!nvs_nosave)
544 error = suspend_nvs_alloc(); 541 error = suspend_nvs_alloc();
545 if (!error) 542 if (!error)
546 acpi_target_sleep_state = ACPI_STATE_S4; 543 acpi_target_sleep_state = ACPI_STATE_S4;
547 } 544 }
548 return error; 545 return error;
549 } 546 }
550 547
551 /* 548 /*
552 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has 549 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
553 * been requested. 550 * been requested.
554 */ 551 */
555 static const struct platform_hibernation_ops acpi_hibernation_ops_old = { 552 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
556 .begin = acpi_hibernation_begin_old, 553 .begin = acpi_hibernation_begin_old,
557 .end = acpi_pm_end, 554 .end = acpi_pm_end,
558 .pre_snapshot = acpi_pm_pre_suspend, 555 .pre_snapshot = acpi_pm_pre_suspend,
559 .prepare = acpi_pm_freeze, 556 .prepare = acpi_pm_freeze,
560 .finish = acpi_pm_finish, 557 .finish = acpi_pm_finish,
561 .enter = acpi_hibernation_enter, 558 .enter = acpi_hibernation_enter,
562 .leave = acpi_hibernation_leave, 559 .leave = acpi_hibernation_leave,
563 .pre_restore = acpi_pm_freeze, 560 .pre_restore = acpi_pm_freeze,
564 .restore_cleanup = acpi_pm_thaw, 561 .restore_cleanup = acpi_pm_thaw,
565 .recover = acpi_pm_finish, 562 .recover = acpi_pm_finish,
566 }; 563 };
567 #endif /* CONFIG_HIBERNATION */ 564 #endif /* CONFIG_HIBERNATION */
568 565
569 int acpi_suspend(u32 acpi_state) 566 int acpi_suspend(u32 acpi_state)
570 { 567 {
571 suspend_state_t states[] = { 568 suspend_state_t states[] = {
572 [1] = PM_SUSPEND_STANDBY, 569 [1] = PM_SUSPEND_STANDBY,
573 [3] = PM_SUSPEND_MEM, 570 [3] = PM_SUSPEND_MEM,
574 [5] = PM_SUSPEND_MAX 571 [5] = PM_SUSPEND_MAX
575 }; 572 };
576 573
577 if (acpi_state < 6 && states[acpi_state]) 574 if (acpi_state < 6 && states[acpi_state])
578 return pm_suspend(states[acpi_state]); 575 return pm_suspend(states[acpi_state]);
579 if (acpi_state == 4) 576 if (acpi_state == 4)
580 return hibernate(); 577 return hibernate();
581 return -EINVAL; 578 return -EINVAL;
582 } 579 }
583 580
584 #ifdef CONFIG_PM_OPS 581 #ifdef CONFIG_PM_OPS
585 /** 582 /**
586 * acpi_pm_device_sleep_state - return preferred power state of ACPI device 583 * acpi_pm_device_sleep_state - return preferred power state of ACPI device
587 * in the system sleep state given by %acpi_target_sleep_state 584 * in the system sleep state given by %acpi_target_sleep_state
588 * @dev: device to examine; its driver model wakeup flags control 585 * @dev: device to examine; its driver model wakeup flags control
589 * whether it should be able to wake up the system 586 * whether it should be able to wake up the system
590 * @d_min_p: used to store the upper limit of allowed states range 587 * @d_min_p: used to store the upper limit of allowed states range
591 * Return value: preferred power state of the device on success, -ENODEV on 588 * Return value: preferred power state of the device on success, -ENODEV on
592 * failure (ie. if there's no 'struct acpi_device' for @dev) 589 * failure (ie. if there's no 'struct acpi_device' for @dev)
593 * 590 *
594 * Find the lowest power (highest number) ACPI device power state that 591 * Find the lowest power (highest number) ACPI device power state that
595 * device @dev can be in while the system is in the sleep state represented 592 * device @dev can be in while the system is in the sleep state represented
596 * by %acpi_target_sleep_state. If @wake is nonzero, the device should be 593 * by %acpi_target_sleep_state. If @wake is nonzero, the device should be
597 * able to wake up the system from this sleep state. If @d_min_p is set, 594 * able to wake up the system from this sleep state. If @d_min_p is set,
598 * the highest power (lowest number) device power state of @dev allowed 595 * the highest power (lowest number) device power state of @dev allowed
599 * in this system sleep state is stored at the location pointed to by it. 596 * in this system sleep state is stored at the location pointed to by it.
600 * 597 *
601 * The caller must ensure that @dev is valid before using this function. 598 * The caller must ensure that @dev is valid before using this function.
602 * The caller is also responsible for figuring out if the device is 599 * The caller is also responsible for figuring out if the device is
603 * supposed to be able to wake up the system and passing this information 600 * supposed to be able to wake up the system and passing this information
604 * via @wake. 601 * via @wake.
605 */ 602 */
606 603
607 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p) 604 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
608 { 605 {
609 acpi_handle handle = DEVICE_ACPI_HANDLE(dev); 606 acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
610 struct acpi_device *adev; 607 struct acpi_device *adev;
611 char acpi_method[] = "_SxD"; 608 char acpi_method[] = "_SxD";
612 unsigned long long d_min, d_max; 609 unsigned long long d_min, d_max;
613 610
614 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) { 611 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
615 printk(KERN_DEBUG "ACPI handle has no context!\n"); 612 printk(KERN_DEBUG "ACPI handle has no context!\n");
616 return -ENODEV; 613 return -ENODEV;
617 } 614 }
618 615
619 acpi_method[2] = '0' + acpi_target_sleep_state; 616 acpi_method[2] = '0' + acpi_target_sleep_state;
620 /* 617 /*
621 * If the sleep state is S0, we will return D3, but if the device has 618 * If the sleep state is S0, we will return D3, but if the device has
622 * _S0W, we will use the value from _S0W 619 * _S0W, we will use the value from _S0W
623 */ 620 */
624 d_min = ACPI_STATE_D0; 621 d_min = ACPI_STATE_D0;
625 d_max = ACPI_STATE_D3; 622 d_max = ACPI_STATE_D3;
626 623
627 /* 624 /*
628 * If present, _SxD methods return the minimum D-state (highest power 625 * If present, _SxD methods return the minimum D-state (highest power
629 * state) we can use for the corresponding S-states. Otherwise, the 626 * state) we can use for the corresponding S-states. Otherwise, the
630 * minimum D-state is D0 (ACPI 3.x). 627 * minimum D-state is D0 (ACPI 3.x).
631 * 628 *
632 * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer 629 * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
633 * provided -- that's our fault recovery, we ignore retval. 630 * provided -- that's our fault recovery, we ignore retval.
634 */ 631 */
635 if (acpi_target_sleep_state > ACPI_STATE_S0) 632 if (acpi_target_sleep_state > ACPI_STATE_S0)
636 acpi_evaluate_integer(handle, acpi_method, NULL, &d_min); 633 acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);
637 634
638 /* 635 /*
639 * If _PRW says we can wake up the system from the target sleep state, 636 * If _PRW says we can wake up the system from the target sleep state,
640 * the D-state returned by _SxD is sufficient for that (we assume a 637 * the D-state returned by _SxD is sufficient for that (we assume a
641 * wakeup-aware driver if wake is set). Still, if _SxW exists 638 * wakeup-aware driver if wake is set). Still, if _SxW exists
642 * (ACPI 3.x), it should return the maximum (lowest power) D-state that 639 * (ACPI 3.x), it should return the maximum (lowest power) D-state that
643 * can wake the system. _S0W may be valid, too. 640 * can wake the system. _S0W may be valid, too.
644 */ 641 */
645 if (acpi_target_sleep_state == ACPI_STATE_S0 || 642 if (acpi_target_sleep_state == ACPI_STATE_S0 ||
646 (device_may_wakeup(dev) && 643 (device_may_wakeup(dev) &&
647 adev->wakeup.sleep_state <= acpi_target_sleep_state)) { 644 adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
648 acpi_status status; 645 acpi_status status;
649 646
650 acpi_method[3] = 'W'; 647 acpi_method[3] = 'W';
651 status = acpi_evaluate_integer(handle, acpi_method, NULL, 648 status = acpi_evaluate_integer(handle, acpi_method, NULL,
652 &d_max); 649 &d_max);
653 if (ACPI_FAILURE(status)) { 650 if (ACPI_FAILURE(status)) {
654 if (acpi_target_sleep_state != ACPI_STATE_S0 || 651 if (acpi_target_sleep_state != ACPI_STATE_S0 ||
655 status != AE_NOT_FOUND) 652 status != AE_NOT_FOUND)
656 d_max = d_min; 653 d_max = d_min;
657 } else if (d_max < d_min) { 654 } else if (d_max < d_min) {
658 /* Warn the user of the broken DSDT */ 655 /* Warn the user of the broken DSDT */
659 printk(KERN_WARNING "ACPI: Wrong value from %s\n", 656 printk(KERN_WARNING "ACPI: Wrong value from %s\n",
660 acpi_method); 657 acpi_method);
661 /* Sanitize it */ 658 /* Sanitize it */
662 d_min = d_max; 659 d_min = d_max;
663 } 660 }
664 } 661 }
665 662
666 if (d_min_p) 663 if (d_min_p)
667 *d_min_p = d_min; 664 *d_min_p = d_min;
668 return d_max; 665 return d_max;
669 } 666 }
670 #endif /* CONFIG_PM_OPS */ 667 #endif /* CONFIG_PM_OPS */
671 668
672 #ifdef CONFIG_PM_SLEEP 669 #ifdef CONFIG_PM_SLEEP
673 /** 670 /**
674 * acpi_pm_device_sleep_wake - enable or disable the system wake-up 671 * acpi_pm_device_sleep_wake - enable or disable the system wake-up
675 * capability of given device 672 * capability of given device
676 * @dev: device to handle 673 * @dev: device to handle
677 * @enable: 'true' - enable, 'false' - disable the wake-up capability 674 * @enable: 'true' - enable, 'false' - disable the wake-up capability
678 */ 675 */
679 int acpi_pm_device_sleep_wake(struct device *dev, bool enable) 676 int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
680 { 677 {
681 acpi_handle handle; 678 acpi_handle handle;
682 struct acpi_device *adev; 679 struct acpi_device *adev;
683 int error; 680 int error;
684 681
685 if (!device_can_wakeup(dev)) 682 if (!device_can_wakeup(dev))
686 return -EINVAL; 683 return -EINVAL;
687 684
688 handle = DEVICE_ACPI_HANDLE(dev); 685 handle = DEVICE_ACPI_HANDLE(dev);
689 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) { 686 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
690 dev_dbg(dev, "ACPI handle has no context in %s!\n", __func__); 687 dev_dbg(dev, "ACPI handle has no context in %s!\n", __func__);
691 return -ENODEV; 688 return -ENODEV;
692 } 689 }
693 690
694 error = enable ? 691 error = enable ?
695 acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) : 692 acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
696 acpi_disable_wakeup_device_power(adev); 693 acpi_disable_wakeup_device_power(adev);
697 if (!error) 694 if (!error)
698 dev_info(dev, "wake-up capability %s by ACPI\n", 695 dev_info(dev, "wake-up capability %s by ACPI\n",
699 enable ? "enabled" : "disabled"); 696 enable ? "enabled" : "disabled");
700 697
701 return error; 698 return error;
702 } 699 }
703 #endif /* CONFIG_PM_SLEEP */ 700 #endif /* CONFIG_PM_SLEEP */
704 701
705 static void acpi_power_off_prepare(void) 702 static void acpi_power_off_prepare(void)
706 { 703 {
707 /* Prepare to power off the system */ 704 /* Prepare to power off the system */
708 acpi_sleep_prepare(ACPI_STATE_S5); 705 acpi_sleep_prepare(ACPI_STATE_S5);
709 acpi_disable_all_gpes(); 706 acpi_disable_all_gpes();
710 } 707 }
711 708
712 static void acpi_power_off(void) 709 static void acpi_power_off(void)
713 { 710 {
714 /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */ 711 /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
715 printk(KERN_DEBUG "%s called\n", __func__); 712 printk(KERN_DEBUG "%s called\n", __func__);
716 local_irq_disable(); 713 local_irq_disable();
717 acpi_enter_sleep_state(ACPI_STATE_S5); 714 acpi_enter_sleep_state(ACPI_STATE_S5);
718 } 715 }
719 716
720 /* 717 /*
721 * ACPI 2.0 created the optional _GTS and _BFS, 718 * ACPI 2.0 created the optional _GTS and _BFS,
722 * but industry adoption has been neither rapid nor broad. 719 * but industry adoption has been neither rapid nor broad.
723 * 720 *
724 * Linux gets into trouble when it executes poorly validated 721 * Linux gets into trouble when it executes poorly validated
725 * paths through the BIOS, so disable _GTS and _BFS by default, 722 * paths through the BIOS, so disable _GTS and _BFS by default,
726 * but do speak up and offer the option to enable them. 723 * but do speak up and offer the option to enable them.
727 */ 724 */
728 static void __init acpi_gts_bfs_check(void) 725 static void __init acpi_gts_bfs_check(void)
729 { 726 {
730 acpi_handle dummy; 727 acpi_handle dummy;
731 728
732 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__GTS, &dummy))) 729 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__GTS, &dummy)))
733 { 730 {
734 printk(KERN_NOTICE PREFIX "BIOS offers _GTS\n"); 731 printk(KERN_NOTICE PREFIX "BIOS offers _GTS\n");
735 printk(KERN_NOTICE PREFIX "If \"acpi.gts=1\" improves suspend, " 732 printk(KERN_NOTICE PREFIX "If \"acpi.gts=1\" improves suspend, "
736 "please notify linux-acpi@vger.kernel.org\n"); 733 "please notify linux-acpi@vger.kernel.org\n");
737 } 734 }
738 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__BFS, &dummy))) 735 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__BFS, &dummy)))
739 { 736 {
740 printk(KERN_NOTICE PREFIX "BIOS offers _BFS\n"); 737 printk(KERN_NOTICE PREFIX "BIOS offers _BFS\n");
741 printk(KERN_NOTICE PREFIX "If \"acpi.bfs=1\" improves resume, " 738 printk(KERN_NOTICE PREFIX "If \"acpi.bfs=1\" improves resume, "
742 "please notify linux-acpi@vger.kernel.org\n"); 739 "please notify linux-acpi@vger.kernel.org\n");
743 } 740 }
744 } 741 }
745 742
746 int __init acpi_sleep_init(void) 743 int __init acpi_sleep_init(void)
747 { 744 {
748 acpi_status status; 745 acpi_status status;
749 u8 type_a, type_b; 746 u8 type_a, type_b;
750 #ifdef CONFIG_SUSPEND 747 #ifdef CONFIG_SUSPEND
751 int i = 0; 748 int i = 0;
752 749
753 dmi_check_system(acpisleep_dmi_table); 750 dmi_check_system(acpisleep_dmi_table);
754 #endif 751 #endif
755 752
756 if (acpi_disabled) 753 if (acpi_disabled)
757 return 0; 754 return 0;
758 755
759 sleep_states[ACPI_STATE_S0] = 1; 756 sleep_states[ACPI_STATE_S0] = 1;
760 printk(KERN_INFO PREFIX "(supports S0"); 757 printk(KERN_INFO PREFIX "(supports S0");
761 758
762 #ifdef CONFIG_SUSPEND 759 #ifdef CONFIG_SUSPEND
763 for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) { 760 for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
764 status = acpi_get_sleep_type_data(i, &type_a, &type_b); 761 status = acpi_get_sleep_type_data(i, &type_a, &type_b);
765 if (ACPI_SUCCESS(status)) { 762 if (ACPI_SUCCESS(status)) {
766 sleep_states[i] = 1; 763 sleep_states[i] = 1;
767 printk(" S%d", i); 764 printk(" S%d", i);
768 } 765 }
769 } 766 }
770 767
771 suspend_set_ops(old_suspend_ordering ? 768 suspend_set_ops(old_suspend_ordering ?
772 &acpi_suspend_ops_old : &acpi_suspend_ops); 769 &acpi_suspend_ops_old : &acpi_suspend_ops);
773 #endif 770 #endif
774 771
775 #ifdef CONFIG_HIBERNATION 772 #ifdef CONFIG_HIBERNATION
776 status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b); 773 status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
777 if (ACPI_SUCCESS(status)) { 774 if (ACPI_SUCCESS(status)) {
778 hibernation_set_ops(old_suspend_ordering ? 775 hibernation_set_ops(old_suspend_ordering ?
779 &acpi_hibernation_ops_old : &acpi_hibernation_ops); 776 &acpi_hibernation_ops_old : &acpi_hibernation_ops);
780 sleep_states[ACPI_STATE_S4] = 1; 777 sleep_states[ACPI_STATE_S4] = 1;
781 printk(" S4"); 778 printk(" S4");
782 if (!nosigcheck) { 779 if (!nosigcheck) {
783 acpi_get_table(ACPI_SIG_FACS, 1, 780 acpi_get_table(ACPI_SIG_FACS, 1,
784 (struct acpi_table_header **)&facs); 781 (struct acpi_table_header **)&facs);
785 if (facs) 782 if (facs)
786 s4_hardware_signature = 783 s4_hardware_signature =
787 facs->hardware_signature; 784 facs->hardware_signature;
788 } 785 }
789 } 786 }
790 #endif 787 #endif
791 status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b); 788 status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
792 if (ACPI_SUCCESS(status)) { 789 if (ACPI_SUCCESS(status)) {
793 sleep_states[ACPI_STATE_S5] = 1; 790 sleep_states[ACPI_STATE_S5] = 1;
794 printk(" S5"); 791 printk(" S5");
795 pm_power_off_prepare = acpi_power_off_prepare; 792 pm_power_off_prepare = acpi_power_off_prepare;
796 pm_power_off = acpi_power_off; 793 pm_power_off = acpi_power_off;
797 } 794 }
798 printk(")\n"); 795 printk(")\n");
799 /* 796 /*
800 * Register the tts_notifier to reboot notifier list so that the _TTS 797 * Register the tts_notifier to reboot notifier list so that the _TTS
801 * object can also be evaluated when the system enters S5. 798 * object can also be evaluated when the system enters S5.
802 */ 799 */
803 register_reboot_notifier(&tts_notifier); 800 register_reboot_notifier(&tts_notifier);
804 acpi_gts_bfs_check(); 801 acpi_gts_bfs_check();
805 return 0; 802 return 0;
806 } 803 }
807 804