drivers/acpi/acpica/evxfgpe.c

   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 - 2020, 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, TRUE);
 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_gispatch_gpe
 643  *
 644  * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
 645  *              gpe_number          - GPE level within the GPE block
 646  *
 647  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
 648  *
 649  * DESCRIPTION: Detect and dispatch a General Purpose Event to either a function
 650  *              (e.g. EC) or method (e.g. _Lxx/_Exx) handler.
 651  *
 652  ******************************************************************************/
 653 u32 acpi_dispatch_gpe(acpi_handle gpe_device, u32 gpe_number)
 654 {
 655         ACPI_FUNCTION_TRACE(acpi_dispatch_gpe);
 656
 657         return acpi_ev_detect_gpe(gpe_device, NULL, gpe_number);
 658 }
 659
 660 ACPI_EXPORT_SYMBOL(acpi_dispatch_gpe)
 661
 662 /*******************************************************************************
 663  *
 664  * FUNCTION:    acpi_finish_gpe
 665  *
 666  * PARAMETERS:  gpe_device          - Namespace node for the GPE Block
 667  *                                    (NULL for FADT defined GPEs)
 668  *              gpe_number          - GPE level within the GPE block
 669  *
 670  * RETURN:      Status
 671  *
 672  * DESCRIPTION: Clear and conditionally re-enable a GPE. This completes the GPE
 673  *              processing. Intended for use by asynchronous host-installed
 674  *              GPE handlers. The GPE is only re-enabled if the enable_for_run bit
 675  *              is set in the GPE info.
 676  *
 677  ******************************************************************************/
 678 acpi_status acpi_finish_gpe(acpi_handle gpe_device, u32 gpe_number)
 679 {
 680         struct acpi_gpe_event_info *gpe_event_info;
 681         acpi_status status;
 682         acpi_cpu_flags flags;
 683
 684         ACPI_FUNCTION_TRACE(acpi_finish_gpe);
 685
 686         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 687
 688         /* Ensure that we have a valid GPE number */
 689
 690         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
 691         if (!gpe_event_info) {
 692                 status = AE_BAD_PARAMETER;
 693                 goto unlock_and_exit;
 694         }
 695
 696         status = acpi_ev_finish_gpe(gpe_event_info);
 697
 698 unlock_and_exit:
 699         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 700         return_ACPI_STATUS(status);
 701 }
 702
 703 ACPI_EXPORT_SYMBOL(acpi_finish_gpe)
 704
 705 /******************************************************************************
 706  *
 707  * FUNCTION:    acpi_disable_all_gpes
 708  *
 709  * PARAMETERS:  None
 710  *
 711  * RETURN:      Status
 712  *
 713  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
 714  *
 715  ******************************************************************************/
 716
 717 acpi_status acpi_disable_all_gpes(void)
 718 {
 719         acpi_status status;
 720
 721         ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
 722
 723         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 724         if (ACPI_FAILURE(status)) {
 725                 return_ACPI_STATUS(status);
 726         }
 727
 728         status = acpi_hw_disable_all_gpes();
 729         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 730
 731         return_ACPI_STATUS(status);
 732 }
 733
 734 ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)
 735
 736 /******************************************************************************
 737  *
 738  * FUNCTION:    acpi_enable_all_runtime_gpes
 739  *
 740  * PARAMETERS:  None
 741  *
 742  * RETURN:      Status
 743  *
 744  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
 745  *
 746  ******************************************************************************/
 747
 748 acpi_status acpi_enable_all_runtime_gpes(void)
 749 {
 750         acpi_status status;
 751
 752         ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
 753
 754         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 755         if (ACPI_FAILURE(status)) {
 756                 return_ACPI_STATUS(status);
 757         }
 758
 759         status = acpi_hw_enable_all_runtime_gpes();
 760         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 761
 762         return_ACPI_STATUS(status);
 763 }
 764
 765 ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)
 766
 767 /******************************************************************************
 768  *
 769  * FUNCTION:    acpi_enable_all_wakeup_gpes
 770  *
 771  * PARAMETERS:  None
 772  *
 773  * RETURN:      Status
 774  *
 775  * DESCRIPTION: Enable all "wakeup" GPEs and disable all of the other GPEs, in
 776  *              all GPE blocks.
 777  *
 778  ******************************************************************************/
 779 acpi_status acpi_enable_all_wakeup_gpes(void)
 780 {
 781         acpi_status status;
 782
 783         ACPI_FUNCTION_TRACE(acpi_enable_all_wakeup_gpes);
 784
 785         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 786         if (ACPI_FAILURE(status)) {
 787                 return_ACPI_STATUS(status);
 788         }
 789
 790         status = acpi_hw_enable_all_wakeup_gpes();
 791         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 792
 793         return_ACPI_STATUS(status);
 794 }
 795
 796 ACPI_EXPORT_SYMBOL(acpi_enable_all_wakeup_gpes)
 797
 798 /******************************************************************************
 799  *
 800  * FUNCTION:    acpi_any_gpe_status_set
 801  *
 802  * PARAMETERS:  gpe_skip_number      - Number of the GPE to skip
 803  *
 804  * RETURN:      Whether or not the status bit is set for any GPE
 805  *
 806  * DESCRIPTION: Check the status bits of all enabled GPEs, except for the one
 807  *              represented by the "skip" argument, and return TRUE if any of
 808  *              them is set or FALSE otherwise.
 809  *
 810  ******************************************************************************/
 811 u32 acpi_any_gpe_status_set(u32 gpe_skip_number)
 812 {
 813         acpi_status status;
 814         acpi_handle gpe_device;
 815         u8 ret;
 816
 817         ACPI_FUNCTION_TRACE(acpi_any_gpe_status_set);
 818
 819         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 820         if (ACPI_FAILURE(status)) {
 821                 return (FALSE);
 822         }
 823
 824         status = acpi_get_gpe_device(gpe_skip_number, &gpe_device);
 825         if (ACPI_FAILURE(status)) {
 826                 gpe_device = NULL;
 827         }
 828
 829         ret = acpi_hw_check_all_gpes(gpe_device, gpe_skip_number);
 830         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 831
 832         return (ret);
 833 }
 834
 835 ACPI_EXPORT_SYMBOL(acpi_any_gpe_status_set)
 836
 837 /*******************************************************************************
 838  *
 839  * FUNCTION:    acpi_install_gpe_block
 840  *
 841  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
 842  *              gpe_block_address   - Address and space_ID
 843  *              register_count      - Number of GPE register pairs in the block
 844  *              interrupt_number    - H/W interrupt for the block
 845  *
 846  * RETURN:      Status
 847  *
 848  * DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not
 849  *              enabled here.
 850  *
 851  ******************************************************************************/
 852 acpi_status
 853 acpi_install_gpe_block(acpi_handle gpe_device,
 854                        struct acpi_generic_address *gpe_block_address,
 855                        u32 register_count, u32 interrupt_number)
 856 {
 857         acpi_status status;
 858         union acpi_operand_object *obj_desc;
 859         struct acpi_namespace_node *node;
 860         struct acpi_gpe_block_info *gpe_block;
 861
 862         ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
 863
 864         if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
 865                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 866         }
 867
 868         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 869         if (ACPI_FAILURE(status)) {
 870                 return_ACPI_STATUS(status);
 871         }
 872
 873         node = acpi_ns_validate_handle(gpe_device);
 874         if (!node) {
 875                 status = AE_BAD_PARAMETER;
 876                 goto unlock_and_exit;
 877         }
 878
 879         /* Validate the parent device */
 880
 881         if (node->type != ACPI_TYPE_DEVICE) {
 882                 status = AE_TYPE;
 883                 goto unlock_and_exit;
 884         }
 885
 886         if (node->object) {
 887                 status = AE_ALREADY_EXISTS;
 888                 goto unlock_and_exit;
 889         }
 890
 891         /*
 892          * For user-installed GPE Block Devices, the gpe_block_base_number
 893          * is always zero
 894          */
 895         status = acpi_ev_create_gpe_block(node, gpe_block_address->address,
 896                                           gpe_block_address->space_id,
 897                                           register_count, 0, interrupt_number,
 898                                           &gpe_block);
 899         if (ACPI_FAILURE(status)) {
 900                 goto unlock_and_exit;
 901         }
 902
 903         /* Install block in the device_object attached to the node */
 904
 905         obj_desc = acpi_ns_get_attached_object(node);
 906         if (!obj_desc) {
 907
 908                 /*
 909                  * No object, create a new one (Device nodes do not always have
 910                  * an attached object)
 911                  */
 912                 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
 913                 if (!obj_desc) {
 914                         status = AE_NO_MEMORY;
 915                         goto unlock_and_exit;
 916                 }
 917
 918                 status =
 919                     acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
 920
 921                 /* Remove local reference to the object */
 922
 923                 acpi_ut_remove_reference(obj_desc);
 924
 925                 if (ACPI_FAILURE(status)) {
 926                         goto unlock_and_exit;
 927                 }
 928         }
 929
 930         /* Now install the GPE block in the device_object */
 931
 932         obj_desc->device.gpe_block = gpe_block;
 933
 934 unlock_and_exit:
 935         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 936         return_ACPI_STATUS(status);
 937 }
 938
 939 ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
 940
 941 /*******************************************************************************
 942  *
 943  * FUNCTION:    acpi_remove_gpe_block
 944  *
 945  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
 946  *
 947  * RETURN:      Status
 948  *
 949  * DESCRIPTION: Remove a previously installed block of GPE registers
 950  *
 951  ******************************************************************************/
 952 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
 953 {
 954         union acpi_operand_object *obj_desc;
 955         acpi_status status;
 956         struct acpi_namespace_node *node;
 957
 958         ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
 959
 960         if (!gpe_device) {
 961                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 962         }
 963
 964         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 965         if (ACPI_FAILURE(status)) {
 966                 return_ACPI_STATUS(status);
 967         }
 968
 969         node = acpi_ns_validate_handle(gpe_device);
 970         if (!node) {
 971                 status = AE_BAD_PARAMETER;
 972                 goto unlock_and_exit;
 973         }
 974
 975         /* Validate the parent device */
 976
 977         if (node->type != ACPI_TYPE_DEVICE) {
 978                 status = AE_TYPE;
 979                 goto unlock_and_exit;
 980         }
 981
 982         /* Get the device_object attached to the node */
 983
 984         obj_desc = acpi_ns_get_attached_object(node);
 985         if (!obj_desc || !obj_desc->device.gpe_block) {
 986                 return_ACPI_STATUS(AE_NULL_OBJECT);
 987         }
 988
 989         /* Delete the GPE block (but not the device_object) */
 990
 991         status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
 992         if (ACPI_SUCCESS(status)) {
 993                 obj_desc->device.gpe_block = NULL;
 994         }
 995
 996 unlock_and_exit:
 997         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 998         return_ACPI_STATUS(status);
 999 }
