1/****************************************************************************** 2 * 3 * Module Name: evxface - External interfaces for ACPI events 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2010, 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 "accommon.h" 46#include "acnamesp.h" 47#include "acevents.h" 48#include "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 0x%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 0x%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_populate_handler_object 222 * 223 * PARAMETERS: handler_obj - Handler object to populate 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 * next - Address of a handler object to link to 231 * 232 * RETURN: None 233 * 234 * DESCRIPTION: Populate a handler object. 235 * 236 ******************************************************************************/ 237static void 238acpi_populate_handler_object(struct acpi_object_notify_handler *handler_obj, 239 u32 handler_type, 240 acpi_notify_handler handler, void *context, 241 struct acpi_object_notify_handler *next) 242{ 243 handler_obj->handler_type = handler_type; 244 handler_obj->handler = handler; 245 handler_obj->context = context; 246 handler_obj->next = next; 247} 248 249/******************************************************************************* 250 * 251 * FUNCTION: acpi_add_handler_object 252 * 253 * PARAMETERS: parent_obj - Parent of the new object 254 * handler - Address of the handler 255 * context - Value passed to the handler on each GPE 256 * 257 * RETURN: Status 258 * 259 * DESCRIPTION: Create a new handler object and populate it. 260 * 261 ******************************************************************************/ 262static acpi_status 263acpi_add_handler_object(struct acpi_object_notify_handler *parent_obj, 264 acpi_notify_handler handler, void *context) 265{ 266 struct acpi_object_notify_handler *handler_obj; 267 268 /* The parent must not be a defice notify handler object. */ 269 if (parent_obj->handler_type & ACPI_DEVICE_NOTIFY) 270 return AE_BAD_PARAMETER; 271 272 handler_obj = ACPI_ALLOCATE_ZEROED(sizeof(*handler_obj)); 273 if (!handler_obj) 274 return AE_NO_MEMORY; 275 276 acpi_populate_handler_object(handler_obj, 277 ACPI_SYSTEM_NOTIFY, 278 handler, context, 279 parent_obj->next); 280 parent_obj->next = handler_obj; 281 282 return AE_OK; 283} 284 285/******************************************************************************* 286 * 287 * FUNCTION: acpi_install_notify_handler 288 * 289 * PARAMETERS: Device - The device for which notifies will be handled 290 * handler_type - The type of handler: 291 * ACPI_SYSTEM_NOTIFY: system_handler (00-7f) 292 * ACPI_DEVICE_NOTIFY: driver_handler (80-ff) 293 * ACPI_ALL_NOTIFY: both system and device 294 * Handler - Address of the handler 295 * Context - Value passed to the handler on each GPE 296 * 297 * RETURN: Status 298 * 299 * DESCRIPTION: Install a handler for notifies on an ACPI device 300 * 301 ******************************************************************************/ 302acpi_status 303acpi_install_notify_handler(acpi_handle device, 304 u32 handler_type, 305 acpi_notify_handler handler, void *context) 306{ 307 union acpi_operand_object *obj_desc; 308 union acpi_operand_object *notify_obj; 309 struct acpi_namespace_node *node; 310 acpi_status status; 311 312 ACPI_FUNCTION_TRACE(acpi_install_notify_handler); 313 314 /* Parameter validation */ 315 316 if ((!device) || 317 (!handler) || (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE)) { 318 return_ACPI_STATUS(AE_BAD_PARAMETER); 319 } 320 321 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 322 if (ACPI_FAILURE(status)) { 323 return_ACPI_STATUS(status); 324 } 325 326 /* Convert and validate the device handle */ 327 328 node = acpi_ns_validate_handle(device); 329 if (!node) { 330 status = AE_BAD_PARAMETER; 331 goto unlock_and_exit; 332 } 333 334 /* 335 * Root Object: 336 * Registering a notify handler on the root object indicates that the 337 * caller wishes to receive notifications for all objects. Note that 338 * only one <external> global handler can be regsitered (per notify type). 339 */ 340 if (device == ACPI_ROOT_OBJECT) { 341 342 /* Make sure the handler is not already installed */ 343 344 if (((handler_type & ACPI_SYSTEM_NOTIFY) && 345 acpi_gbl_system_notify.handler) || 346 ((handler_type & ACPI_DEVICE_NOTIFY) && 347 acpi_gbl_device_notify.handler)) { 348 status = AE_ALREADY_EXISTS; 349 goto unlock_and_exit; 350 } 351 352 if (handler_type & ACPI_SYSTEM_NOTIFY) { 353 acpi_gbl_system_notify.node = node; 354 acpi_gbl_system_notify.handler = handler; 355 acpi_gbl_system_notify.context = context; 356 } 357 358 if (handler_type & ACPI_DEVICE_NOTIFY) { 359 acpi_gbl_device_notify.node = node; 360 acpi_gbl_device_notify.handler = handler; 361 acpi_gbl_device_notify.context = context; 362 } 363 364 /* Global notify handler installed */ 365 } 366 367 /* 368 * All Other Objects: 369 * Caller will only receive notifications specific to the target object. 370 * Note that only certain object types can receive notifications. 371 */ 372 else { 373 /* Notifies allowed on this object? */ 374 375 if (!acpi_ev_is_notify_object(node)) { 376 status = AE_TYPE; 377 goto unlock_and_exit; 378 } 379 380 /* Check for an existing internal object */ 381 382 obj_desc = acpi_ns_get_attached_object(node); 383 if (obj_desc) { 384 385 /* Object exists. */ 386 387 /* For a device notify, make sure there's no handler. */ 388 if ((handler_type & ACPI_DEVICE_NOTIFY) && 389 obj_desc->common_notify.device_notify) { 390 status = AE_ALREADY_EXISTS; 391 goto unlock_and_exit; 392 } 393 394 /* System notifies may have more handlers installed. */ 395 notify_obj = obj_desc->common_notify.system_notify; 396 397 if ((handler_type & ACPI_SYSTEM_NOTIFY) && notify_obj) { 398 struct acpi_object_notify_handler *parent_obj; 399 400 if (handler_type & ACPI_DEVICE_NOTIFY) { 401 status = AE_ALREADY_EXISTS; 402 goto unlock_and_exit; 403 } 404 405 parent_obj = ¬ify_obj->notify; 406 status = acpi_add_handler_object(parent_obj, 407 handler, 408 context); 409 goto unlock_and_exit; 410 } 411 } else { 412 /* Create a new object */ 413 414 obj_desc = acpi_ut_create_internal_object(node->type); 415 if (!obj_desc) { 416 status = AE_NO_MEMORY; 417 goto unlock_and_exit; 418 } 419 420 /* Attach new object to the Node */ 421 422 status = 423 acpi_ns_attach_object(device, obj_desc, node->type); 424 425 /* Remove local reference to the object */ 426 427 acpi_ut_remove_reference(obj_desc); 428 if (ACPI_FAILURE(status)) { 429 goto unlock_and_exit; 430 } 431 } 432 433 /* Install the handler */ 434 435 notify_obj = 436 acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_NOTIFY); 437 if (!notify_obj) { 438 status = AE_NO_MEMORY; 439 goto unlock_and_exit; 440 } 441 442 acpi_populate_handler_object(¬ify_obj->notify, 443 handler_type, 444 handler, context, 445 NULL); 446 447 if (handler_type & ACPI_SYSTEM_NOTIFY) { 448 obj_desc->common_notify.system_notify = notify_obj; 449 } 450 451 if (handler_type & ACPI_DEVICE_NOTIFY) { 452 obj_desc->common_notify.device_notify = notify_obj; 453 } 454 455 if (handler_type == ACPI_ALL_NOTIFY) { 456 457 /* Extra ref if installed in both */ 458 459 acpi_ut_add_reference(notify_obj); 460 } 461 } 462 463 unlock_and_exit: 464 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 465 return_ACPI_STATUS(status); 466} 467 468ACPI_EXPORT_SYMBOL(acpi_install_notify_handler) 469 470/******************************************************************************* 471 * 472 * FUNCTION: acpi_remove_notify_handler 473 * 474 * PARAMETERS: Device - The device for which notifies will be handled 475 * handler_type - The type of handler: 476 * ACPI_SYSTEM_NOTIFY: system_handler (00-7f) 477 * ACPI_DEVICE_NOTIFY: driver_handler (80-ff) 478 * ACPI_ALL_NOTIFY: both system and device 479 * Handler - Address of the handler 480 * 481 * RETURN: Status 482 * 483 * DESCRIPTION: Remove a handler for notifies on an ACPI device 484 * 485 ******************************************************************************/ 486acpi_status 487acpi_remove_notify_handler(acpi_handle device, 488 u32 handler_type, acpi_notify_handler handler) 489{ 490 union acpi_operand_object *notify_obj; 491 union acpi_operand_object *obj_desc; 492 struct acpi_namespace_node *node; 493 acpi_status status; 494 495 ACPI_FUNCTION_TRACE(acpi_remove_notify_handler); 496 497 /* Parameter validation */ 498 499 if ((!device) || 500 (!handler) || (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE)) { 501 status = AE_BAD_PARAMETER; 502 goto exit; 503 } 504 505 506 /* Make sure all deferred tasks are completed */ 507 acpi_os_wait_events_complete(NULL); 508 509 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 510 if (ACPI_FAILURE(status)) { 511 goto exit; 512 } 513 514 /* Convert and validate the device handle */ 515 516 node = acpi_ns_validate_handle(device); 517 if (!node) { 518 status = AE_BAD_PARAMETER; 519 goto unlock_and_exit; 520 } 521 522 /* Root Object */ 523 524 if (device == ACPI_ROOT_OBJECT) { 525 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 526 "Removing notify handler for namespace root object\n")); 527 528 if (((handler_type & ACPI_SYSTEM_NOTIFY) && 529 !acpi_gbl_system_notify.handler) || 530 ((handler_type & ACPI_DEVICE_NOTIFY) && 531 !acpi_gbl_device_notify.handler)) { 532 status = AE_NOT_EXIST; 533 goto unlock_and_exit; 534 } 535 536 if (handler_type & ACPI_SYSTEM_NOTIFY) { 537 acpi_gbl_system_notify.node = NULL; 538 acpi_gbl_system_notify.handler = NULL; 539 acpi_gbl_system_notify.context = NULL; 540 } 541 542 if (handler_type & ACPI_DEVICE_NOTIFY) { 543 acpi_gbl_device_notify.node = NULL; 544 acpi_gbl_device_notify.handler = NULL; 545 acpi_gbl_device_notify.context = NULL; 546 } 547 } 548 549 /* All Other Objects */ 550 551 else { 552 /* Notifies allowed on this object? */ 553 554 if (!acpi_ev_is_notify_object(node)) { 555 status = AE_TYPE; 556 goto unlock_and_exit; 557 } 558 559 /* Check for an existing internal object */ 560 561 obj_desc = acpi_ns_get_attached_object(node); 562 if (!obj_desc) { 563 status = AE_NOT_EXIST; 564 goto unlock_and_exit; 565 } 566 567 /* Object exists - make sure there's an existing handler */ 568 569 if (handler_type & ACPI_SYSTEM_NOTIFY) { 570 struct acpi_object_notify_handler *handler_obj; 571 struct acpi_object_notify_handler *parent_obj; 572 573 notify_obj = obj_desc->common_notify.system_notify; 574 if (!notify_obj) { 575 status = AE_NOT_EXIST; 576 goto unlock_and_exit; 577 } 578 579 handler_obj = ¬ify_obj->notify; 580 parent_obj = NULL; 581 while (handler_obj->handler != handler) { 582 if (handler_obj->next) { 583 parent_obj = handler_obj; 584 handler_obj = handler_obj->next; 585 } else { 586 break; 587 } 588 } 589 590 if (handler_obj->handler != handler) { 591 status = AE_BAD_PARAMETER; 592 goto unlock_and_exit; 593 } 594 595 /* 596 * Remove the handler. There are three possible cases. 597 * First, we may need to remove a non-embedded object. 598 * Second, we may need to remove the embedded object's 599 * handler data, while non-embedded objects exist. 600 * Finally, we may need to remove the embedded object 601 * entirely along with its container. 602 */ 603 if (parent_obj) { 604 /* Non-embedded object is being removed. */ 605 parent_obj->next = handler_obj->next; 606 ACPI_FREE(handler_obj); 607 } else if (notify_obj->notify.next) { 608 /* 609 * The handler matches the embedded object, but 610 * there are more handler objects in the list. 611 * Replace the embedded object's data with the 612 * first next object's data and remove that 613 * object. 614 */ 615 parent_obj = ¬ify_obj->notify; 616 handler_obj = notify_obj->notify.next; 617 *parent_obj = *handler_obj; 618 ACPI_FREE(handler_obj); 619 } else { 620 /* No more handler objects in the list. */ 621 obj_desc->common_notify.system_notify = NULL; 622 acpi_ut_remove_reference(notify_obj); 623 } 624 } 625 626 if (handler_type & ACPI_DEVICE_NOTIFY) { 627 notify_obj = obj_desc->common_notify.device_notify; 628 if (!notify_obj) { 629 status = AE_NOT_EXIST; 630 goto unlock_and_exit; 631 } 632 633 if (notify_obj->notify.handler != handler) { 634 status = AE_BAD_PARAMETER; 635 goto unlock_and_exit; 636 } 637 638 /* Remove the handler */ 639 obj_desc->common_notify.device_notify = NULL; 640 acpi_ut_remove_reference(notify_obj); 641 } 642 } 643 644 unlock_and_exit: 645 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 646 exit: 647 if (ACPI_FAILURE(status)) 648 ACPI_EXCEPTION((AE_INFO, status, "Removing notify handler")); 649 return_ACPI_STATUS(status); 650} 651 652ACPI_EXPORT_SYMBOL(acpi_remove_notify_handler) 653 654/******************************************************************************* 655 * 656 * FUNCTION: acpi_install_gpe_handler 657 * 658 * PARAMETERS: gpe_device - Namespace node for the GPE (NULL for FADT 659 * defined GPEs) 660 * gpe_number - The GPE number within the GPE block 661 * Type - Whether this GPE should be treated as an 662 * edge- or level-triggered interrupt. 663 * Address - Address of the handler 664 * Context - Value passed to the handler on each GPE 665 * 666 * RETURN: Status 667 * 668 * DESCRIPTION: Install a handler for a General Purpose Event. 669 * 670 ******************************************************************************/ 671acpi_status 672acpi_install_gpe_handler(acpi_handle gpe_device, 673 u32 gpe_number, 674 u32 type, acpi_event_handler address, void *context) 675{ 676 struct acpi_gpe_event_info *gpe_event_info; 677 struct acpi_handler_info *handler; 678 acpi_status status; 679 acpi_cpu_flags flags; 680 681 ACPI_FUNCTION_TRACE(acpi_install_gpe_handler); 682 683 /* Parameter validation */ 684 685 if ((!address) || (type & ~ACPI_GPE_XRUPT_TYPE_MASK)) { 686 return_ACPI_STATUS(AE_BAD_PARAMETER); 687 } 688 689 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 690 if (ACPI_FAILURE(status)) { 691 return_ACPI_STATUS(status); 692 } 693 694 /* Allocate memory for the handler object */ 695 696 handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info)); 697 if (!handler) { 698 status = AE_NO_MEMORY; 699 goto unlock_and_exit; 700 } 701 702 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 703 704 /* Ensure that we have a valid GPE number */ 705 706 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 707 if (!gpe_event_info) { 708 status = AE_BAD_PARAMETER; 709 goto free_and_exit; 710 } 711 712 /* Make sure that there isn't a handler there already */ 713 714 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) == 715 ACPI_GPE_DISPATCH_HANDLER) { 716 status = AE_ALREADY_EXISTS; 717 goto free_and_exit; 718 } 719 720 /* Allocate and init handler object */ 721 722 handler->address = address; 723 handler->context = context; 724 handler->method_node = gpe_event_info->dispatch.method_node; 725 handler->orig_flags = gpe_event_info->flags & 726 (ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK); 727 728 /* 729 * If the GPE is associated with a method and it cannot wake up the 730 * system from sleep states, it was enabled automatically during 731 * initialization, so it has to be disabled now to avoid spurious 732 * execution of the handler. 733 */ 734 735 if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD) 736 && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) 737 (void)acpi_raw_disable_gpe(gpe_event_info); 738 739 /* Install the handler */ 740 741 gpe_event_info->dispatch.handler = handler; 742 743 /* Setup up dispatch flags to indicate handler (vs. method) */ 744 745 gpe_event_info->flags &= 746 ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK); 747 gpe_event_info->flags |= (u8) (type | ACPI_GPE_DISPATCH_HANDLER); 748 749 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 750 751unlock_and_exit: 752 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 753 return_ACPI_STATUS(status); 754 755free_and_exit: 756 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 757 ACPI_FREE(handler); 758 goto unlock_and_exit; 759} 760 761ACPI_EXPORT_SYMBOL(acpi_install_gpe_handler) 762 763/******************************************************************************* 764 * 765 * FUNCTION: acpi_remove_gpe_handler 766 * 767 * PARAMETERS: gpe_device - Namespace node for the GPE (NULL for FADT 768 * defined GPEs) 769 * gpe_number - The event to remove a handler 770 * Address - Address of the handler 771 * 772 * RETURN: Status 773 * 774 * DESCRIPTION: Remove a handler for a General Purpose acpi_event. 775 * 776 ******************************************************************************/ 777acpi_status 778acpi_remove_gpe_handler(acpi_handle gpe_device, 779 u32 gpe_number, acpi_event_handler address) 780{ 781 struct acpi_gpe_event_info *gpe_event_info; 782 struct acpi_handler_info *handler; 783 acpi_status status; 784 acpi_cpu_flags flags; 785 786 ACPI_FUNCTION_TRACE(acpi_remove_gpe_handler); 787 788 /* Parameter validation */ 789 790 if (!address) { 791 return_ACPI_STATUS(AE_BAD_PARAMETER); 792 } 793 794 /* Make sure all deferred tasks are completed */ 795 796 acpi_os_wait_events_complete(NULL); 797 798 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 799 if (ACPI_FAILURE(status)) { 800 return_ACPI_STATUS(status); 801 } 802 803 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 804 805 /* Ensure that we have a valid GPE number */ 806 807 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 808 if (!gpe_event_info) { 809 status = AE_BAD_PARAMETER; 810 goto unlock_and_exit; 811 } 812 813 /* Make sure that a handler is indeed installed */ 814 815 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) != 816 ACPI_GPE_DISPATCH_HANDLER) { 817 status = AE_NOT_EXIST; 818 goto unlock_and_exit; 819 } 820 821 /* Make sure that the installed handler is the same */ 822 823 if (gpe_event_info->dispatch.handler->address != address) { 824 status = AE_BAD_PARAMETER; 825 goto unlock_and_exit; 826 } 827 828 /* Remove the handler */ 829 830 handler = gpe_event_info->dispatch.handler; 831 832 /* Restore Method node (if any), set dispatch flags */ 833 834 gpe_event_info->dispatch.method_node = handler->method_node; 835 gpe_event_info->flags &= 836 ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK); 837 gpe_event_info->flags |= handler->orig_flags; 838 839 /* 840 * If the GPE was previously associated with a method and it cannot wake 841 * up the system from sleep states, it should be enabled at this point 842 * to restore the post-initialization configuration. 843 */ 844 845 if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD) 846 && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) 847 (void)acpi_raw_enable_gpe(gpe_event_info); 848 849 /* Now we can free the handler object */ 850 851 ACPI_FREE(handler); 852 853unlock_and_exit: 854 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 855 856 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 857 return_ACPI_STATUS(status); 858} 859 860ACPI_EXPORT_SYMBOL(acpi_remove_gpe_handler) 861 862/******************************************************************************* 863 * 864 * FUNCTION: acpi_acquire_global_lock 865 * 866 * PARAMETERS: Timeout - How long the caller is willing to wait 867 * Handle - Where the handle to the lock is returned 868 * (if acquired) 869 * 870 * RETURN: Status 871 * 872 * DESCRIPTION: Acquire the ACPI Global Lock 873 * 874 * Note: Allows callers with the same thread ID to acquire the global lock 875 * multiple times. In other words, externally, the behavior of the global lock 876 * is identical to an AML mutex. On the first acquire, a new handle is 877 * returned. On any subsequent calls to acquire by the same thread, the same 878 * handle is returned. 879 * 880 ******************************************************************************/ 881acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle) 882{ 883 acpi_status status; 884 885 if (!handle) { 886 return (AE_BAD_PARAMETER); 887 } 888 889 /* Must lock interpreter to prevent race conditions */ 890 891 acpi_ex_enter_interpreter(); 892 893 status = acpi_ex_acquire_mutex_object(timeout, 894 acpi_gbl_global_lock_mutex, 895 acpi_os_get_thread_id()); 896 897 if (ACPI_SUCCESS(status)) { 898 899 /* Return the global lock handle (updated in acpi_ev_acquire_global_lock) */ 900 901 *handle = acpi_gbl_global_lock_handle; 902 } 903 904 acpi_ex_exit_interpreter(); 905 return (status); 906} 907 908ACPI_EXPORT_SYMBOL(acpi_acquire_global_lock) 909 910/******************************************************************************* 911 * 912 * FUNCTION: acpi_release_global_lock 913 * 914 * PARAMETERS: Handle - Returned from acpi_acquire_global_lock 915 * 916 * RETURN: Status 917 * 918 * DESCRIPTION: Release the ACPI Global Lock. The handle must be valid. 919 * 920 ******************************************************************************/ 921acpi_status acpi_release_global_lock(u32 handle) 922{ 923 acpi_status status; 924 925 if (!handle || (handle != acpi_gbl_global_lock_handle)) { 926 return (AE_NOT_ACQUIRED); 927 } 928 929 status = acpi_ex_release_mutex_object(acpi_gbl_global_lock_mutex); 930 return (status); 931} 932 933ACPI_EXPORT_SYMBOL(acpi_release_global_lock) 934