1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: evxfgpe - External Interfaces for General Purpose Events (GPEs) 5 * 6 * Copyright (C) 2000 - 2018, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #define EXPORT_ACPI_INTERFACES 11 12 #include <acpi/acpi.h> 13 #include "accommon.h" 14 #include "acevents.h" 15 #include "acnamesp.h" 16 17 #define _COMPONENT ACPI_EVENTS 18 ACPI_MODULE_NAME("evxfgpe") 19 20 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */ 21 /******************************************************************************* 22 * 23 * FUNCTION: acpi_update_all_gpes 24 * 25 * PARAMETERS: None 26 * 27 * RETURN: Status 28 * 29 * DESCRIPTION: Complete GPE initialization and enable all GPEs that have 30 * associated _Lxx or _Exx methods and are not pointed to by any 31 * device _PRW methods (this indicates that these GPEs are 32 * generally intended for system or device wakeup. Such GPEs 33 * have to be enabled directly when the devices whose _PRW 34 * methods point to them are set up for wakeup signaling.) 35 * 36 * NOTE: Should be called after any GPEs are added to the system. Primarily, 37 * after the system _PRW methods have been run, but also after a GPE Block 38 * Device has been added or if any new GPE methods have been added via a 39 * dynamic table load. 40 * 41 ******************************************************************************/ 42 43 acpi_status acpi_update_all_gpes(void) 44 { 45 acpi_status status; 46 u8 is_polling_needed = FALSE; 47 48 ACPI_FUNCTION_TRACE(acpi_update_all_gpes); 49 50 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 51 if (ACPI_FAILURE(status)) { 52 return_ACPI_STATUS(status); 53 } 54 55 if (acpi_gbl_all_gpes_initialized) { 56 goto unlock_and_exit; 57 } 58 59 status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block, 60 &is_polling_needed); 61 if (ACPI_SUCCESS(status)) { 62 acpi_gbl_all_gpes_initialized = TRUE; 63 } 64 65 unlock_and_exit: 66 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 67 68 if (is_polling_needed && acpi_gbl_all_gpes_initialized) { 69 70 /* Poll GPEs to handle already triggered events */ 71 72 acpi_ev_gpe_detect(acpi_gbl_gpe_xrupt_list_head); 73 } 74 return_ACPI_STATUS(status); 75 } 76 77 ACPI_EXPORT_SYMBOL(acpi_update_all_gpes) 78 79 /******************************************************************************* 80 * 81 * FUNCTION: acpi_enable_gpe 82 * 83 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 84 * gpe_number - GPE level within the GPE block 85 * 86 * RETURN: Status 87 * 88 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is 89 * hardware-enabled. 90 * 91 ******************************************************************************/ 92 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number) 93 { 94 acpi_status status = AE_BAD_PARAMETER; 95 struct acpi_gpe_event_info *gpe_event_info; 96 acpi_cpu_flags flags; 97 98 ACPI_FUNCTION_TRACE(acpi_enable_gpe); 99 100 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 101 102 /* 103 * Ensure that we have a valid GPE number and that there is some way 104 * of handling the GPE (handler or a GPE method). In other words, we 105 * won't allow a valid GPE to be enabled if there is no way to handle it. 106 */ 107 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 108 if (gpe_event_info) { 109 if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) != 110 ACPI_GPE_DISPATCH_NONE) { 111 status = acpi_ev_add_gpe_reference(gpe_event_info); 112 if (ACPI_SUCCESS(status) && 113 ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) { 114 115 /* Poll edge-triggered GPEs to handle existing events */ 116 117 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 118 (void)acpi_ev_detect_gpe(gpe_device, 119 gpe_event_info, 120 gpe_number); 121 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 122 } 123 } else { 124 status = AE_NO_HANDLER; 125 } 126 } 127 128 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 129 return_ACPI_STATUS(status); 130 } 131 ACPI_EXPORT_SYMBOL(acpi_enable_gpe) 132 133 /******************************************************************************* 134 * 135 * FUNCTION: acpi_disable_gpe 136 * 137 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 138 * gpe_number - GPE level within the GPE block 139 * 140 * RETURN: Status 141 * 142 * DESCRIPTION: Remove a reference to a GPE. When the last reference is 143 * removed, only then is the GPE disabled (for runtime GPEs), or 144 * the GPE mask bit disabled (for wake GPEs) 145 * 146 ******************************************************************************/ 147 148 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number) 149 { 150 acpi_status status = AE_BAD_PARAMETER; 151 struct acpi_gpe_event_info *gpe_event_info; 152 acpi_cpu_flags flags; 153 154 ACPI_FUNCTION_TRACE(acpi_disable_gpe); 155 156 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 157 158 /* Ensure that we have a valid GPE number */ 159 160 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 161 if (gpe_event_info) { 162 status = acpi_ev_remove_gpe_reference(gpe_event_info) ; 163 } 164 165 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 166 return_ACPI_STATUS(status); 167 } 168 169 ACPI_EXPORT_SYMBOL(acpi_disable_gpe) 170 171 /******************************************************************************* 172 * 173 * FUNCTION: acpi_set_gpe 174 * 175 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 176 * gpe_number - GPE level within the GPE block 177 * action - ACPI_GPE_ENABLE or ACPI_GPE_DISABLE 178 * 179 * RETURN: Status 180 * 181 * DESCRIPTION: Enable or disable an individual GPE. This function bypasses 182 * the reference count mechanism used in the acpi_enable_gpe(), 183 * acpi_disable_gpe() interfaces. 184 * This API is typically used by the GPE raw handler mode driver 185 * to switch between the polling mode and the interrupt mode after 186 * the driver has enabled the GPE. 187 * The APIs should be invoked in this order: 188 * acpi_enable_gpe() <- Ensure the reference count > 0 189 * acpi_set_gpe(ACPI_GPE_DISABLE) <- Enter polling mode 190 * acpi_set_gpe(ACPI_GPE_ENABLE) <- Leave polling mode 191 * acpi_disable_gpe() <- Decrease the reference count 192 * 193 * Note: If a GPE is shared by 2 silicon components, then both the drivers 194 * should support GPE polling mode or disabling the GPE for long period 195 * for one driver may break the other. So use it with care since all 196 * firmware _Lxx/_Exx handlers currently rely on the GPE interrupt mode. 197 * 198 ******************************************************************************/ 199 acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action) 200 { 201 struct acpi_gpe_event_info *gpe_event_info; 202 acpi_status status; 203 acpi_cpu_flags flags; 204 205 ACPI_FUNCTION_TRACE(acpi_set_gpe); 206 207 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 208 209 /* Ensure that we have a valid GPE number */ 210 211 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 212 if (!gpe_event_info) { 213 status = AE_BAD_PARAMETER; 214 goto unlock_and_exit; 215 } 216 217 /* Perform the action */ 218 219 switch (action) { 220 case ACPI_GPE_ENABLE: 221 222 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE); 223 gpe_event_info->disable_for_dispatch = FALSE; 224 break; 225 226 case ACPI_GPE_DISABLE: 227 228 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE); 229 gpe_event_info->disable_for_dispatch = TRUE; 230 break; 231 232 default: 233 234 status = AE_BAD_PARAMETER; 235 break; 236 } 237 238 unlock_and_exit: 239 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 240 return_ACPI_STATUS(status); 241 } 242 243 ACPI_EXPORT_SYMBOL(acpi_set_gpe) 244 245 /******************************************************************************* 246 * 247 * FUNCTION: acpi_mask_gpe 248 * 249 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 250 * gpe_number - GPE level within the GPE block 251 * is_masked - Whether the GPE is masked or not 252 * 253 * RETURN: Status 254 * 255 * DESCRIPTION: Unconditionally mask/unmask the an individual GPE, ex., to 256 * prevent a GPE flooding. 257 * 258 ******************************************************************************/ 259 acpi_status acpi_mask_gpe(acpi_handle gpe_device, u32 gpe_number, u8 is_masked) 260 { 261 struct acpi_gpe_event_info *gpe_event_info; 262 acpi_status status; 263 acpi_cpu_flags flags; 264 265 ACPI_FUNCTION_TRACE(acpi_mask_gpe); 266 267 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 268 269 /* Ensure that we have a valid GPE number */ 270 271 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 272 if (!gpe_event_info) { 273 status = AE_BAD_PARAMETER; 274 goto unlock_and_exit; 275 } 276 277 status = acpi_ev_mask_gpe(gpe_event_info, is_masked); 278 279 unlock_and_exit: 280 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 281 return_ACPI_STATUS(status); 282 } 283 284 ACPI_EXPORT_SYMBOL(acpi_mask_gpe) 285 286 /******************************************************************************* 287 * 288 * FUNCTION: acpi_mark_gpe_for_wake 289 * 290 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 291 * gpe_number - GPE level within the GPE block 292 * 293 * RETURN: Status 294 * 295 * DESCRIPTION: Mark a GPE as having the ability to wake the system. Simply 296 * sets the ACPI_GPE_CAN_WAKE flag. 297 * 298 * Some potential callers of acpi_setup_gpe_for_wake may know in advance that 299 * there won't be any notify handlers installed for device wake notifications 300 * from the given GPE (one example is a button GPE in Linux). For these cases, 301 * acpi_mark_gpe_for_wake should be used instead of acpi_setup_gpe_for_wake. 302 * This will set the ACPI_GPE_CAN_WAKE flag for the GPE without trying to 303 * setup implicit wake notification for it (since there's no handler method). 304 * 305 ******************************************************************************/ 306 acpi_status acpi_mark_gpe_for_wake(acpi_handle gpe_device, u32 gpe_number) 307 { 308 struct acpi_gpe_event_info *gpe_event_info; 309 acpi_status status = AE_BAD_PARAMETER; 310 acpi_cpu_flags flags; 311 312 ACPI_FUNCTION_TRACE(acpi_mark_gpe_for_wake); 313 314 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 315 316 /* Ensure that we have a valid GPE number */ 317 318 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 319 if (gpe_event_info) { 320 321 /* Mark the GPE as a possible wake event */ 322 323 gpe_event_info->flags |= ACPI_GPE_CAN_WAKE; 324 status = AE_OK; 325 } 326 327 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 328 return_ACPI_STATUS(status); 329 } 330 331 ACPI_EXPORT_SYMBOL(acpi_mark_gpe_for_wake) 332 333 /******************************************************************************* 334 * 335 * FUNCTION: acpi_setup_gpe_for_wake 336 * 337 * PARAMETERS: wake_device - Device associated with the GPE (via _PRW) 338 * gpe_device - Parent GPE Device. NULL for GPE0/GPE1 339 * gpe_number - GPE level within the GPE block 340 * 341 * RETURN: Status 342 * 343 * DESCRIPTION: Mark a GPE as having the ability to wake the system. This 344 * interface is intended to be used as the host executes the 345 * _PRW methods (Power Resources for Wake) in the system tables. 346 * Each _PRW appears under a Device Object (The wake_device), and 347 * contains the info for the wake GPE associated with the 348 * wake_device. 349 * 350 ******************************************************************************/ 351 acpi_status 352 acpi_setup_gpe_for_wake(acpi_handle wake_device, 353 acpi_handle gpe_device, u32 gpe_number) 354 { 355 acpi_status status; 356 struct acpi_gpe_event_info *gpe_event_info; 357 struct acpi_namespace_node *device_node; 358 struct acpi_gpe_notify_info *notify; 359 struct acpi_gpe_notify_info *new_notify; 360 acpi_cpu_flags flags; 361 362 ACPI_FUNCTION_TRACE(acpi_setup_gpe_for_wake); 363 364 /* Parameter Validation */ 365 366 if (!wake_device) { 367 /* 368 * By forcing wake_device to be valid, we automatically enable the 369 * implicit notify feature on all hosts. 370 */ 371 return_ACPI_STATUS(AE_BAD_PARAMETER); 372 } 373 374 /* Handle root object case */ 375 376 if (wake_device == ACPI_ROOT_OBJECT) { 377 device_node = acpi_gbl_root_node; 378 } else { 379 device_node = 380 ACPI_CAST_PTR(struct acpi_namespace_node, wake_device); 381 } 382 383 /* Validate wake_device is of type Device */ 384 385 if (device_node->type != ACPI_TYPE_DEVICE) { 386 return_ACPI_STATUS (AE_BAD_PARAMETER); 387 } 388 389 /* 390 * Allocate a new notify object up front, in case it is needed. 391 * Memory allocation while holding a spinlock is a big no-no 392 * on some hosts. 393 */ 394 new_notify = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_notify_info)); 395 if (!new_notify) { 396 return_ACPI_STATUS(AE_NO_MEMORY); 397 } 398 399 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 400 401 /* Ensure that we have a valid GPE number */ 402 403 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 404 if (!gpe_event_info) { 405 status = AE_BAD_PARAMETER; 406 goto unlock_and_exit; 407 } 408 409 /* 410 * If there is no method or handler for this GPE, then the 411 * wake_device will be notified whenever this GPE fires. This is 412 * known as an "implicit notify". Note: The GPE is assumed to be 413 * level-triggered (for windows compatibility). 414 */ 415 if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) == 416 ACPI_GPE_DISPATCH_NONE) { 417 /* 418 * This is the first device for implicit notify on this GPE. 419 * Just set the flags here, and enter the NOTIFY block below. 420 */ 421 gpe_event_info->flags = 422 (ACPI_GPE_DISPATCH_NOTIFY | ACPI_GPE_LEVEL_TRIGGERED); 423 } else if (gpe_event_info->flags & ACPI_GPE_AUTO_ENABLED) { 424 /* 425 * A reference to this GPE has been added during the GPE block 426 * initialization, so drop it now to prevent the GPE from being 427 * permanently enabled and clear its ACPI_GPE_AUTO_ENABLED flag. 428 */ 429 (void)acpi_ev_remove_gpe_reference(gpe_event_info); 430 gpe_event_info->flags &= ~ACPI_GPE_AUTO_ENABLED; 431 } 432 433 /* 434 * If we already have an implicit notify on this GPE, add 435 * this device to the notify list. 436 */ 437 if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) == 438 ACPI_GPE_DISPATCH_NOTIFY) { 439 440 /* Ensure that the device is not already in the list */ 441 442 notify = gpe_event_info->dispatch.notify_list; 443 while (notify) { 444 if (notify->device_node == device_node) { 445 status = AE_ALREADY_EXISTS; 446 goto unlock_and_exit; 447 } 448 notify = notify->next; 449 } 450 451 /* Add this device to the notify list for this GPE */ 452 453 new_notify->device_node = device_node; 454 new_notify->next = gpe_event_info->dispatch.notify_list; 455 gpe_event_info->dispatch.notify_list = new_notify; 456 new_notify = NULL; 457 } 458 459 /* Mark the GPE as a possible wake event */ 460 461 gpe_event_info->flags |= ACPI_GPE_CAN_WAKE; 462 status = AE_OK; 463 464 unlock_and_exit: 465 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 466 467 /* Delete the notify object if it was not used above */ 468 469 if (new_notify) { 470 ACPI_FREE(new_notify); 471 } 472 return_ACPI_STATUS(status); 473 } 474 ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake) 475 476 /******************************************************************************* 477 * 478 * FUNCTION: acpi_set_gpe_wake_mask 479 * 480 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 481 * gpe_number - GPE level within the GPE block 482 * action - Enable or Disable 483 * 484 * RETURN: Status 485 * 486 * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit. The GPE must 487 * already be marked as a WAKE GPE. 488 * 489 ******************************************************************************/ 490 491 acpi_status 492 acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action) 493 { 494 acpi_status status = AE_OK; 495 struct acpi_gpe_event_info *gpe_event_info; 496 struct acpi_gpe_register_info *gpe_register_info; 497 acpi_cpu_flags flags; 498 u32 register_bit; 499 500 ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask); 501 502 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 503 504 /* 505 * Ensure that we have a valid GPE number and that this GPE is in 506 * fact a wake GPE 507 */ 508 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 509 if (!gpe_event_info) { 510 status = AE_BAD_PARAMETER; 511 goto unlock_and_exit; 512 } 513 514 if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) { 515 status = AE_TYPE; 516 goto unlock_and_exit; 517 } 518 519 gpe_register_info = gpe_event_info->register_info; 520 if (!gpe_register_info) { 521 status = AE_NOT_EXIST; 522 goto unlock_and_exit; 523 } 524 525 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info); 526 527 /* Perform the action */ 528 529 switch (action) { 530 case ACPI_GPE_ENABLE: 531 532 ACPI_SET_BIT(gpe_register_info->enable_for_wake, 533 (u8)register_bit); 534 break; 535 536 case ACPI_GPE_DISABLE: 537 538 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, 539 (u8)register_bit); 540 break; 541 542 default: 543 544 ACPI_ERROR((AE_INFO, "%u, Invalid action", action)); 545 status = AE_BAD_PARAMETER; 546 break; 547 } 548 549 unlock_and_exit: 550 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 551 return_ACPI_STATUS(status); 552 } 553 554 ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask) 555 556 /******************************************************************************* 557 * 558 * FUNCTION: acpi_clear_gpe 559 * 560 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 561 * gpe_number - GPE level within the GPE block 562 * 563 * RETURN: Status 564 * 565 * DESCRIPTION: Clear an ACPI event (general purpose) 566 * 567 ******************************************************************************/ 568 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number) 569 { 570 acpi_status status = AE_OK; 571 struct acpi_gpe_event_info *gpe_event_info; 572 acpi_cpu_flags flags; 573 574 ACPI_FUNCTION_TRACE(acpi_clear_gpe); 575 576 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 577 578 /* Ensure that we have a valid GPE number */ 579 580 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 581 if (!gpe_event_info) { 582 status = AE_BAD_PARAMETER; 583 goto unlock_and_exit; 584 } 585 586 status = acpi_hw_clear_gpe(gpe_event_info); 587 588 unlock_and_exit: 589 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 590 return_ACPI_STATUS(status); 591 } 592 593 ACPI_EXPORT_SYMBOL(acpi_clear_gpe) 594 595 /******************************************************************************* 596 * 597 * FUNCTION: acpi_get_gpe_status 598 * 599 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1 600 * gpe_number - GPE level within the GPE block 601 * event_status - Where the current status of the event 602 * will be returned 603 * 604 * RETURN: Status 605 * 606 * DESCRIPTION: Get the current status of a GPE (signalled/not_signalled) 607 * 608 ******************************************************************************/ 609 acpi_status 610 acpi_get_gpe_status(acpi_handle gpe_device, 611 u32 gpe_number, acpi_event_status *event_status) 612 { 613 acpi_status status = AE_OK; 614 struct acpi_gpe_event_info *gpe_event_info; 615 acpi_cpu_flags flags; 616 617 ACPI_FUNCTION_TRACE(acpi_get_gpe_status); 618 619 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 620 621 /* Ensure that we have a valid GPE number */ 622 623 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 624 if (!gpe_event_info) { 625 status = AE_BAD_PARAMETER; 626 goto unlock_and_exit; 627 } 628 629 /* Obtain status on the requested GPE number */ 630 631 status = acpi_hw_get_gpe_status(gpe_event_info, event_status); 632 633 unlock_and_exit: 634 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 635 return_ACPI_STATUS(status); 636 } 637 638 ACPI_EXPORT_SYMBOL(acpi_get_gpe_status) 639 640 /******************************************************************************* 641 * 642 * FUNCTION: acpi_finish_gpe 643 * 644 * PARAMETERS: gpe_device - Namespace node for the GPE Block 645 * (NULL for FADT defined GPEs) 646 * gpe_number - GPE level within the GPE block 647 * 648 * RETURN: Status 649 * 650 * DESCRIPTION: Clear and conditionally reenable a GPE. This completes the GPE 651 * processing. Intended for use by asynchronous host-installed 652 * GPE handlers. The GPE is only reenabled if the enable_for_run bit 653 * is set in the GPE info. 654 * 655 ******************************************************************************/ 656 acpi_status acpi_finish_gpe(acpi_handle gpe_device, u32 gpe_number) 657 { 658 struct acpi_gpe_event_info *gpe_event_info; 659 acpi_status status; 660 acpi_cpu_flags flags; 661 662 ACPI_FUNCTION_TRACE(acpi_finish_gpe); 663 664 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 665 666 /* Ensure that we have a valid GPE number */ 667 668 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 669 if (!gpe_event_info) { 670 status = AE_BAD_PARAMETER; 671 goto unlock_and_exit; 672 } 673 674 status = acpi_ev_finish_gpe(gpe_event_info); 675 676 unlock_and_exit: 677 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 678 return_ACPI_STATUS(status); 679 } 680 681 ACPI_EXPORT_SYMBOL(acpi_finish_gpe) 682 683 /****************************************************************************** 684 * 685 * FUNCTION: acpi_disable_all_gpes 686 * 687 * PARAMETERS: None 688 * 689 * RETURN: Status 690 * 691 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks 692 * 693 ******************************************************************************/ 694 695 acpi_status acpi_disable_all_gpes(void) 696 { 697 acpi_status status; 698 699 ACPI_FUNCTION_TRACE(acpi_disable_all_gpes); 700 701 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 702 if (ACPI_FAILURE(status)) { 703 return_ACPI_STATUS(status); 704 } 705 706 status = acpi_hw_disable_all_gpes(); 707 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 708 709 return_ACPI_STATUS(status); 710 } 711 712 ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes) 713 714 /****************************************************************************** 715 * 716 * FUNCTION: acpi_enable_all_runtime_gpes 717 * 718 * PARAMETERS: None 719 * 720 * RETURN: Status 721 * 722 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks 723 * 724 ******************************************************************************/ 725 726 acpi_status acpi_enable_all_runtime_gpes(void) 727 { 728 acpi_status status; 729 730 ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes); 731 732 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 733 if (ACPI_FAILURE(status)) { 734 return_ACPI_STATUS(status); 735 } 736 737 status = acpi_hw_enable_all_runtime_gpes(); 738 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 739 740 return_ACPI_STATUS(status); 741 } 742 743 ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes) 744 745 /****************************************************************************** 746 * 747 * FUNCTION: acpi_enable_all_wakeup_gpes 748 * 749 * PARAMETERS: None 750 * 751 * RETURN: Status 752 * 753 * DESCRIPTION: Enable all "wakeup" GPEs and disable all of the other GPEs, in 754 * all GPE blocks. 755 * 756 ******************************************************************************/ 757 acpi_status acpi_enable_all_wakeup_gpes(void) 758 { 759 acpi_status status; 760 761 ACPI_FUNCTION_TRACE(acpi_enable_all_wakeup_gpes); 762 763 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 764 if (ACPI_FAILURE(status)) { 765 return_ACPI_STATUS(status); 766 } 767 768 status = acpi_hw_enable_all_wakeup_gpes(); 769 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 770 771 return_ACPI_STATUS(status); 772 } 773 774 ACPI_EXPORT_SYMBOL(acpi_enable_all_wakeup_gpes) 775 776 /******************************************************************************* 777 * 778 * FUNCTION: acpi_install_gpe_block 779 * 780 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device 781 * gpe_block_address - Address and space_ID 782 * register_count - Number of GPE register pairs in the block 783 * interrupt_number - H/W interrupt for the block 784 * 785 * RETURN: Status 786 * 787 * DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not 788 * enabled here. 789 * 790 ******************************************************************************/ 791 acpi_status 792 acpi_install_gpe_block(acpi_handle gpe_device, 793 struct acpi_generic_address *gpe_block_address, 794 u32 register_count, u32 interrupt_number) 795 { 796 acpi_status status; 797 union acpi_operand_object *obj_desc; 798 struct acpi_namespace_node *node; 799 struct acpi_gpe_block_info *gpe_block; 800 801 ACPI_FUNCTION_TRACE(acpi_install_gpe_block); 802 803 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) { 804 return_ACPI_STATUS(AE_BAD_PARAMETER); 805 } 806 807 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 808 if (ACPI_FAILURE(status)) { 809 return_ACPI_STATUS(status); 810 } 811 812 node = acpi_ns_validate_handle(gpe_device); 813 if (!node) { 814 status = AE_BAD_PARAMETER; 815 goto unlock_and_exit; 816 } 817 818 /* Validate the parent device */ 819 820 if (node->type != ACPI_TYPE_DEVICE) { 821 status = AE_TYPE; 822 goto unlock_and_exit; 823 } 824 825 if (node->object) { 826 status = AE_ALREADY_EXISTS; 827 goto unlock_and_exit; 828 } 829 830 /* 831 * For user-installed GPE Block Devices, the gpe_block_base_number 832 * is always zero 833 */ 834 status = acpi_ev_create_gpe_block(node, gpe_block_address->address, 835 gpe_block_address->space_id, 836 register_count, 0, interrupt_number, 837 &gpe_block); 838 if (ACPI_FAILURE(status)) { 839 goto unlock_and_exit; 840 } 841 842 /* Install block in the device_object attached to the node */ 843 844 obj_desc = acpi_ns_get_attached_object(node); 845 if (!obj_desc) { 846 847 /* 848 * No object, create a new one (Device nodes do not always have 849 * an attached object) 850 */ 851 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE); 852 if (!obj_desc) { 853 status = AE_NO_MEMORY; 854 goto unlock_and_exit; 855 } 856 857 status = 858 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE); 859 860 /* Remove local reference to the object */ 861 862 acpi_ut_remove_reference(obj_desc); 863 864 if (ACPI_FAILURE(status)) { 865 goto unlock_and_exit; 866 } 867 } 868 869 /* Now install the GPE block in the device_object */ 870 871 obj_desc->device.gpe_block = gpe_block; 872 873 unlock_and_exit: 874 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 875 return_ACPI_STATUS(status); 876 } 877 878 ACPI_EXPORT_SYMBOL(acpi_install_gpe_block) 879 880 /******************************************************************************* 881 * 882 * FUNCTION: acpi_remove_gpe_block 883 * 884 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device 885 * 886 * RETURN: Status 887 * 888 * DESCRIPTION: Remove a previously installed block of GPE registers 889 * 890 ******************************************************************************/ 891 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device) 892 { 893 union acpi_operand_object *obj_desc; 894 acpi_status status; 895 struct acpi_namespace_node *node; 896 897 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block); 898 899 if (!gpe_device) { 900 return_ACPI_STATUS(AE_BAD_PARAMETER); 901 } 902 903 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 904 if (ACPI_FAILURE(status)) { 905 return_ACPI_STATUS(status); 906 } 907 908 node = acpi_ns_validate_handle(gpe_device); 909 if (!node) { 910 status = AE_BAD_PARAMETER; 911 goto unlock_and_exit; 912 } 913 914 /* Validate the parent device */ 915 916 if (node->type != ACPI_TYPE_DEVICE) { 917 status = AE_TYPE; 918 goto unlock_and_exit; 919 } 920 921 /* Get the device_object attached to the node */ 922 923 obj_desc = acpi_ns_get_attached_object(node); 924 if (!obj_desc || !obj_desc->device.gpe_block) { 925 return_ACPI_STATUS(AE_NULL_OBJECT); 926 } 927 928 /* Delete the GPE block (but not the device_object) */ 929 930 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block); 931 if (ACPI_SUCCESS(status)) { 932 obj_desc->device.gpe_block = NULL; 933 } 934 935 unlock_and_exit: 936 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 937 return_ACPI_STATUS(status); 938 } 939 940 ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block) 941 942 /******************************************************************************* 943 * 944 * FUNCTION: acpi_get_gpe_device 945 * 946 * PARAMETERS: index - System GPE index (0-current_gpe_count) 947 * gpe_device - Where the parent GPE Device is returned 948 * 949 * RETURN: Status 950 * 951 * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL 952 * gpe device indicates that the gpe number is contained in one of 953 * the FADT-defined gpe blocks. Otherwise, the GPE block device. 954 * 955 ******************************************************************************/ 956 acpi_status acpi_get_gpe_device(u32 index, acpi_handle *gpe_device) 957 { 958 struct acpi_gpe_device_info info; 959 acpi_status status; 960 961 ACPI_FUNCTION_TRACE(acpi_get_gpe_device); 962 963 if (!gpe_device) { 964 return_ACPI_STATUS(AE_BAD_PARAMETER); 965 } 966 967 if (index >= acpi_current_gpe_count) { 968 return_ACPI_STATUS(AE_NOT_EXIST); 969 } 970 971 /* Setup and walk the GPE list */ 972 973 info.index = index; 974 info.status = AE_NOT_EXIST; 975 info.gpe_device = NULL; 976 info.next_block_base_index = 0; 977 978 status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info); 979 if (ACPI_FAILURE(status)) { 980 return_ACPI_STATUS(status); 981 } 982 983 *gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device); 984 return_ACPI_STATUS(info.status); 985 } 986 987 ACPI_EXPORT_SYMBOL(acpi_get_gpe_device) 988 #endif /* !ACPI_REDUCED_HARDWARE */ 989