1 /******************************************************************************
3 * Module Name: evxface - External interfaces for ACPI events
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2006, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <linux/module.h>
46 #include <acpi/acpi.h>
47 #include <acpi/acnamesp.h>
48 #include <acpi/acevents.h>
49 #include <acpi/acinterp.h>
51 #define _COMPONENT ACPI_EVENTS
52 ACPI_MODULE_NAME("evxface")
54 /*******************************************************************************
56 * FUNCTION: acpi_install_exception_handler
58 * PARAMETERS: Handler - Pointer to the handler function for the
63 * DESCRIPTION: Saves the pointer to the handler function
65 ******************************************************************************/
66 #ifdef ACPI_FUTURE_USAGE
67 acpi_status acpi_install_exception_handler(acpi_exception_handler handler)
71 ACPI_FUNCTION_TRACE("acpi_install_exception_handler");
73 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
74 if (ACPI_FAILURE(status)) {
75 return_ACPI_STATUS(status);
78 /* Don't allow two handlers. */
80 if (acpi_gbl_exception_handler) {
81 status = AE_ALREADY_EXISTS;
85 /* Install the handler */
87 acpi_gbl_exception_handler = handler;
90 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
91 return_ACPI_STATUS(status);
93 #endif /* ACPI_FUTURE_USAGE */
95 /*******************************************************************************
97 * FUNCTION: acpi_install_fixed_event_handler
99 * PARAMETERS: Event - Event type to enable.
100 * Handler - Pointer to the handler function for the
102 * Context - Value passed to the handler on each GPE
106 * DESCRIPTION: Saves the pointer to the handler function and then enables the
109 ******************************************************************************/
112 acpi_install_fixed_event_handler(u32 event,
113 acpi_event_handler handler, void *context)
117 ACPI_FUNCTION_TRACE("acpi_install_fixed_event_handler");
119 /* Parameter validation */
121 if (event > ACPI_EVENT_MAX) {
122 return_ACPI_STATUS(AE_BAD_PARAMETER);
125 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
126 if (ACPI_FAILURE(status)) {
127 return_ACPI_STATUS(status);
130 /* Don't allow two handlers. */
132 if (NULL != acpi_gbl_fixed_event_handlers[event].handler) {
133 status = AE_ALREADY_EXISTS;
137 /* Install the handler before enabling the event */
139 acpi_gbl_fixed_event_handlers[event].handler = handler;
140 acpi_gbl_fixed_event_handlers[event].context = context;
142 status = acpi_clear_event(event);
143 if (ACPI_SUCCESS(status))
144 status = acpi_enable_event(event, 0);
145 if (ACPI_FAILURE(status)) {
146 ACPI_REPORT_WARNING(("Could not enable fixed event %X\n",
149 /* Remove the handler */
151 acpi_gbl_fixed_event_handlers[event].handler = NULL;
152 acpi_gbl_fixed_event_handlers[event].context = NULL;
154 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
155 "Enabled fixed event %X, Handler=%p\n", event,
160 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
161 return_ACPI_STATUS(status);
164 EXPORT_SYMBOL(acpi_install_fixed_event_handler);
166 /*******************************************************************************
168 * FUNCTION: acpi_remove_fixed_event_handler
170 * PARAMETERS: Event - Event type to disable.
171 * Handler - Address of the handler
175 * DESCRIPTION: Disables the event and unregisters the event handler.
177 ******************************************************************************/
180 acpi_remove_fixed_event_handler(u32 event, acpi_event_handler handler)
182 acpi_status status = AE_OK;
184 ACPI_FUNCTION_TRACE("acpi_remove_fixed_event_handler");
186 /* Parameter validation */
188 if (event > ACPI_EVENT_MAX) {
189 return_ACPI_STATUS(AE_BAD_PARAMETER);
192 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
193 if (ACPI_FAILURE(status)) {
194 return_ACPI_STATUS(status);
197 /* Disable the event before removing the handler */
199 status = acpi_disable_event(event, 0);
201 /* Always Remove the handler */
203 acpi_gbl_fixed_event_handlers[event].handler = NULL;
204 acpi_gbl_fixed_event_handlers[event].context = NULL;
206 if (ACPI_FAILURE(status)) {
207 ACPI_REPORT_WARNING(("Could not write to fixed event enable register %X\n", event));
209 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Disabled fixed event %X\n",
213 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
214 return_ACPI_STATUS(status);
217 EXPORT_SYMBOL(acpi_remove_fixed_event_handler);
219 /*******************************************************************************
221 * FUNCTION: acpi_install_notify_handler
223 * PARAMETERS: Device - The device for which notifies will be handled
224 * handler_type - The type of handler:
225 * ACPI_SYSTEM_NOTIFY: system_handler (00-7f)
226 * ACPI_DEVICE_NOTIFY: driver_handler (80-ff)
227 * ACPI_ALL_NOTIFY: both system and device
228 * Handler - Address of the handler
229 * Context - Value passed to the handler on each GPE
233 * DESCRIPTION: Install a handler for notifies on an ACPI device
235 ******************************************************************************/
238 acpi_install_notify_handler(acpi_handle device,
240 acpi_notify_handler handler, void *context)
242 union acpi_operand_object *obj_desc;
243 union acpi_operand_object *notify_obj;
244 struct acpi_namespace_node *node;
247 ACPI_FUNCTION_TRACE("acpi_install_notify_handler");
249 /* Parameter validation */
252 (!handler) || (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE)) {
253 return_ACPI_STATUS(AE_BAD_PARAMETER);
256 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
257 if (ACPI_FAILURE(status)) {
258 return_ACPI_STATUS(status);
261 /* Convert and validate the device handle */
263 node = acpi_ns_map_handle_to_node(device);
265 status = AE_BAD_PARAMETER;
266 goto unlock_and_exit;
271 * Registering a notify handler on the root object indicates that the
272 * caller wishes to receive notifications for all objects. Note that
273 * only one <external> global handler can be regsitered (per notify type).
275 if (device == ACPI_ROOT_OBJECT) {
276 /* Make sure the handler is not already installed */
278 if (((handler_type & ACPI_SYSTEM_NOTIFY) &&
279 acpi_gbl_system_notify.handler) ||
280 ((handler_type & ACPI_DEVICE_NOTIFY) &&
281 acpi_gbl_device_notify.handler)) {
282 status = AE_ALREADY_EXISTS;
283 goto unlock_and_exit;
286 if (handler_type & ACPI_SYSTEM_NOTIFY) {
287 acpi_gbl_system_notify.node = node;
288 acpi_gbl_system_notify.handler = handler;
289 acpi_gbl_system_notify.context = context;
292 if (handler_type & ACPI_DEVICE_NOTIFY) {
293 acpi_gbl_device_notify.node = node;
294 acpi_gbl_device_notify.handler = handler;
295 acpi_gbl_device_notify.context = context;
298 /* Global notify handler installed */
303 * Caller will only receive notifications specific to the target object.
304 * Note that only certain object types can receive notifications.
307 /* Notifies allowed on this object? */
309 if (!acpi_ev_is_notify_object(node)) {
311 goto unlock_and_exit;
314 /* Check for an existing internal object */
316 obj_desc = acpi_ns_get_attached_object(node);
318 /* Object exists - make sure there's no handler */
320 if (((handler_type & ACPI_SYSTEM_NOTIFY) &&
321 obj_desc->common_notify.system_notify) ||
322 ((handler_type & ACPI_DEVICE_NOTIFY) &&
323 obj_desc->common_notify.device_notify)) {
324 status = AE_ALREADY_EXISTS;
325 goto unlock_and_exit;
328 /* Create a new object */
330 obj_desc = acpi_ut_create_internal_object(node->type);
332 status = AE_NO_MEMORY;
333 goto unlock_and_exit;
336 /* Attach new object to the Node */
339 acpi_ns_attach_object(device, obj_desc, node->type);
341 /* Remove local reference to the object */
343 acpi_ut_remove_reference(obj_desc);
344 if (ACPI_FAILURE(status)) {
345 goto unlock_and_exit;
349 /* Install the handler */
352 acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_NOTIFY);
354 status = AE_NO_MEMORY;
355 goto unlock_and_exit;
358 notify_obj->notify.node = node;
359 notify_obj->notify.handler = handler;
360 notify_obj->notify.context = context;
362 if (handler_type & ACPI_SYSTEM_NOTIFY) {
363 obj_desc->common_notify.system_notify = notify_obj;
366 if (handler_type & ACPI_DEVICE_NOTIFY) {
367 obj_desc->common_notify.device_notify = notify_obj;
370 if (handler_type == ACPI_ALL_NOTIFY) {
371 /* Extra ref if installed in both */
373 acpi_ut_add_reference(notify_obj);
378 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
379 return_ACPI_STATUS(status);
382 EXPORT_SYMBOL(acpi_install_notify_handler);
384 /*******************************************************************************
386 * FUNCTION: acpi_remove_notify_handler
388 * PARAMETERS: Device - The device for which notifies will be handled
389 * handler_type - The type of handler:
390 * ACPI_SYSTEM_NOTIFY: system_handler (00-7f)
391 * ACPI_DEVICE_NOTIFY: driver_handler (80-ff)
392 * ACPI_ALL_NOTIFY: both system and device
393 * Handler - Address of the handler
397 * DESCRIPTION: Remove a handler for notifies on an ACPI device
399 ******************************************************************************/
402 acpi_remove_notify_handler(acpi_handle device,
403 u32 handler_type, acpi_notify_handler handler)
405 union acpi_operand_object *notify_obj;
406 union acpi_operand_object *obj_desc;
407 struct acpi_namespace_node *node;
410 ACPI_FUNCTION_TRACE("acpi_remove_notify_handler");
412 /* Parameter validation */
415 (!handler) || (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE)) {
416 return_ACPI_STATUS(AE_BAD_PARAMETER);
419 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
420 if (ACPI_FAILURE(status)) {
421 return_ACPI_STATUS(status);
424 /* Convert and validate the device handle */
426 node = acpi_ns_map_handle_to_node(device);
428 status = AE_BAD_PARAMETER;
429 goto unlock_and_exit;
434 if (device == ACPI_ROOT_OBJECT) {
435 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
436 "Removing notify handler for namespace root object\n"));
438 if (((handler_type & ACPI_SYSTEM_NOTIFY) &&
439 !acpi_gbl_system_notify.handler) ||
440 ((handler_type & ACPI_DEVICE_NOTIFY) &&
441 !acpi_gbl_device_notify.handler)) {
442 status = AE_NOT_EXIST;
443 goto unlock_and_exit;
446 /* Make sure all deferred tasks are completed */
448 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
449 acpi_os_wait_events_complete(NULL);
450 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
451 if (ACPI_FAILURE(status)) {
452 return_ACPI_STATUS(status);
455 if (handler_type & ACPI_SYSTEM_NOTIFY) {
456 acpi_gbl_system_notify.node = NULL;
457 acpi_gbl_system_notify.handler = NULL;
458 acpi_gbl_system_notify.context = NULL;
461 if (handler_type & ACPI_DEVICE_NOTIFY) {
462 acpi_gbl_device_notify.node = NULL;
463 acpi_gbl_device_notify.handler = NULL;
464 acpi_gbl_device_notify.context = NULL;
468 /* All Other Objects */
471 /* Notifies allowed on this object? */
473 if (!acpi_ev_is_notify_object(node)) {
475 goto unlock_and_exit;
478 /* Check for an existing internal object */
480 obj_desc = acpi_ns_get_attached_object(node);
482 status = AE_NOT_EXIST;
483 goto unlock_and_exit;
486 /* Object exists - make sure there's an existing handler */
488 if (handler_type & ACPI_SYSTEM_NOTIFY) {
489 notify_obj = obj_desc->common_notify.system_notify;
491 (notify_obj->notify.handler != handler)) {
492 status = AE_BAD_PARAMETER;
493 goto unlock_and_exit;
495 /* Make sure all deferred tasks are completed */
497 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
498 acpi_os_wait_events_complete(NULL);
499 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
500 if (ACPI_FAILURE(status)) {
501 return_ACPI_STATUS(status);
504 /* Remove the handler */
505 obj_desc->common_notify.system_notify = NULL;
506 acpi_ut_remove_reference(notify_obj);
509 if (handler_type & ACPI_DEVICE_NOTIFY) {
510 notify_obj = obj_desc->common_notify.device_notify;
512 (notify_obj->notify.handler != handler)) {
513 status = AE_BAD_PARAMETER;
514 goto unlock_and_exit;
516 /* Make sure all deferred tasks are completed */
518 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
519 acpi_os_wait_events_complete(NULL);
520 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
521 if (ACPI_FAILURE(status)) {
522 return_ACPI_STATUS(status);
525 /* Remove the handler */
526 obj_desc->common_notify.device_notify = NULL;
527 acpi_ut_remove_reference(notify_obj);
532 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
533 return_ACPI_STATUS(status);
536 EXPORT_SYMBOL(acpi_remove_notify_handler);
538 /*******************************************************************************
540 * FUNCTION: acpi_install_gpe_handler
542 * PARAMETERS: gpe_device - Namespace node for the GPE (NULL for FADT
544 * gpe_number - The GPE number within the GPE block
545 * Type - Whether this GPE should be treated as an
546 * edge- or level-triggered interrupt.
547 * Address - Address of the handler
548 * Context - Value passed to the handler on each GPE
552 * DESCRIPTION: Install a handler for a General Purpose Event.
554 ******************************************************************************/
557 acpi_install_gpe_handler(acpi_handle gpe_device,
559 u32 type, acpi_event_handler address, void *context)
561 struct acpi_gpe_event_info *gpe_event_info;
562 struct acpi_handler_info *handler;
564 acpi_native_uint flags;
566 ACPI_FUNCTION_TRACE("acpi_install_gpe_handler");
568 /* Parameter validation */
570 if ((!address) || (type > ACPI_GPE_XRUPT_TYPE_MASK)) {
571 return_ACPI_STATUS(AE_BAD_PARAMETER);
574 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
575 if (ACPI_FAILURE(status)) {
576 return_ACPI_STATUS(status);
579 /* Ensure that we have a valid GPE number */
581 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
582 if (!gpe_event_info) {
583 status = AE_BAD_PARAMETER;
584 goto unlock_and_exit;
587 /* Make sure that there isn't a handler there already */
589 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
590 ACPI_GPE_DISPATCH_HANDLER) {
591 status = AE_ALREADY_EXISTS;
592 goto unlock_and_exit;
595 /* Allocate and init handler object */
597 handler = ACPI_MEM_CALLOCATE(sizeof(struct acpi_handler_info));
599 status = AE_NO_MEMORY;
600 goto unlock_and_exit;
603 handler->address = address;
604 handler->context = context;
605 handler->method_node = gpe_event_info->dispatch.method_node;
607 /* Disable the GPE before installing the handler */
609 status = acpi_ev_disable_gpe(gpe_event_info);
610 if (ACPI_FAILURE(status)) {
611 goto unlock_and_exit;
614 /* Install the handler */
616 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
617 gpe_event_info->dispatch.handler = handler;
619 /* Setup up dispatch flags to indicate handler (vs. method) */
621 gpe_event_info->flags &= ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK); /* Clear bits */
622 gpe_event_info->flags |= (u8) (type | ACPI_GPE_DISPATCH_HANDLER);
624 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
627 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
628 return_ACPI_STATUS(status);
631 EXPORT_SYMBOL(acpi_install_gpe_handler);
633 /*******************************************************************************
635 * FUNCTION: acpi_remove_gpe_handler
637 * PARAMETERS: gpe_device - Namespace node for the GPE (NULL for FADT
639 * gpe_number - The event to remove a handler
640 * Address - Address of the handler
644 * DESCRIPTION: Remove a handler for a General Purpose acpi_event.
646 ******************************************************************************/
649 acpi_remove_gpe_handler(acpi_handle gpe_device,
650 u32 gpe_number, acpi_event_handler address)
652 struct acpi_gpe_event_info *gpe_event_info;
653 struct acpi_handler_info *handler;
655 acpi_native_uint flags;
657 ACPI_FUNCTION_TRACE("acpi_remove_gpe_handler");
659 /* Parameter validation */
662 return_ACPI_STATUS(AE_BAD_PARAMETER);
665 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
666 if (ACPI_FAILURE(status)) {
667 return_ACPI_STATUS(status);
670 /* Ensure that we have a valid GPE number */
672 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
673 if (!gpe_event_info) {
674 status = AE_BAD_PARAMETER;
675 goto unlock_and_exit;
678 /* Make sure that a handler is indeed installed */
680 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) !=
681 ACPI_GPE_DISPATCH_HANDLER) {
682 status = AE_NOT_EXIST;
683 goto unlock_and_exit;
686 /* Make sure that the installed handler is the same */
688 if (gpe_event_info->dispatch.handler->address != address) {
689 status = AE_BAD_PARAMETER;
690 goto unlock_and_exit;
693 /* Disable the GPE before removing the handler */
695 status = acpi_ev_disable_gpe(gpe_event_info);
696 if (ACPI_FAILURE(status)) {
697 goto unlock_and_exit;
700 /* Make sure all deferred tasks are completed */
702 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
703 acpi_os_wait_events_complete(NULL);
704 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
705 if (ACPI_FAILURE(status)) {
706 return_ACPI_STATUS(status);
709 /* Remove the handler */
711 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
712 handler = gpe_event_info->dispatch.handler;
714 /* Restore Method node (if any), set dispatch flags */
716 gpe_event_info->dispatch.method_node = handler->method_node;
717 gpe_event_info->flags &= ~ACPI_GPE_DISPATCH_MASK; /* Clear bits */
718 if (handler->method_node) {
719 gpe_event_info->flags |= ACPI_GPE_DISPATCH_METHOD;
721 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
723 /* Now we can free the handler object */
725 ACPI_MEM_FREE(handler);
728 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
729 return_ACPI_STATUS(status);
732 EXPORT_SYMBOL(acpi_remove_gpe_handler);
734 /*******************************************************************************
736 * FUNCTION: acpi_acquire_global_lock
738 * PARAMETERS: Timeout - How long the caller is willing to wait
739 * Handle - Where the handle to the lock is returned
744 * DESCRIPTION: Acquire the ACPI Global Lock
746 ******************************************************************************/
748 acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle)
753 return (AE_BAD_PARAMETER);
756 status = acpi_ex_enter_interpreter();
757 if (ACPI_FAILURE(status)) {
761 status = acpi_ev_acquire_global_lock(timeout);
762 acpi_ex_exit_interpreter();
764 if (ACPI_SUCCESS(status)) {
765 acpi_gbl_global_lock_handle++;
766 *handle = acpi_gbl_global_lock_handle;
772 EXPORT_SYMBOL(acpi_acquire_global_lock);
774 /*******************************************************************************
776 * FUNCTION: acpi_release_global_lock
778 * PARAMETERS: Handle - Returned from acpi_acquire_global_lock
782 * DESCRIPTION: Release the ACPI Global Lock. The handle must be valid.
784 ******************************************************************************/
786 acpi_status acpi_release_global_lock(u32 handle)
790 if (handle != acpi_gbl_global_lock_handle) {
791 return (AE_NOT_ACQUIRED);
794 status = acpi_ev_release_global_lock();
798 EXPORT_SYMBOL(acpi_release_global_lock);