diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/acpi/events/evmisc.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/acpi/events/evmisc.c')
-rw-r--r-- | drivers/acpi/events/evmisc.c | 588 |
1 files changed, 588 insertions, 0 deletions
diff --git a/drivers/acpi/events/evmisc.c b/drivers/acpi/events/evmisc.c new file mode 100644 index 000000000000..2548efa7a45f --- /dev/null +++ b/drivers/acpi/events/evmisc.c | |||
@@ -0,0 +1,588 @@ | |||
1 | /****************************************************************************** | ||
2 | * | ||
3 | * Module Name: evmisc - Miscellaneous event manager support functions | ||
4 | * | ||
5 | *****************************************************************************/ | ||
6 | |||
7 | /* | ||
8 | * Copyright (C) 2000 - 2005, R. Byron Moore | ||
9 | * All rights reserved. | ||
10 | * | ||
11 | * Redistribution and use in source and binary forms, with or without | ||
12 | * modification, are permitted provided that the following conditions | ||
13 | * are met: | ||
14 | * 1. Redistributions of source code must retain the above copyright | ||
15 | * notice, this list of conditions, and the following disclaimer, | ||
16 | * without modification. | ||
17 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | ||
18 | * substantially similar to the "NO WARRANTY" disclaimer below | ||
19 | * ("Disclaimer") and any redistribution must be conditioned upon | ||
20 | * including a substantially similar Disclaimer requirement for further | ||
21 | * binary redistribution. | ||
22 | * 3. Neither the names of the above-listed copyright holders nor the names | ||
23 | * of any contributors may be used to endorse or promote products derived | ||
24 | * from this software without specific prior written permission. | ||
25 | * | ||
26 | * Alternatively, this software may be distributed under the terms of the | ||
27 | * GNU General Public License ("GPL") version 2 as published by the Free | ||
28 | * Software Foundation. | ||
29 | * | ||
30 | * NO WARRANTY | ||
31 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
32 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
33 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | ||
34 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | ||
35 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
36 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
37 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
38 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
39 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | ||
40 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | ||
41 | * POSSIBILITY OF SUCH DAMAGES. | ||
42 | */ | ||
43 | |||
44 | #include <acpi/acpi.h> | ||
45 | #include <acpi/acevents.h> | ||
46 | #include <acpi/acnamesp.h> | ||
47 | #include <acpi/acinterp.h> | ||
48 | |||
49 | #define _COMPONENT ACPI_EVENTS | ||
50 | ACPI_MODULE_NAME ("evmisc") | ||
51 | |||
52 | |||
53 | /******************************************************************************* | ||
54 | * | ||
55 | * FUNCTION: acpi_ev_is_notify_object | ||
56 | * | ||
57 | * PARAMETERS: Node - Node to check | ||
58 | * | ||
59 | * RETURN: TRUE if notifies allowed on this object | ||
60 | * | ||
61 | * DESCRIPTION: Check type of node for a object that supports notifies. | ||
62 | * | ||
63 | * TBD: This could be replaced by a flag bit in the node. | ||
64 | * | ||
65 | ******************************************************************************/ | ||
66 | |||
67 | u8 | ||
68 | acpi_ev_is_notify_object ( | ||
69 | struct acpi_namespace_node *node) | ||
70 | { | ||
71 | switch (node->type) { | ||
72 | case ACPI_TYPE_DEVICE: | ||
73 | case ACPI_TYPE_PROCESSOR: | ||
74 | case ACPI_TYPE_POWER: | ||
75 | case ACPI_TYPE_THERMAL: | ||
76 | /* | ||
77 | * These are the ONLY objects that can receive ACPI notifications | ||
78 | */ | ||
79 | return (TRUE); | ||
80 | |||
81 | default: | ||
82 | return (FALSE); | ||
83 | } | ||
84 | } | ||
85 | |||
86 | |||
87 | /******************************************************************************* | ||
88 | * | ||
89 | * FUNCTION: acpi_ev_queue_notify_request | ||
90 | * | ||
91 | * PARAMETERS: Node - NS node for the notified object | ||
92 | * notify_value - Value from the Notify() request | ||
93 | * | ||
94 | * RETURN: Status | ||
95 | * | ||
96 | * DESCRIPTION: Dispatch a device notification event to a previously | ||
97 | * installed handler. | ||
98 | * | ||
99 | ******************************************************************************/ | ||
100 | |||
101 | #ifdef ACPI_DEBUG_OUTPUT | ||
102 | static const char *acpi_notify_value_names[] = | ||
103 | { | ||
104 | "Bus Check", | ||
105 | "Device Check", | ||
106 | "Device Wake", | ||
107 | "Eject request", | ||
108 | "Device Check Light", | ||
109 | "Frequency Mismatch", | ||
110 | "Bus Mode Mismatch", | ||
111 | "Power Fault" | ||
112 | }; | ||
113 | #endif | ||
114 | |||
115 | acpi_status | ||
116 | acpi_ev_queue_notify_request ( | ||
117 | struct acpi_namespace_node *node, | ||
118 | u32 notify_value) | ||
119 | { | ||
120 | union acpi_operand_object *obj_desc; | ||
121 | union acpi_operand_object *handler_obj = NULL; | ||
122 | union acpi_generic_state *notify_info; | ||
123 | acpi_status status = AE_OK; | ||
124 | |||
125 | |||
126 | ACPI_FUNCTION_NAME ("ev_queue_notify_request"); | ||
127 | |||
128 | |||
129 | /* | ||
130 | * For value 3 (Ejection Request), some device method may need to be run. | ||
131 | * For value 2 (Device Wake) if _PRW exists, the _PS0 method may need to be run. | ||
132 | * For value 0x80 (Status Change) on the power button or sleep button, | ||
133 | * initiate soft-off or sleep operation? | ||
134 | */ | ||
135 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, | ||
136 | "Dispatching Notify(%X) on node %p\n", notify_value, node)); | ||
137 | |||
138 | if (notify_value <= 7) { | ||
139 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: %s\n", | ||
140 | acpi_notify_value_names[notify_value])); | ||
141 | } | ||
142 | else { | ||
143 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: 0x%2.2X **Device Specific**\n", | ||
144 | notify_value)); | ||
145 | } | ||
146 | |||
147 | /* Get the notify object attached to the NS Node */ | ||
148 | |||
149 | obj_desc = acpi_ns_get_attached_object (node); | ||
150 | if (obj_desc) { | ||
151 | /* We have the notify object, Get the right handler */ | ||
152 | |||
153 | switch (node->type) { | ||
154 | case ACPI_TYPE_DEVICE: | ||
155 | case ACPI_TYPE_THERMAL: | ||
156 | case ACPI_TYPE_PROCESSOR: | ||
157 | case ACPI_TYPE_POWER: | ||
158 | |||
159 | if (notify_value <= ACPI_MAX_SYS_NOTIFY) { | ||
160 | handler_obj = obj_desc->common_notify.system_notify; | ||
161 | } | ||
162 | else { | ||
163 | handler_obj = obj_desc->common_notify.device_notify; | ||
164 | } | ||
165 | break; | ||
166 | |||
167 | default: | ||
168 | /* All other types are not supported */ | ||
169 | return (AE_TYPE); | ||
170 | } | ||
171 | } | ||
172 | |||
173 | /* If there is any handler to run, schedule the dispatcher */ | ||
174 | |||
175 | if ((acpi_gbl_system_notify.handler && (notify_value <= ACPI_MAX_SYS_NOTIFY)) || | ||
176 | (acpi_gbl_device_notify.handler && (notify_value > ACPI_MAX_SYS_NOTIFY)) || | ||
177 | handler_obj) { | ||
178 | notify_info = acpi_ut_create_generic_state (); | ||
179 | if (!notify_info) { | ||
180 | return (AE_NO_MEMORY); | ||
181 | } | ||
182 | |||
183 | notify_info->common.data_type = ACPI_DESC_TYPE_STATE_NOTIFY; | ||
184 | notify_info->notify.node = node; | ||
185 | notify_info->notify.value = (u16) notify_value; | ||
186 | notify_info->notify.handler_obj = handler_obj; | ||
187 | |||
188 | status = acpi_os_queue_for_execution (OSD_PRIORITY_HIGH, | ||
189 | acpi_ev_notify_dispatch, notify_info); | ||
190 | if (ACPI_FAILURE (status)) { | ||
191 | acpi_ut_delete_generic_state (notify_info); | ||
192 | } | ||
193 | } | ||
194 | |||
195 | if (!handler_obj) { | ||
196 | /* | ||
197 | * There is no per-device notify handler for this device. | ||
198 | * This may or may not be a problem. | ||
199 | */ | ||
200 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, | ||
201 | "No notify handler for Notify(%4.4s, %X) node %p\n", | ||
202 | acpi_ut_get_node_name (node), notify_value, node)); | ||
203 | } | ||
204 | |||
205 | return (status); | ||
206 | } | ||
207 | |||
208 | |||
209 | /******************************************************************************* | ||
210 | * | ||
211 | * FUNCTION: acpi_ev_notify_dispatch | ||
212 | * | ||
213 | * PARAMETERS: Context - To be passsed to the notify handler | ||
214 | * | ||
215 | * RETURN: None. | ||
216 | * | ||
217 | * DESCRIPTION: Dispatch a device notification event to a previously | ||
218 | * installed handler. | ||
219 | * | ||
220 | ******************************************************************************/ | ||
221 | |||
222 | void ACPI_SYSTEM_XFACE | ||
223 | acpi_ev_notify_dispatch ( | ||
224 | void *context) | ||
225 | { | ||
226 | union acpi_generic_state *notify_info = (union acpi_generic_state *) context; | ||
227 | acpi_notify_handler global_handler = NULL; | ||
228 | void *global_context = NULL; | ||
229 | union acpi_operand_object *handler_obj; | ||
230 | |||
231 | |||
232 | ACPI_FUNCTION_ENTRY (); | ||
233 | |||
234 | |||
235 | /* | ||
236 | * We will invoke a global notify handler if installed. | ||
237 | * This is done _before_ we invoke the per-device handler attached to the device. | ||
238 | */ | ||
239 | if (notify_info->notify.value <= ACPI_MAX_SYS_NOTIFY) { | ||
240 | /* Global system notification handler */ | ||
241 | |||
242 | if (acpi_gbl_system_notify.handler) { | ||
243 | global_handler = acpi_gbl_system_notify.handler; | ||
244 | global_context = acpi_gbl_system_notify.context; | ||
245 | } | ||
246 | } | ||
247 | else { | ||
248 | /* Global driver notification handler */ | ||
249 | |||
250 | if (acpi_gbl_device_notify.handler) { | ||
251 | global_handler = acpi_gbl_device_notify.handler; | ||
252 | global_context = acpi_gbl_device_notify.context; | ||
253 | } | ||
254 | } | ||
255 | |||
256 | /* Invoke the system handler first, if present */ | ||
257 | |||
258 | if (global_handler) { | ||
259 | global_handler (notify_info->notify.node, notify_info->notify.value, global_context); | ||
260 | } | ||
261 | |||
262 | /* Now invoke the per-device handler, if present */ | ||
263 | |||
264 | handler_obj = notify_info->notify.handler_obj; | ||
265 | if (handler_obj) { | ||
266 | handler_obj->notify.handler (notify_info->notify.node, notify_info->notify.value, | ||
267 | handler_obj->notify.context); | ||
268 | } | ||
269 | |||
270 | /* All done with the info object */ | ||
271 | |||
272 | acpi_ut_delete_generic_state (notify_info); | ||
273 | } | ||
274 | |||
275 | |||
276 | /******************************************************************************* | ||
277 | * | ||
278 | * FUNCTION: acpi_ev_global_lock_thread | ||
279 | * | ||
280 | * PARAMETERS: Context - From thread interface, not used | ||
281 | * | ||
282 | * RETURN: None | ||
283 | * | ||
284 | * DESCRIPTION: Invoked by SCI interrupt handler upon acquisition of the | ||
285 | * Global Lock. Simply signal all threads that are waiting | ||
286 | * for the lock. | ||
287 | * | ||
288 | ******************************************************************************/ | ||
289 | |||
290 | static void ACPI_SYSTEM_XFACE | ||
291 | acpi_ev_global_lock_thread ( | ||
292 | void *context) | ||
293 | { | ||
294 | acpi_status status; | ||
295 | |||
296 | |||
297 | /* Signal threads that are waiting for the lock */ | ||
298 | |||
299 | if (acpi_gbl_global_lock_thread_count) { | ||
300 | /* Send sufficient units to the semaphore */ | ||
301 | |||
302 | status = acpi_os_signal_semaphore (acpi_gbl_global_lock_semaphore, | ||
303 | acpi_gbl_global_lock_thread_count); | ||
304 | if (ACPI_FAILURE (status)) { | ||
305 | ACPI_REPORT_ERROR (("Could not signal Global Lock semaphore\n")); | ||
306 | } | ||
307 | } | ||
308 | } | ||
309 | |||
310 | |||
311 | /******************************************************************************* | ||
312 | * | ||
313 | * FUNCTION: acpi_ev_global_lock_handler | ||
314 | * | ||
315 | * PARAMETERS: Context - From thread interface, not used | ||
316 | * | ||
317 | * RETURN: ACPI_INTERRUPT_HANDLED or ACPI_INTERRUPT_NOT_HANDLED | ||
318 | * | ||
319 | * DESCRIPTION: Invoked directly from the SCI handler when a global lock | ||
320 | * release interrupt occurs. Grab the global lock and queue | ||
321 | * the global lock thread for execution | ||
322 | * | ||
323 | ******************************************************************************/ | ||
324 | |||
325 | static u32 | ||
326 | acpi_ev_global_lock_handler ( | ||
327 | void *context) | ||
328 | { | ||
329 | u8 acquired = FALSE; | ||
330 | acpi_status status; | ||
331 | |||
332 | |||
333 | /* | ||
334 | * Attempt to get the lock | ||
335 | * If we don't get it now, it will be marked pending and we will | ||
336 | * take another interrupt when it becomes free. | ||
337 | */ | ||
338 | ACPI_ACQUIRE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, acquired); | ||
339 | if (acquired) { | ||
340 | /* Got the lock, now wake all threads waiting for it */ | ||
341 | |||
342 | acpi_gbl_global_lock_acquired = TRUE; | ||
343 | |||
344 | /* Run the Global Lock thread which will signal all waiting threads */ | ||
345 | |||
346 | status = acpi_os_queue_for_execution (OSD_PRIORITY_HIGH, | ||
347 | acpi_ev_global_lock_thread, context); | ||
348 | if (ACPI_FAILURE (status)) { | ||
349 | ACPI_REPORT_ERROR (("Could not queue Global Lock thread, %s\n", | ||
350 | acpi_format_exception (status))); | ||
351 | |||
352 | return (ACPI_INTERRUPT_NOT_HANDLED); | ||
353 | } | ||
354 | } | ||
355 | |||
356 | return (ACPI_INTERRUPT_HANDLED); | ||
357 | } | ||
358 | |||
359 | |||
360 | /******************************************************************************* | ||
361 | * | ||
362 | * FUNCTION: acpi_ev_init_global_lock_handler | ||
363 | * | ||
364 | * PARAMETERS: None | ||
365 | * | ||
366 | * RETURN: Status | ||
367 | * | ||
368 | * DESCRIPTION: Install a handler for the global lock release event | ||
369 | * | ||
370 | ******************************************************************************/ | ||
371 | |||
372 | acpi_status | ||
373 | acpi_ev_init_global_lock_handler (void) | ||
374 | { | ||
375 | acpi_status status; | ||
376 | |||
377 | |||
378 | ACPI_FUNCTION_TRACE ("ev_init_global_lock_handler"); | ||
379 | |||
380 | |||
381 | acpi_gbl_global_lock_present = TRUE; | ||
382 | status = acpi_install_fixed_event_handler (ACPI_EVENT_GLOBAL, | ||
383 | acpi_ev_global_lock_handler, NULL); | ||
384 | |||
385 | /* | ||
386 | * If the global lock does not exist on this platform, the attempt | ||
387 | * to enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick) | ||
388 | * Map to AE_OK, but mark global lock as not present. | ||
389 | * Any attempt to actually use the global lock will be flagged | ||
390 | * with an error. | ||
391 | */ | ||
392 | if (status == AE_NO_HARDWARE_RESPONSE) { | ||
393 | acpi_gbl_global_lock_present = FALSE; | ||
394 | status = AE_OK; | ||
395 | } | ||
396 | |||
397 | return_ACPI_STATUS (status); | ||
398 | } | ||
399 | |||
400 | |||
401 | /****************************************************************************** | ||
402 | * | ||
403 | * FUNCTION: acpi_ev_acquire_global_lock | ||
404 | * | ||
405 | * PARAMETERS: Timeout - Max time to wait for the lock, in millisec. | ||
406 | * | ||
407 | * RETURN: Status | ||
408 | * | ||
409 | * DESCRIPTION: Attempt to gain ownership of the Global Lock. | ||
410 | * | ||
411 | *****************************************************************************/ | ||
412 | |||
413 | acpi_status | ||
414 | acpi_ev_acquire_global_lock ( | ||
415 | u16 timeout) | ||
416 | { | ||
417 | acpi_status status = AE_OK; | ||
418 | u8 acquired = FALSE; | ||
419 | |||
420 | |||
421 | ACPI_FUNCTION_TRACE ("ev_acquire_global_lock"); | ||
422 | |||
423 | |||
424 | #ifndef ACPI_APPLICATION | ||
425 | /* Make sure that we actually have a global lock */ | ||
426 | |||
427 | if (!acpi_gbl_global_lock_present) { | ||
428 | return_ACPI_STATUS (AE_NO_GLOBAL_LOCK); | ||
429 | } | ||
430 | #endif | ||
431 | |||
432 | /* One more thread wants the global lock */ | ||
433 | |||
434 | acpi_gbl_global_lock_thread_count++; | ||
435 | |||
436 | /* If we (OS side vs. BIOS side) have the hardware lock already, we are done */ | ||
437 | |||
438 | if (acpi_gbl_global_lock_acquired) { | ||
439 | return_ACPI_STATUS (AE_OK); | ||
440 | } | ||
441 | |||
442 | /* We must acquire the actual hardware lock */ | ||
443 | |||
444 | ACPI_ACQUIRE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, acquired); | ||
445 | if (acquired) { | ||
446 | /* We got the lock */ | ||
447 | |||
448 | ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Acquired the HW Global Lock\n")); | ||
449 | |||
450 | acpi_gbl_global_lock_acquired = TRUE; | ||
451 | return_ACPI_STATUS (AE_OK); | ||
452 | } | ||
453 | |||
454 | /* | ||
455 | * Did not get the lock. The pending bit was set above, and we must now | ||
456 | * wait until we get the global lock released interrupt. | ||
457 | */ | ||
458 | ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Waiting for the HW Global Lock\n")); | ||
459 | |||
460 | /* | ||
461 | * Acquire the global lock semaphore first. | ||
462 | * Since this wait will block, we must release the interpreter | ||
463 | */ | ||
464 | status = acpi_ex_system_wait_semaphore (acpi_gbl_global_lock_semaphore, | ||
465 | timeout); | ||
466 | return_ACPI_STATUS (status); | ||
467 | } | ||
468 | |||
469 | |||
470 | /******************************************************************************* | ||
471 | * | ||
472 | * FUNCTION: acpi_ev_release_global_lock | ||
473 | * | ||
474 | * PARAMETERS: None | ||
475 | * | ||
476 | * RETURN: Status | ||
477 | * | ||
478 | * DESCRIPTION: Releases ownership of the Global Lock. | ||
479 | * | ||
480 | ******************************************************************************/ | ||
481 | |||
482 | acpi_status | ||
483 | acpi_ev_release_global_lock (void) | ||
484 | { | ||
485 | u8 pending = FALSE; | ||
486 | acpi_status status = AE_OK; | ||
487 | |||
488 | |||
489 | ACPI_FUNCTION_TRACE ("ev_release_global_lock"); | ||
490 | |||
491 | |||
492 | if (!acpi_gbl_global_lock_thread_count) { | ||
493 | ACPI_REPORT_WARNING(("Cannot release HW Global Lock, it has not been acquired\n")); | ||
494 | return_ACPI_STATUS (AE_NOT_ACQUIRED); | ||
495 | } | ||
496 | |||
497 | /* One fewer thread has the global lock */ | ||
498 | |||
499 | acpi_gbl_global_lock_thread_count--; | ||
500 | if (acpi_gbl_global_lock_thread_count) { | ||
501 | /* There are still some threads holding the lock, cannot release */ | ||
502 | |||
503 | return_ACPI_STATUS (AE_OK); | ||
504 | } | ||
505 | |||
506 | /* | ||
507 | * No more threads holding lock, we can do the actual hardware | ||
508 | * release | ||
509 | */ | ||
510 | ACPI_RELEASE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, pending); | ||
511 | acpi_gbl_global_lock_acquired = FALSE; | ||
512 | |||
513 | /* | ||
514 | * If the pending bit was set, we must write GBL_RLS to the control | ||
515 | * register | ||
516 | */ | ||
517 | if (pending) { | ||
518 | status = acpi_set_register (ACPI_BITREG_GLOBAL_LOCK_RELEASE, 1, ACPI_MTX_LOCK); | ||
519 | } | ||
520 | |||
521 | return_ACPI_STATUS (status); | ||
522 | } | ||
523 | |||
524 | |||
525 | /****************************************************************************** | ||
526 | * | ||
527 | * FUNCTION: acpi_ev_terminate | ||
528 | * | ||
529 | * PARAMETERS: none | ||
530 | * | ||
531 | * RETURN: none | ||
532 | * | ||
533 | * DESCRIPTION: Disable events and free memory allocated for table storage. | ||
534 | * | ||
535 | ******************************************************************************/ | ||
536 | |||
537 | void | ||
538 | acpi_ev_terminate (void) | ||
539 | { | ||
540 | acpi_native_uint i; | ||
541 | acpi_status status; | ||
542 | |||
543 | |||
544 | ACPI_FUNCTION_TRACE ("ev_terminate"); | ||
545 | |||
546 | |||
547 | if (acpi_gbl_events_initialized) { | ||
548 | /* | ||
549 | * Disable all event-related functionality. | ||
550 | * In all cases, on error, print a message but obviously we don't abort. | ||
551 | */ | ||
552 | |||
553 | /* Disable all fixed events */ | ||
554 | |||
555 | for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) { | ||
556 | status = acpi_disable_event ((u32) i, 0); | ||
557 | if (ACPI_FAILURE (status)) { | ||
558 | ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not disable fixed event %d\n", (u32) i)); | ||
559 | } | ||
560 | } | ||
561 | |||
562 | /* Disable all GPEs in all GPE blocks */ | ||
563 | |||
564 | status = acpi_ev_walk_gpe_list (acpi_hw_disable_gpe_block, ACPI_NOT_ISR); | ||
565 | |||
566 | /* Remove SCI handler */ | ||
567 | |||
568 | status = acpi_ev_remove_sci_handler (); | ||
569 | if (ACPI_FAILURE(status)) { | ||
570 | ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not remove SCI handler\n")); | ||
571 | } | ||
572 | } | ||
573 | |||
574 | /* Deallocate all handler objects installed within GPE info structs */ | ||
575 | |||
576 | status = acpi_ev_walk_gpe_list (acpi_ev_delete_gpe_handlers, ACPI_NOT_ISR); | ||
577 | |||
578 | /* Return to original mode if necessary */ | ||
579 | |||
580 | if (acpi_gbl_original_mode == ACPI_SYS_MODE_LEGACY) { | ||
581 | status = acpi_disable (); | ||
582 | if (ACPI_FAILURE (status)) { | ||
583 | ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "acpi_disable failed\n")); | ||
584 | } | ||
585 | } | ||
586 | return_VOID; | ||
587 | } | ||
588 | |||