aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi/events/evmisc.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /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.c588
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
67u8
68acpi_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
102static 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
115acpi_status
116acpi_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
222void ACPI_SYSTEM_XFACE
223acpi_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
290static void ACPI_SYSTEM_XFACE
291acpi_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
325static u32
326acpi_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
372acpi_status
373acpi_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
413acpi_status
414acpi_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
482acpi_status
483acpi_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
537void
538acpi_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