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
);