drivers/acpi/acpica/evgpe.c

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