aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi/acpica/evxface.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/acpi/acpica/evxface.c')
-rw-r--r--drivers/acpi/acpica/evxface.c821
1 files changed, 821 insertions, 0 deletions
diff --git a/drivers/acpi/acpica/evxface.c b/drivers/acpi/acpica/evxface.c
new file mode 100644
index 000000000000..3b6a069f5b06
--- /dev/null
+++ b/drivers/acpi/acpica/evxface.c
@@ -0,0 +1,821 @@
1/******************************************************************************
2 *
3 * Module Name: evxface - External interfaces for ACPI events
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2008, Intel Corp.
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/accommon.h>
46#include <acpi/acnamesp.h>
47#include <acpi/acevents.h>
48#include <acpi/acinterp.h>
49
50#define _COMPONENT ACPI_EVENTS
51ACPI_MODULE_NAME("evxface")
52
53/*******************************************************************************
54 *
55 * FUNCTION: acpi_install_exception_handler
56 *
57 * PARAMETERS: Handler - Pointer to the handler function for the
58 * event
59 *
60 * RETURN: Status
61 *
62 * DESCRIPTION: Saves the pointer to the handler function
63 *
64 ******************************************************************************/
65#ifdef ACPI_FUTURE_USAGE
66acpi_status acpi_install_exception_handler(acpi_exception_handler handler)
67{
68 acpi_status status;
69
70 ACPI_FUNCTION_TRACE(acpi_install_exception_handler);
71
72 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
73 if (ACPI_FAILURE(status)) {
74 return_ACPI_STATUS(status);
75 }
76
77 /* Don't allow two handlers. */
78
79 if (acpi_gbl_exception_handler) {
80 status = AE_ALREADY_EXISTS;
81 goto cleanup;
82 }
83
84 /* Install the handler */
85
86 acpi_gbl_exception_handler = handler;
87
88 cleanup:
89 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
90 return_ACPI_STATUS(status);
91}
92
93ACPI_EXPORT_SYMBOL(acpi_install_exception_handler)
94#endif /* ACPI_FUTURE_USAGE */
95/*******************************************************************************
96 *
97 * FUNCTION: acpi_install_fixed_event_handler
98 *
99 * PARAMETERS: Event - Event type to enable.
100 * Handler - Pointer to the handler function for the
101 * event
102 * Context - Value passed to the handler on each GPE
103 *
104 * RETURN: Status
105 *
106 * DESCRIPTION: Saves the pointer to the handler function and then enables the
107 * event.
108 *
109 ******************************************************************************/
110acpi_status
111acpi_install_fixed_event_handler(u32 event,
112 acpi_event_handler handler, void *context)
113{
114 acpi_status status;
115
116 ACPI_FUNCTION_TRACE(acpi_install_fixed_event_handler);
117
118 /* Parameter validation */
119
120 if (event > ACPI_EVENT_MAX) {
121 return_ACPI_STATUS(AE_BAD_PARAMETER);
122 }
123
124 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
125 if (ACPI_FAILURE(status)) {
126 return_ACPI_STATUS(status);
127 }
128
129 /* Don't allow two handlers. */
130
131 if (NULL != acpi_gbl_fixed_event_handlers[event].handler) {
132 status = AE_ALREADY_EXISTS;
133 goto cleanup;
134 }
135
136 /* Install the handler before enabling the event */
137
138 acpi_gbl_fixed_event_handlers[event].handler = handler;
139 acpi_gbl_fixed_event_handlers[event].context = context;
140
141 status = acpi_clear_event(event);
142 if (ACPI_SUCCESS(status))
143 status = acpi_enable_event(event, 0);
144 if (ACPI_FAILURE(status)) {
145 ACPI_WARNING((AE_INFO, "Could not enable fixed event %X",
146 event));
147
148 /* Remove the handler */
149
150 acpi_gbl_fixed_event_handlers[event].handler = NULL;
151 acpi_gbl_fixed_event_handlers[event].context = NULL;
152 } else {
153 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
154 "Enabled fixed event %X, Handler=%p\n", event,
155 handler));
156 }
157
158 cleanup:
159 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
160 return_ACPI_STATUS(status);
161}
162
163ACPI_EXPORT_SYMBOL(acpi_install_fixed_event_handler)
164
165/*******************************************************************************
166 *
167 * FUNCTION: acpi_remove_fixed_event_handler
168 *
169 * PARAMETERS: Event - Event type to disable.
170 * Handler - Address of the handler
171 *
172 * RETURN: Status
173 *
174 * DESCRIPTION: Disables the event and unregisters the event handler.
175 *
176 ******************************************************************************/
177acpi_status
178acpi_remove_fixed_event_handler(u32 event, acpi_event_handler handler)
179{
180 acpi_status status = AE_OK;
181
182 ACPI_FUNCTION_TRACE(acpi_remove_fixed_event_handler);
183
184 /* Parameter validation */
185
186 if (event > ACPI_EVENT_MAX) {
187 return_ACPI_STATUS(AE_BAD_PARAMETER);
188 }
189
190 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
191 if (ACPI_FAILURE(status)) {
192 return_ACPI_STATUS(status);
193 }
194
195 /* Disable the event before removing the handler */
196
197 status = acpi_disable_event(event, 0);
198
199 /* Always Remove the handler */
200
201 acpi_gbl_fixed_event_handlers[event].handler = NULL;
202 acpi_gbl_fixed_event_handlers[event].context = NULL;
203
204 if (ACPI_FAILURE(status)) {
205 ACPI_WARNING((AE_INFO,
206 "Could not write to fixed event enable register %X",
207 event));
208 } else {
209 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Disabled fixed event %X\n",
210 event));
211 }
212
213 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
214 return_ACPI_STATUS(status);
215}
216
217ACPI_EXPORT_SYMBOL(acpi_remove_fixed_event_handler)
218
219/*******************************************************************************
220 *
221 * FUNCTION: acpi_install_notify_handler
222 *
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
230 *
231 * RETURN: Status
232 *
233 * DESCRIPTION: Install a handler for notifies on an ACPI device
234 *
235 ******************************************************************************/
236acpi_status
237acpi_install_notify_handler(acpi_handle device,
238 u32 handler_type,
239 acpi_notify_handler handler, void *context)
240{
241 union acpi_operand_object *obj_desc;
242 union acpi_operand_object *notify_obj;
243 struct acpi_namespace_node *node;
244 acpi_status status;
245
246 ACPI_FUNCTION_TRACE(acpi_install_notify_handler);
247
248 /* Parameter validation */
249
250 if ((!device) ||
251 (!handler) || (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE)) {
252 return_ACPI_STATUS(AE_BAD_PARAMETER);
253 }
254
255 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
256 if (ACPI_FAILURE(status)) {
257 return_ACPI_STATUS(status);
258 }
259
260 /* Convert and validate the device handle */
261
262 node = acpi_ns_map_handle_to_node(device);
263 if (!node) {
264 status = AE_BAD_PARAMETER;
265 goto unlock_and_exit;
266 }
267
268 /*
269 * Root Object:
270 * Registering a notify handler on the root object indicates that the
271 * caller wishes to receive notifications for all objects. Note that
272 * only one <external> global handler can be regsitered (per notify type).
273 */
274 if (device == ACPI_ROOT_OBJECT) {
275
276 /* Make sure the handler is not already installed */
277
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;
284 }
285
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;
290 }
291
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;
296 }
297
298 /* Global notify handler installed */
299 }
300
301 /*
302 * All Other Objects:
303 * Caller will only receive notifications specific to the target object.
304 * Note that only certain object types can receive notifications.
305 */
306 else {
307 /* Notifies allowed on this object? */
308
309 if (!acpi_ev_is_notify_object(node)) {
310 status = AE_TYPE;
311 goto unlock_and_exit;
312 }
313
314 /* Check for an existing internal object */
315
316 obj_desc = acpi_ns_get_attached_object(node);
317 if (obj_desc) {
318
319 /* Object exists - make sure there's no handler */
320
321 if (((handler_type & ACPI_SYSTEM_NOTIFY) &&
322 obj_desc->common_notify.system_notify) ||
323 ((handler_type & ACPI_DEVICE_NOTIFY) &&
324 obj_desc->common_notify.device_notify)) {
325 status = AE_ALREADY_EXISTS;
326 goto unlock_and_exit;
327 }
328 } else {
329 /* Create a new object */
330
331 obj_desc = acpi_ut_create_internal_object(node->type);
332 if (!obj_desc) {
333 status = AE_NO_MEMORY;
334 goto unlock_and_exit;
335 }
336
337 /* Attach new object to the Node */
338
339 status =
340 acpi_ns_attach_object(device, obj_desc, node->type);
341
342 /* Remove local reference to the object */
343
344 acpi_ut_remove_reference(obj_desc);
345 if (ACPI_FAILURE(status)) {
346 goto unlock_and_exit;
347 }
348 }
349
350 /* Install the handler */
351
352 notify_obj =
353 acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_NOTIFY);
354 if (!notify_obj) {
355 status = AE_NO_MEMORY;
356 goto unlock_and_exit;
357 }
358
359 notify_obj->notify.node = node;
360 notify_obj->notify.handler = handler;
361 notify_obj->notify.context = context;
362
363 if (handler_type & ACPI_SYSTEM_NOTIFY) {
364 obj_desc->common_notify.system_notify = notify_obj;
365 }
366
367 if (handler_type & ACPI_DEVICE_NOTIFY) {
368 obj_desc->common_notify.device_notify = notify_obj;
369 }
370
371 if (handler_type == ACPI_ALL_NOTIFY) {
372
373 /* Extra ref if installed in both */
374
375 acpi_ut_add_reference(notify_obj);
376 }
377 }
378
379 unlock_and_exit:
380 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
381 return_ACPI_STATUS(status);
382}
383
384ACPI_EXPORT_SYMBOL(acpi_install_notify_handler)
385
386/*******************************************************************************
387 *
388 * FUNCTION: acpi_remove_notify_handler
389 *
390 * PARAMETERS: Device - The device for which notifies will be handled
391 * handler_type - The type of handler:
392 * ACPI_SYSTEM_NOTIFY: system_handler (00-7f)
393 * ACPI_DEVICE_NOTIFY: driver_handler (80-ff)
394 * ACPI_ALL_NOTIFY: both system and device
395 * Handler - Address of the handler
396 *
397 * RETURN: Status
398 *
399 * DESCRIPTION: Remove a handler for notifies on an ACPI device
400 *
401 ******************************************************************************/
402acpi_status
403acpi_remove_notify_handler(acpi_handle device,
404 u32 handler_type, acpi_notify_handler handler)
405{
406 union acpi_operand_object *notify_obj;
407 union acpi_operand_object *obj_desc;
408 struct acpi_namespace_node *node;
409 acpi_status status;
410
411 ACPI_FUNCTION_TRACE(acpi_remove_notify_handler);
412
413 /* Parameter validation */
414
415 if ((!device) ||
416 (!handler) || (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE)) {
417 status = AE_BAD_PARAMETER;
418 goto exit;
419 }
420
421 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
422 if (ACPI_FAILURE(status)) {
423 goto exit;
424 }
425
426 /* Convert and validate the device handle */
427
428 node = acpi_ns_map_handle_to_node(device);
429 if (!node) {
430 status = AE_BAD_PARAMETER;
431 goto unlock_and_exit;
432 }
433
434 /* Root Object */
435
436 if (device == ACPI_ROOT_OBJECT) {
437 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
438 "Removing notify handler for namespace root object\n"));
439
440 if (((handler_type & ACPI_SYSTEM_NOTIFY) &&
441 !acpi_gbl_system_notify.handler) ||
442 ((handler_type & ACPI_DEVICE_NOTIFY) &&
443 !acpi_gbl_device_notify.handler)) {
444 status = AE_NOT_EXIST;
445 goto unlock_and_exit;
446 }
447
448 /* Make sure all deferred tasks are completed */
449
450 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
451 acpi_os_wait_events_complete(NULL);
452 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
453 if (ACPI_FAILURE(status)) {
454 goto exit;
455 }
456
457 if (handler_type & ACPI_SYSTEM_NOTIFY) {
458 acpi_gbl_system_notify.node = NULL;
459 acpi_gbl_system_notify.handler = NULL;
460 acpi_gbl_system_notify.context = NULL;
461 }
462
463 if (handler_type & ACPI_DEVICE_NOTIFY) {
464 acpi_gbl_device_notify.node = NULL;
465 acpi_gbl_device_notify.handler = NULL;
466 acpi_gbl_device_notify.context = NULL;
467 }
468 }
469
470 /* All Other Objects */
471
472 else {
473 /* Notifies allowed on this object? */
474
475 if (!acpi_ev_is_notify_object(node)) {
476 status = AE_TYPE;
477 goto unlock_and_exit;
478 }
479
480 /* Check for an existing internal object */
481
482 obj_desc = acpi_ns_get_attached_object(node);
483 if (!obj_desc) {
484 status = AE_NOT_EXIST;
485 goto unlock_and_exit;
486 }
487
488 /* Object exists - make sure there's an existing handler */
489
490 if (handler_type & ACPI_SYSTEM_NOTIFY) {
491 notify_obj = obj_desc->common_notify.system_notify;
492 if (!notify_obj) {
493 status = AE_NOT_EXIST;
494 goto unlock_and_exit;
495 }
496
497 if (notify_obj->notify.handler != handler) {
498 status = AE_BAD_PARAMETER;
499 goto unlock_and_exit;
500 }
501 /* Make sure all deferred tasks are completed */
502
503 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
504 acpi_os_wait_events_complete(NULL);
505 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
506 if (ACPI_FAILURE(status)) {
507 goto exit;
508 }
509
510 /* Remove the handler */
511 obj_desc->common_notify.system_notify = NULL;
512 acpi_ut_remove_reference(notify_obj);
513 }
514
515 if (handler_type & ACPI_DEVICE_NOTIFY) {
516 notify_obj = obj_desc->common_notify.device_notify;
517 if (!notify_obj) {
518 status = AE_NOT_EXIST;
519 goto unlock_and_exit;
520 }
521
522 if (notify_obj->notify.handler != handler) {
523 status = AE_BAD_PARAMETER;
524 goto unlock_and_exit;
525 }
526 /* Make sure all deferred tasks are completed */
527
528 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
529 acpi_os_wait_events_complete(NULL);
530 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
531 if (ACPI_FAILURE(status)) {
532 goto exit;
533 }
534
535 /* Remove the handler */
536 obj_desc->common_notify.device_notify = NULL;
537 acpi_ut_remove_reference(notify_obj);
538 }
539 }
540
541 unlock_and_exit:
542 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
543 exit:
544 if (ACPI_FAILURE(status))
545 ACPI_EXCEPTION((AE_INFO, status, "Removing notify handler"));
546 return_ACPI_STATUS(status);
547}
548
549ACPI_EXPORT_SYMBOL(acpi_remove_notify_handler)
550
551/*******************************************************************************
552 *
553 * FUNCTION: acpi_install_gpe_handler
554 *
555 * PARAMETERS: gpe_device - Namespace node for the GPE (NULL for FADT
556 * defined GPEs)
557 * gpe_number - The GPE number within the GPE block
558 * Type - Whether this GPE should be treated as an
559 * edge- or level-triggered interrupt.
560 * Address - Address of the handler
561 * Context - Value passed to the handler on each GPE
562 *
563 * RETURN: Status
564 *
565 * DESCRIPTION: Install a handler for a General Purpose Event.
566 *
567 ******************************************************************************/
568acpi_status
569acpi_install_gpe_handler(acpi_handle gpe_device,
570 u32 gpe_number,
571 u32 type, acpi_event_handler address, void *context)
572{
573 struct acpi_gpe_event_info *gpe_event_info;
574 struct acpi_handler_info *handler;
575 acpi_status status;
576 acpi_cpu_flags flags;
577
578 ACPI_FUNCTION_TRACE(acpi_install_gpe_handler);
579
580 /* Parameter validation */
581
582 if ((!address) || (type > ACPI_GPE_XRUPT_TYPE_MASK)) {
583 status = AE_BAD_PARAMETER;
584 goto exit;
585 }
586
587 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
588 if (ACPI_FAILURE(status)) {
589 goto exit;
590 }
591
592 /* Ensure that we have a valid GPE number */
593
594 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
595 if (!gpe_event_info) {
596 status = AE_BAD_PARAMETER;
597 goto unlock_and_exit;
598 }
599
600 /* Make sure that there isn't a handler there already */
601
602 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
603 ACPI_GPE_DISPATCH_HANDLER) {
604 status = AE_ALREADY_EXISTS;
605 goto unlock_and_exit;
606 }
607
608 /* Allocate and init handler object */
609
610 handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info));
611 if (!handler) {
612 status = AE_NO_MEMORY;
613 goto unlock_and_exit;
614 }
615
616 handler->address = address;
617 handler->context = context;
618 handler->method_node = gpe_event_info->dispatch.method_node;
619
620 /* Disable the GPE before installing the handler */
621
622 status = acpi_ev_disable_gpe(gpe_event_info);
623 if (ACPI_FAILURE(status)) {
624 goto unlock_and_exit;
625 }
626
627 /* Install the handler */
628
629 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
630 gpe_event_info->dispatch.handler = handler;
631
632 /* Setup up dispatch flags to indicate handler (vs. method) */
633
634 gpe_event_info->flags &= ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK); /* Clear bits */
635 gpe_event_info->flags |= (u8) (type | ACPI_GPE_DISPATCH_HANDLER);
636
637 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
638
639 unlock_and_exit:
640 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
641 exit:
642 if (ACPI_FAILURE(status))
643 ACPI_EXCEPTION((AE_INFO, status,
644 "Installing notify handler failed"));
645 return_ACPI_STATUS(status);
646}
647
648ACPI_EXPORT_SYMBOL(acpi_install_gpe_handler)
649
650/*******************************************************************************
651 *
652 * FUNCTION: acpi_remove_gpe_handler
653 *
654 * PARAMETERS: gpe_device - Namespace node for the GPE (NULL for FADT
655 * defined GPEs)
656 * gpe_number - The event to remove a handler
657 * Address - Address of the handler
658 *
659 * RETURN: Status
660 *
661 * DESCRIPTION: Remove a handler for a General Purpose acpi_event.
662 *
663 ******************************************************************************/
664acpi_status
665acpi_remove_gpe_handler(acpi_handle gpe_device,
666 u32 gpe_number, acpi_event_handler address)
667{
668 struct acpi_gpe_event_info *gpe_event_info;
669 struct acpi_handler_info *handler;
670 acpi_status status;
671 acpi_cpu_flags flags;
672
673 ACPI_FUNCTION_TRACE(acpi_remove_gpe_handler);
674
675 /* Parameter validation */
676
677 if (!address) {
678 return_ACPI_STATUS(AE_BAD_PARAMETER);
679 }
680
681 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
682 if (ACPI_FAILURE(status)) {
683 return_ACPI_STATUS(status);
684 }
685
686 /* Ensure that we have a valid GPE number */
687
688 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
689 if (!gpe_event_info) {
690 status = AE_BAD_PARAMETER;
691 goto unlock_and_exit;
692 }
693
694 /* Make sure that a handler is indeed installed */
695
696 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) !=
697 ACPI_GPE_DISPATCH_HANDLER) {
698 status = AE_NOT_EXIST;
699 goto unlock_and_exit;
700 }
701
702 /* Make sure that the installed handler is the same */
703
704 if (gpe_event_info->dispatch.handler->address != address) {
705 status = AE_BAD_PARAMETER;
706 goto unlock_and_exit;
707 }
708
709 /* Disable the GPE before removing the handler */
710
711 status = acpi_ev_disable_gpe(gpe_event_info);
712 if (ACPI_FAILURE(status)) {
713 goto unlock_and_exit;
714 }
715
716 /* Make sure all deferred tasks are completed */
717
718 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
719 acpi_os_wait_events_complete(NULL);
720 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
721 if (ACPI_FAILURE(status)) {
722 return_ACPI_STATUS(status);
723 }
724
725 /* Remove the handler */
726
727 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
728 handler = gpe_event_info->dispatch.handler;
729
730 /* Restore Method node (if any), set dispatch flags */
731
732 gpe_event_info->dispatch.method_node = handler->method_node;
733 gpe_event_info->flags &= ~ACPI_GPE_DISPATCH_MASK; /* Clear bits */
734 if (handler->method_node) {
735 gpe_event_info->flags |= ACPI_GPE_DISPATCH_METHOD;
736 }
737 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
738
739 /* Now we can free the handler object */
740
741 ACPI_FREE(handler);
742
743 unlock_and_exit:
744 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
745 return_ACPI_STATUS(status);
746}
747
748ACPI_EXPORT_SYMBOL(acpi_remove_gpe_handler)
749
750/*******************************************************************************
751 *
752 * FUNCTION: acpi_acquire_global_lock
753 *
754 * PARAMETERS: Timeout - How long the caller is willing to wait
755 * Handle - Where the handle to the lock is returned
756 * (if acquired)
757 *
758 * RETURN: Status
759 *
760 * DESCRIPTION: Acquire the ACPI Global Lock
761 *
762 * Note: Allows callers with the same thread ID to acquire the global lock
763 * multiple times. In other words, externally, the behavior of the global lock
764 * is identical to an AML mutex. On the first acquire, a new handle is
765 * returned. On any subsequent calls to acquire by the same thread, the same
766 * handle is returned.
767 *
768 ******************************************************************************/
769acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle)
770{
771 acpi_status status;
772
773 if (!handle) {
774 return (AE_BAD_PARAMETER);
775 }
776
777 /* Must lock interpreter to prevent race conditions */
778
779 acpi_ex_enter_interpreter();
780
781 status = acpi_ex_acquire_mutex_object(timeout,
782 acpi_gbl_global_lock_mutex,
783 acpi_os_get_thread_id());
784
785 if (ACPI_SUCCESS(status)) {
786
787 /* Return the global lock handle (updated in acpi_ev_acquire_global_lock) */
788
789 *handle = acpi_gbl_global_lock_handle;
790 }
791
792 acpi_ex_exit_interpreter();
793 return (status);
794}
795
796ACPI_EXPORT_SYMBOL(acpi_acquire_global_lock)
797
798/*******************************************************************************
799 *
800 * FUNCTION: acpi_release_global_lock
801 *
802 * PARAMETERS: Handle - Returned from acpi_acquire_global_lock
803 *
804 * RETURN: Status
805 *
806 * DESCRIPTION: Release the ACPI Global Lock. The handle must be valid.
807 *
808 ******************************************************************************/
809acpi_status acpi_release_global_lock(u32 handle)
810{
811 acpi_status status;
812
813 if (!handle || (handle != acpi_gbl_global_lock_handle)) {
814 return (AE_NOT_ACQUIRED);
815 }
816
817 status = acpi_ex_release_mutex_object(acpi_gbl_global_lock_mutex);
818 return (status);
819}
820
821ACPI_EXPORT_SYMBOL(acpi_release_global_lock)
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-12 08:58:21 -0500