1 /****************************************************************************** 2 * 3 * Module Name: evgpe - General Purpose Event handling and dispatch 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2011, 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 "acevents.h" 47 #include "acnamesp.h" 48 49 #define _COMPONENT ACPI_EVENTS 50 ACPI_MODULE_NAME("evgpe") 51 52 /* Local prototypes */ 53 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context); 54 55 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context); 56 57 /******************************************************************************* 58 * 59 * FUNCTION: acpi_ev_update_gpe_enable_mask 60 * 61 * PARAMETERS: gpe_event_info - GPE to update 62 * 63 * RETURN: Status 64 * 65 * DESCRIPTION: Updates GPE register enable mask based upon whether there are 66 * runtime references to this GPE 67 * 68 ******************************************************************************/ 69 70 acpi_status 71 acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info) 72 { 73 struct acpi_gpe_register_info *gpe_register_info; 74 u32 register_bit; 75 76 ACPI_FUNCTION_TRACE(ev_update_gpe_enable_mask); 77 78 gpe_register_info = gpe_event_info->register_info; 79 if (!gpe_register_info) { 80 return_ACPI_STATUS(AE_NOT_EXIST); 81 } 82 83 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info, 84 gpe_register_info); 85 86 /* Clear the run bit up front */ 87 88 ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit); 89 90 /* Set the mask bit only if there are references to this GPE */ 91 92 if (gpe_event_info->runtime_count) { 93 ACPI_SET_BIT(gpe_register_info->enable_for_run, (u8)register_bit); 94 } 95 96 return_ACPI_STATUS(AE_OK); 97 } 98 99 /******************************************************************************* 100 * 101 * FUNCTION: acpi_ev_enable_gpe 102 * 103 * PARAMETERS: gpe_event_info - GPE to enable 104 * 105 * RETURN: Status 106 * 107 * DESCRIPTION: Clear a GPE of stale events and enable it. 108 * 109 ******************************************************************************/ 110 acpi_status 111 acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info) 112 { 113 acpi_status status; 114 115 ACPI_FUNCTION_TRACE(ev_enable_gpe); 116 117 /* 118 * We will only allow a GPE to be enabled if it has either an associated 119 * method (_Lxx/_Exx) or a handler, or is using the implicit notify 120 * feature. Otherwise, the GPE will be immediately disabled by 121 * acpi_ev_gpe_dispatch the first time it fires. 122 */ 123 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) == 124 ACPI_GPE_DISPATCH_NONE) { 125 return_ACPI_STATUS(AE_NO_HANDLER); 126 } 127 128 /* Clear the GPE (of stale events) */ 129 status = acpi_hw_clear_gpe(gpe_event_info); 130 if (ACPI_FAILURE(status)) { 131 return_ACPI_STATUS(status); 132 } 133 134 /* Enable the requested GPE */ 135 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE); 136 137 return_ACPI_STATUS(status); 138 } 139 140 141 /******************************************************************************* 142 * 143 * FUNCTION: acpi_ev_add_gpe_reference 144 * 145 * PARAMETERS: gpe_event_info - Add a reference to this GPE 146 * 147 * RETURN: Status 148 * 149 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is 150 * hardware-enabled. 151 * 152 ******************************************************************************/ 153 154 acpi_status acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info) 155 { 156 acpi_status status = AE_OK; 157 158 ACPI_FUNCTION_TRACE(ev_add_gpe_reference); 159 160 if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) { 161 return_ACPI_STATUS(AE_LIMIT); 162 } 163 164 gpe_event_info->runtime_count++; 165 if (gpe_event_info->runtime_count == 1) { 166 167 /* Enable on first reference */ 168 169 status = acpi_ev_update_gpe_enable_mask(gpe_event_info); 170 if (ACPI_SUCCESS(status)) { 171 status = acpi_ev_enable_gpe(gpe_event_info); 172 } 173 174 if (ACPI_FAILURE(status)) { 175 gpe_event_info->runtime_count--; 176 } 177 } 178 179 return_ACPI_STATUS(status); 180 } 181 182 /******************************************************************************* 183 * 184 * FUNCTION: acpi_ev_remove_gpe_reference 185 * 186 * PARAMETERS: gpe_event_info - Remove a reference to this GPE 187 * 188 * RETURN: Status 189 * 190 * DESCRIPTION: Remove a reference to a GPE. When the last reference is 191 * removed, the GPE is hardware-disabled. 192 * 193 ******************************************************************************/ 194 195 acpi_status acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info) 196 { 197 acpi_status status = AE_OK; 198 199 ACPI_FUNCTION_TRACE(ev_remove_gpe_reference); 200 201 if (!gpe_event_info->runtime_count) { 202 return_ACPI_STATUS(AE_LIMIT); 203 } 204 205 gpe_event_info->runtime_count--; 206 if (!gpe_event_info->runtime_count) { 207 208 /* Disable on last reference */ 209 210 status = acpi_ev_update_gpe_enable_mask(gpe_event_info); 211 if (ACPI_SUCCESS(status)) { 212 status = acpi_hw_low_set_gpe(gpe_event_info, 213 ACPI_GPE_DISABLE); 214 } 215 216 if (ACPI_FAILURE(status)) { 217 gpe_event_info->runtime_count++; 218 } 219 } 220 221 return_ACPI_STATUS(status); 222 } 223 224 /******************************************************************************* 225 * 226 * FUNCTION: acpi_ev_low_get_gpe_info 227 * 228 * PARAMETERS: gpe_number - Raw GPE number 229 * gpe_block - A GPE info block 230 * 231 * RETURN: A GPE event_info struct. NULL if not a valid GPE (The gpe_number 232 * is not within the specified GPE block) 233 * 234 * DESCRIPTION: Returns the event_info struct associated with this GPE. This is 235 * the low-level implementation of ev_get_gpe_event_info. 236 * 237 ******************************************************************************/ 238 239 struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number, 240 struct acpi_gpe_block_info 241 *gpe_block) 242 { 243 u32 gpe_index; 244 245 /* 246 * Validate that the gpe_number is within the specified gpe_block. 247 * (Two steps) 248 */ 249 if (!gpe_block || (gpe_number < gpe_block->block_base_number)) { 250 return (NULL); 251 } 252 253 gpe_index = gpe_number - gpe_block->block_base_number; 254 if (gpe_index >= gpe_block->gpe_count) { 255 return (NULL); 256 } 257 258 return (&gpe_block->event_info[gpe_index]); 259 } 260 261 262 /******************************************************************************* 263 * 264 * FUNCTION: acpi_ev_get_gpe_event_info 265 * 266 * PARAMETERS: gpe_device - Device node. NULL for GPE0/GPE1 267 * gpe_number - Raw GPE number 268 * 269 * RETURN: A GPE event_info struct. NULL if not a valid GPE 270 * 271 * DESCRIPTION: Returns the event_info struct associated with this GPE. 272 * Validates the gpe_block and the gpe_number 273 * 274 * Should be called only when the GPE lists are semaphore locked 275 * and not subject to change. 276 * 277 ******************************************************************************/ 278 279 struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device, 280 u32 gpe_number) 281 { 282 union acpi_operand_object *obj_desc; 283 struct acpi_gpe_event_info *gpe_info; 284 u32 i; 285 286 ACPI_FUNCTION_ENTRY(); 287 288 /* A NULL gpe_device means use the FADT-defined GPE block(s) */ 289 290 if (!gpe_device) { 291 292 /* Examine GPE Block 0 and 1 (These blocks are permanent) */ 293 294 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) { 295 gpe_info = acpi_ev_low_get_gpe_info(gpe_number, 296 acpi_gbl_gpe_fadt_blocks 297 [i]); 298 if (gpe_info) { 299 return (gpe_info); 300 } 301 } 302 303 /* The gpe_number was not in the range of either FADT GPE block */ 304 305 return (NULL); 306 } 307 308 /* A Non-NULL gpe_device means this is a GPE Block Device */ 309 310 obj_desc = acpi_ns_get_attached_object((struct acpi_namespace_node *) 311 gpe_device); 312 if (!obj_desc || !obj_desc->device.gpe_block) { 313 return (NULL); 314 } 315 316 return (acpi_ev_low_get_gpe_info 317 (gpe_number, obj_desc->device.gpe_block)); 318 } 319 320 /******************************************************************************* 321 * 322 * FUNCTION: acpi_ev_gpe_detect 323 * 324 * PARAMETERS: gpe_xrupt_list - Interrupt block for this interrupt. 325 * Can have multiple GPE blocks attached. 326 * 327 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED 328 * 329 * DESCRIPTION: Detect if any GP events have occurred. This function is 330 * executed at interrupt level. 331 * 332 ******************************************************************************/ 333 334 u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list) 335 { 336 acpi_status status; 337 struct acpi_gpe_block_info *gpe_block; 338 struct acpi_gpe_register_info *gpe_register_info; 339 u32 int_status = ACPI_INTERRUPT_NOT_HANDLED; 340 u8 enabled_status_byte; 341 u32 status_reg; 342 u32 enable_reg; 343 acpi_cpu_flags flags; 344 u32 i; 345 u32 j; 346 347 ACPI_FUNCTION_NAME(ev_gpe_detect); 348 349 /* Check for the case where there are no GPEs */ 350 351 if (!gpe_xrupt_list) { 352 return (int_status); 353 } 354 355 /* 356 * We need to obtain the GPE lock for both the data structs and registers 357 * Note: Not necessary to obtain the hardware lock, since the GPE 358 * registers are owned by the gpe_lock. 359 */ 360 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 361 362 /* Examine all GPE blocks attached to this interrupt level */ 363 364 gpe_block = gpe_xrupt_list->gpe_block_list_head; 365 while (gpe_block) { 366 /* 367 * Read all of the 8-bit GPE status and enable registers in this GPE 368 * block, saving all of them. Find all currently active GP events. 369 */ 370 for (i = 0; i < gpe_block->register_count; i++) { 371 372 /* Get the next status/enable pair */ 373 374 gpe_register_info = &gpe_block->register_info[i]; 375 376 /* Read the Status Register */ 377 378 status = 379 acpi_hw_read(&status_reg, 380 &gpe_register_info->status_address); 381 if (ACPI_FAILURE(status)) { 382 goto unlock_and_exit; 383 } 384 385 /* Read the Enable Register */ 386 387 status = 388 acpi_hw_read(&enable_reg, 389 &gpe_register_info->enable_address); 390 if (ACPI_FAILURE(status)) { 391 goto unlock_and_exit; 392 } 393 394 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS, 395 "Read GPE Register at GPE%02X: Status=%02X, Enable=%02X\n", 396 gpe_register_info->base_gpe_number, 397 status_reg, enable_reg)); 398 399 /* Check if there is anything active at all in this register */ 400 401 enabled_status_byte = (u8) (status_reg & enable_reg); 402 if (!enabled_status_byte) { 403 404 /* No active GPEs in this register, move on */ 405 406 continue; 407 } 408 409 /* Now look at the individual GPEs in this byte register */ 410 411 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) { 412 413 /* Examine one GPE bit */ 414 415 if (enabled_status_byte & (1 << j)) { 416 /* 417 * Found an active GPE. Dispatch the event to a handler 418 * or method. 419 */ 420 int_status |= 421 acpi_ev_gpe_dispatch(gpe_block-> 422 node, 423 &gpe_block-> 424 event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number); 425 } 426 } 427 } 428 429 gpe_block = gpe_block->next; 430 } 431 432 unlock_and_exit: 433 434 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 435 return (int_status); 436 } 437 438 /******************************************************************************* 439 * 440 * FUNCTION: acpi_ev_asynch_execute_gpe_method 441 * 442 * PARAMETERS: Context (gpe_event_info) - Info for this GPE 443 * 444 * RETURN: None 445 * 446 * DESCRIPTION: Perform the actual execution of a GPE control method. This 447 * function is called from an invocation of acpi_os_execute and 448 * therefore does NOT execute at interrupt level - so that 449 * the control method itself is not executed in the context of 450 * an interrupt handler. 451 * 452 ******************************************************************************/ 453 454 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context) 455 { 456 struct acpi_gpe_event_info *gpe_event_info = context; 457 acpi_status status; 458 struct acpi_gpe_event_info *local_gpe_event_info; 459 struct acpi_evaluate_info *info; 460 struct acpi_gpe_notify_object *notify_object; 461 462 ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method); 463 464 /* Allocate a local GPE block */ 465 466 local_gpe_event_info = 467 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_event_info)); 468 if (!local_gpe_event_info) { 469 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, "while handling a GPE")); 470 return_VOID; 471 } 472 473 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 474 if (ACPI_FAILURE(status)) { 475 ACPI_FREE(local_gpe_event_info); 476 return_VOID; 477 } 478 479 /* Must revalidate the gpe_number/gpe_block */ 480 481 if (!acpi_ev_valid_gpe_event(gpe_event_info)) { 482 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS); 483 ACPI_FREE(local_gpe_event_info); 484 return_VOID; 485 } 486 487 /* 488 * Take a snapshot of the GPE info for this level - we copy the info to 489 * prevent a race condition with remove_handler/remove_block. 490 */ 491 ACPI_MEMCPY(local_gpe_event_info, gpe_event_info, 492 sizeof(struct acpi_gpe_event_info)); 493 494 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS); 495 if (ACPI_FAILURE(status)) { 496 return_VOID; 497 } 498 499 /* Do the correct dispatch - normal method or implicit notify */ 500 501 switch (local_gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) { 502 case ACPI_GPE_DISPATCH_NOTIFY: 503 504 /* 505 * Implicit notify. 506 * Dispatch a DEVICE_WAKE notify to the appropriate handler. 507 * NOTE: the request is queued for execution after this method 508 * completes. The notify handlers are NOT invoked synchronously 509 * from this thread -- because handlers may in turn run other 510 * control methods. 511 */ 512 status = acpi_ev_queue_notify_request( 513 local_gpe_event_info->dispatch.device.node, 514 ACPI_NOTIFY_DEVICE_WAKE); 515 516 notify_object = local_gpe_event_info->dispatch.device.next; 517 while (ACPI_SUCCESS(status) && notify_object) { 518 status = acpi_ev_queue_notify_request( 519 notify_object->node, 520 ACPI_NOTIFY_DEVICE_WAKE); 521 notify_object = notify_object->next; 522 } 523 524 break; 525 526 case ACPI_GPE_DISPATCH_METHOD: 527 528 /* Allocate the evaluation information block */ 529 530 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 531 if (!info) { 532 status = AE_NO_MEMORY; 533 } else { 534 /* 535 * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the _Lxx/_Exx 536 * control method that corresponds to this GPE 537 */ 538 info->prefix_node = 539 local_gpe_event_info->dispatch.method_node; 540 info->flags = ACPI_IGNORE_RETURN_VALUE; 541 542 status = acpi_ns_evaluate(info); 543 ACPI_FREE(info); 544 } 545 546 if (ACPI_FAILURE(status)) { 547 ACPI_EXCEPTION((AE_INFO, status, 548 "while evaluating GPE method [%4.4s]", 549 acpi_ut_get_node_name 550 (local_gpe_event_info->dispatch. 551 method_node))); 552 } 553 554 break; 555 556 default: 557 return_VOID; /* Should never happen */ 558 } 559 560 /* Defer enabling of GPE until all notify handlers are done */ 561 562 status = acpi_os_execute(OSL_NOTIFY_HANDLER, 563 acpi_ev_asynch_enable_gpe, 564 local_gpe_event_info); 565 if (ACPI_FAILURE(status)) { 566 ACPI_FREE(local_gpe_event_info); 567 } 568 return_VOID; 569 } 570 571 572 /******************************************************************************* 573 * 574 * FUNCTION: acpi_ev_asynch_enable_gpe 575 * 576 * PARAMETERS: Context (gpe_event_info) - Info for this GPE 577 * Callback from acpi_os_execute 578 * 579 * RETURN: None 580 * 581 * DESCRIPTION: Asynchronous clear/enable for GPE. This allows the GPE to 582 * complete (i.e., finish execution of Notify) 583 * 584 ******************************************************************************/ 585 586 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context) 587 { 588 struct acpi_gpe_event_info *gpe_event_info = context; 589 590 (void)acpi_ev_finish_gpe(gpe_event_info); 591 592 ACPI_FREE(gpe_event_info); 593 return; 594 } 595 596 597 /******************************************************************************* 598 * 599 * FUNCTION: acpi_ev_finish_gpe 600 * 601 * PARAMETERS: gpe_event_info - Info for this GPE 602 * 603 * RETURN: Status 604 * 605 * DESCRIPTION: Clear/Enable a GPE. Common code that is used after execution 606 * of a GPE method or a synchronous or asynchronous GPE handler. 607 * 608 ******************************************************************************/ 609 610 acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info) 611 { 612 acpi_status status; 613 614 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) == 615 ACPI_GPE_LEVEL_TRIGGERED) { 616 /* 617 * GPE is level-triggered, we clear the GPE status bit after 618 * handling the event. 619 */ 620 status = acpi_hw_clear_gpe(gpe_event_info); 621 if (ACPI_FAILURE(status)) { 622 return (status); 623 } 624 } 625 626 /* 627 * Enable this GPE, conditionally. This means that the GPE will 628 * only be physically enabled if the enable_for_run bit is set 629 * in the event_info. 630 */ 631 (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_CONDITIONAL_ENABLE); 632 return (AE_OK); 633 } 634 635 636 /******************************************************************************* 637 * 638 * FUNCTION: acpi_ev_gpe_dispatch 639 * 640 * PARAMETERS: gpe_device - Device node. NULL for GPE0/GPE1 641 * gpe_event_info - Info for this GPE 642 * gpe_number - Number relative to the parent GPE block 643 * 644 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED 645 * 646 * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC) 647 * or method (e.g. _Lxx/_Exx) handler. 648 * 649 * This function executes at interrupt level. 650 * 651 ******************************************************************************/ 652 653 u32 654 acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device, 655 struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number) 656 { 657 acpi_status status; 658 u32 return_value; 659 660 ACPI_FUNCTION_TRACE(ev_gpe_dispatch); 661 662 /* Invoke global event handler if present */ 663 664 acpi_gpe_count++; 665 if (acpi_gbl_global_event_handler) { 666 acpi_gbl_global_event_handler(ACPI_EVENT_TYPE_GPE, gpe_device, 667 gpe_number, 668 acpi_gbl_global_event_handler_context); 669 } 670 671 /* 672 * If edge-triggered, clear the GPE status bit now. Note that 673 * level-triggered events are cleared after the GPE is serviced. 674 */ 675 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) == 676 ACPI_GPE_EDGE_TRIGGERED) { 677 status = acpi_hw_clear_gpe(gpe_event_info); 678 if (ACPI_FAILURE(status)) { 679 ACPI_EXCEPTION((AE_INFO, status, 680 "Unable to clear GPE%02X", gpe_number)); 681 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED); 682 } 683 } 684 685 /* 686 * Always disable the GPE so that it does not keep firing before 687 * any asynchronous activity completes (either from the execution 688 * of a GPE method or an asynchronous GPE handler.) 689 * 690 * If there is no handler or method to run, just disable the 691 * GPE and leave it disabled permanently to prevent further such 692 * pointless events from firing. 693 */ 694 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE); 695 if (ACPI_FAILURE(status)) { 696 ACPI_EXCEPTION((AE_INFO, status, 697 "Unable to disable GPE%02X", gpe_number)); 698 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED); 699 } 700 701 /* 702 * Dispatch the GPE to either an installed handler or the control 703 * method associated with this GPE (_Lxx or _Exx). If a handler 704 * exists, we invoke it and do not attempt to run the method. 705 * If there is neither a handler nor a method, leave the GPE 706 * disabled. 707 */ 708 switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) { 709 case ACPI_GPE_DISPATCH_HANDLER: 710 711 /* Invoke the installed handler (at interrupt level) */ 712 713 return_value = 714 gpe_event_info->dispatch.handler->address(gpe_device, 715 gpe_number, 716 gpe_event_info-> 717 dispatch.handler-> 718 context); 719 720 /* If requested, clear (if level-triggered) and reenable the GPE */ 721 722 if (return_value & ACPI_REENABLE_GPE) { 723 (void)acpi_ev_finish_gpe(gpe_event_info); 724 } 725 break; 726 727 case ACPI_GPE_DISPATCH_METHOD: 728 case ACPI_GPE_DISPATCH_NOTIFY: 729 730 /* 731 * Execute the method associated with the GPE 732 * NOTE: Level-triggered GPEs are cleared after the method completes. 733 */ 734 status = acpi_os_execute(OSL_GPE_HANDLER, 735 acpi_ev_asynch_execute_gpe_method, 736 gpe_event_info); 737 if (ACPI_FAILURE(status)) { 738 ACPI_EXCEPTION((AE_INFO, status, 739 "Unable to queue handler for GPE%2X - event disabled", 740 gpe_number)); 741 } 742 break; 743 744 default: 745 746 /* 747 * No handler or method to run! 748 * 03/2010: This case should no longer be possible. We will not allow 749 * a GPE to be enabled if it has no handler or method. 750 */ 751 ACPI_ERROR((AE_INFO, 752 "No handler or method for GPE%02X, disabling event", 753 gpe_number)); 754 755 break; 756 } 757 758 return_UINT32(ACPI_INTERRUPT_HANDLED); 759 } 760