1000
1001 ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
1002
1003 /*******************************************************************************
1004  *
1005  * FUNCTION:    acpi_get_gpe_device
1006  *
1007  * PARAMETERS:  index               - System GPE index (0-current_gpe_count)
1008  *              gpe_device          - Where the parent GPE Device is returned
1009  *
1010  * RETURN:      Status
1011  *
1012  * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
1013  *              gpe device indicates that the gpe number is contained in one of
1014  *              the FADT-defined gpe blocks. Otherwise, the GPE block device.
1015  *
1016  ******************************************************************************/
1017 acpi_status acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)
1018 {
1019         struct acpi_gpe_device_info info;
1020         acpi_status status;
1021
1022         ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
1023
1024         if (!gpe_device) {
1025                 return_ACPI_STATUS(AE_BAD_PARAMETER);
1026         }
1027
1028         if (index >= acpi_current_gpe_count) {
1029                 return_ACPI_STATUS(AE_NOT_EXIST);
1030         }
1031
1032         /* Setup and walk the GPE list */
1033
1034         info.index = index;
1035         info.status = AE_NOT_EXIST;
1036         info.gpe_device = NULL;
1037         info.next_block_base_index = 0;
1038
1039         status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
1040         if (ACPI_FAILURE(status)) {
1041                 return_ACPI_STATUS(status);
1042         }
1043
1044         *gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device);
1045         return_ACPI_STATUS(info.status);
1046 }
1047
1048 ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
1049 #endif                          /* !ACPI_REDUCED_HARDWARE */