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 - 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 */