drivers/acpi/acpica/evgpe.c

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