drivers/acpi/components/events/evgpeblk.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evgpeblk - GPE block creation and initialization.
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include "acpi.h"
 117 #include "accommon.h"
 118 #include "acevents.h"
 119 #include "acnamesp.h"
 120
 121 #define _COMPONENT          ACPI_EVENTS
 122         ACPI_MODULE_NAME    ("evgpeblk")
 123
 124 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
 125
 126 /* Local prototypes */
 127
 128 static ACPI_STATUS
 129 AcpiEvInstallGpeBlock (
 130     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 131     UINT32                  InterruptNumber);
 132
 133 static ACPI_STATUS
 134 AcpiEvCreateGpeInfoBlocks (
 135     ACPI_GPE_BLOCK_INFO     *GpeBlock);
 136
 137
 138 /*******************************************************************************
 139  *
 140  * FUNCTION:    AcpiEvInstallGpeBlock
 141  *
 142  * PARAMETERS:  GpeBlock                - New GPE block
 143  *              InterruptNumber         - Xrupt to be associated with this
 144  *                                        GPE block
 145  *
 146  * RETURN:      Status
 147  *
 148  * DESCRIPTION: Install new GPE block with mutex support
 149  *
 150  ******************************************************************************/
 151
 152 static ACPI_STATUS
 153 AcpiEvInstallGpeBlock (
 154     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 155     UINT32                  InterruptNumber)
 156 {
 157     ACPI_GPE_BLOCK_INFO     *NextGpeBlock;
 158     ACPI_GPE_XRUPT_INFO     *GpeXruptBlock;
 159     ACPI_STATUS             Status;
 160     ACPI_CPU_FLAGS          Flags;
 161
 162
 163     ACPI_FUNCTION_TRACE (EvInstallGpeBlock);
 164
 165
 166     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 167     if (ACPI_FAILURE (Status))
 168     {
 169         return_ACPI_STATUS (Status);
 170     }
 171
 172     Status = AcpiEvGetGpeXruptBlock (InterruptNumber, &GpeXruptBlock);
 173     if (ACPI_FAILURE (Status))
 174     {
 175         goto UnlockAndExit;
 176     }
 177
 178     /* Install the new block at the end of the list with lock */
 179
 180     Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 181     if (GpeXruptBlock->GpeBlockListHead)
 182     {
 183         NextGpeBlock = GpeXruptBlock->GpeBlockListHead;
 184         while (NextGpeBlock->Next)
 185         {
 186             NextGpeBlock = NextGpeBlock->Next;
 187         }
 188
 189         NextGpeBlock->Next = GpeBlock;
 190         GpeBlock->Previous = NextGpeBlock;
 191     }
 192     else
 193     {
 194         GpeXruptBlock->GpeBlockListHead = GpeBlock;
 195     }
 196
 197     GpeBlock->XruptBlock = GpeXruptBlock;
 198     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 199
 200
 201 UnlockAndExit:
 202     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 203     return_ACPI_STATUS (Status);
 204 }
 205
 206
 207 /*******************************************************************************
 208  *
 209  * FUNCTION:    AcpiEvDeleteGpeBlock
 210  *
 211  * PARAMETERS:  GpeBlock            - Existing GPE block
 212  *
 213  * RETURN:      Status
 214  *
 215  * DESCRIPTION: Remove a GPE block
 216  *
 217  ******************************************************************************/
 218
 219 ACPI_STATUS
 220 AcpiEvDeleteGpeBlock (
 221     ACPI_GPE_BLOCK_INFO     *GpeBlock)
 222 {
 223     ACPI_STATUS             Status;
 224     ACPI_CPU_FLAGS          Flags;
 225
 226
 227     ACPI_FUNCTION_TRACE (EvInstallGpeBlock);
 228
 229
 230     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 231     if (ACPI_FAILURE (Status))
 232     {
 233         return_ACPI_STATUS (Status);
 234     }
 235
 236     /* Disable all GPEs in this block */
 237
 238     Status = AcpiHwDisableGpeBlock (GpeBlock->XruptBlock, GpeBlock, NULL);
 239
 240     if (!GpeBlock->Previous && !GpeBlock->Next)
 241     {
 242         /* This is the last GpeBlock on this interrupt */
 243
 244         Status = AcpiEvDeleteGpeXrupt (GpeBlock->XruptBlock);
 245         if (ACPI_FAILURE (Status))
 246         {
 247             goto UnlockAndExit;
 248         }
 249     }
 250     else
 251     {
 252         /* Remove the block on this interrupt with lock */
 253
 254         Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 255         if (GpeBlock->Previous)
 256         {
 257             GpeBlock->Previous->Next = GpeBlock->Next;
 258         }
 259         else
 260         {
 261             GpeBlock->XruptBlock->GpeBlockListHead = GpeBlock->Next;
 262         }
 263
 264         if (GpeBlock->Next)
 265         {
 266             GpeBlock->Next->Previous = GpeBlock->Previous;
 267         }
 268         AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 269     }
 270
 271     AcpiCurrentGpeCount -= GpeBlock->GpeCount;
 272
 273     /* Free the GpeBlock */
 274
 275     ACPI_FREE (GpeBlock->RegisterInfo);
 276     ACPI_FREE (GpeBlock->EventInfo);
 277     ACPI_FREE (GpeBlock);
 278
 279 UnlockAndExit:
 280     Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 281     return_ACPI_STATUS (Status);
 282 }
 283
 284
 285 /*******************************************************************************
 286  *
 287  * FUNCTION:    AcpiEvCreateGpeInfoBlocks
 288  *
 289  * PARAMETERS:  GpeBlock    - New GPE block
 290  *
 291  * RETURN:      Status
 292  *
 293  * DESCRIPTION: Create the RegisterInfo and EventInfo blocks for this GPE block
 294  *
 295  ******************************************************************************/
 296
 297 static ACPI_STATUS
 298 AcpiEvCreateGpeInfoBlocks (
 299     ACPI_GPE_BLOCK_INFO     *GpeBlock)
 300 {
 301     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo = NULL;
 302     ACPI_GPE_EVENT_INFO     *GpeEventInfo = NULL;
 303     ACPI_GPE_EVENT_INFO     *ThisEvent;
 304     ACPI_GPE_REGISTER_INFO  *ThisRegister;
 305     UINT32                  i;
 306     UINT32                  j;
 307     ACPI_STATUS             Status;
 308
 309
 310     ACPI_FUNCTION_TRACE (EvCreateGpeInfoBlocks);
 311
 312
 313     /* Allocate the GPE register information block */
 314
 315     GpeRegisterInfo = ACPI_ALLOCATE_ZEROED (
 316                         (ACPI_SIZE) GpeBlock->RegisterCount *
 317                         sizeof (ACPI_GPE_REGISTER_INFO));
 318     if (!GpeRegisterInfo)
 319     {
 320         ACPI_ERROR ((AE_INFO,
 321             "Could not allocate the GpeRegisterInfo table"));
 322         return_ACPI_STATUS (AE_NO_MEMORY);
 323     }
 324
 325     /*
 326      * Allocate the GPE EventInfo block. There are eight distinct GPEs
 327      * per register. Initialization to zeros is sufficient.
 328      */
 329     GpeEventInfo = ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) GpeBlock->GpeCount *
 330                     sizeof (ACPI_GPE_EVENT_INFO));
 331     if (!GpeEventInfo)
 332     {
 333         ACPI_ERROR ((AE_INFO,
 334             "Could not allocate the GpeEventInfo table"));
 335         Status = AE_NO_MEMORY;
 336         goto ErrorExit;
 337     }
 338
 339     /* Save the new Info arrays in the GPE block */
 340
 341     GpeBlock->RegisterInfo = GpeRegisterInfo;
 342     GpeBlock->EventInfo    = GpeEventInfo;
 343
 344     /*
 345      * Initialize the GPE Register and Event structures. A goal of these
 346      * tables is to hide the fact that there are two separate GPE register
 347      * sets in a given GPE hardware block, the status registers occupy the
 348      * first half, and the enable registers occupy the second half.
 349      */
 350     ThisRegister = GpeRegisterInfo;
 351     ThisEvent    = GpeEventInfo;
 352
 353     for (i = 0; i < GpeBlock->RegisterCount; i++)
 354     {
 355         /* Init the RegisterInfo for this GPE register (8 GPEs) */
 356
 357         ThisRegister->BaseGpeNumber = (UINT16)
 358             (GpeBlock->BlockBaseNumber + (i * ACPI_GPE_REGISTER_WIDTH));
 359
 360         ThisRegister->StatusAddress.Address =
 361             GpeBlock->Address + i;
 362
 363         ThisRegister->EnableAddress.Address =
 364             GpeBlock->Address + i + GpeBlock->RegisterCount;
 365
 366         ThisRegister->StatusAddress.SpaceId   = GpeBlock->SpaceId;
 367         ThisRegister->EnableAddress.SpaceId   = GpeBlock->SpaceId;
 368         ThisRegister->StatusAddress.BitWidth  = ACPI_GPE_REGISTER_WIDTH;
 369         ThisRegister->EnableAddress.BitWidth  = ACPI_GPE_REGISTER_WIDTH;
 370         ThisRegister->StatusAddress.BitOffset = 0;
 371         ThisRegister->EnableAddress.BitOffset = 0;
 372
 373         /* Init the EventInfo for each GPE within this register */
 374
 375         for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
 376         {
 377             ThisEvent->GpeNumber = (UINT8) (ThisRegister->BaseGpeNumber + j);
 378             ThisEvent->RegisterInfo = ThisRegister;
 379             ThisEvent++;
 380         }
 381
 382         /* Disable all GPEs within this register */
 383
 384         Status = AcpiHwWrite (0x00, &ThisRegister->EnableAddress);
 385         if (ACPI_FAILURE (Status))
 386         {
 387             goto ErrorExit;
 388         }
 389
 390         /* Clear any pending GPE events within this register */
 391
 392         Status = AcpiHwWrite (0xFF, &ThisRegister->StatusAddress);
 393         if (ACPI_FAILURE (Status))
 394         {
 395             goto ErrorExit;
 396         }
 397
 398         ThisRegister++;
 399     }
 400
 401     return_ACPI_STATUS (AE_OK);
 402
 403
 404 ErrorExit:
 405     if (GpeRegisterInfo)
 406     {
 407         ACPI_FREE (GpeRegisterInfo);
 408     }
 409     if (GpeEventInfo)
 410     {
 411         ACPI_FREE (GpeEventInfo);
 412     }
 413
 414     return_ACPI_STATUS (Status);
 415 }
 416
 417
 418 /*******************************************************************************
 419  *
 420  * FUNCTION:    AcpiEvCreateGpeBlock
 421  *
 422  * PARAMETERS:  GpeDevice           - Handle to the parent GPE block
 423  *              GpeBlockAddress     - Address and SpaceID
 424  *              RegisterCount       - Number of GPE register pairs in the block
 425  *              GpeBlockBaseNumber  - Starting GPE number for the block
 426  *              InterruptNumber     - H/W interrupt for the block
 427  *              ReturnGpeBlock      - Where the new block descriptor is returned
 428  *
 429  * RETURN:      Status
 430  *
 431  * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
 432  *              the block are disabled at exit.
 433  *              Note: Assumes namespace is locked.
 434  *
 435  ******************************************************************************/
 436
 437 ACPI_STATUS
 438 AcpiEvCreateGpeBlock (
 439     ACPI_NAMESPACE_NODE     *GpeDevice,
 440     UINT64                  Address,
 441     UINT8                   SpaceId,
 442     UINT32                  RegisterCount,
 443     UINT16                  GpeBlockBaseNumber,
 444     UINT32                  InterruptNumber,
 445     ACPI_GPE_BLOCK_INFO     **ReturnGpeBlock)
 446 {
 447     ACPI_STATUS             Status;
 448     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 449     ACPI_GPE_WALK_INFO      WalkInfo;
 450
 451
 452     ACPI_FUNCTION_TRACE (EvCreateGpeBlock);
 453
 454
 455     if (!RegisterCount)
 456     {
 457         return_ACPI_STATUS (AE_OK);
 458     }
 459
 460     /* Allocate a new GPE block */
 461
 462     GpeBlock = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_BLOCK_INFO));
 463     if (!GpeBlock)
 464     {
 465         return_ACPI_STATUS (AE_NO_MEMORY);
 466     }
 467
 468     /* Initialize the new GPE block */
 469
 470     GpeBlock->Address = Address;
 471     GpeBlock->SpaceId = SpaceId;
 472     GpeBlock->Node = GpeDevice;
 473     GpeBlock->GpeCount = (UINT16) (RegisterCount * ACPI_GPE_REGISTER_WIDTH);
 474     GpeBlock->Initialized = FALSE;
 475     GpeBlock->RegisterCount = RegisterCount;
 476     GpeBlock->BlockBaseNumber = GpeBlockBaseNumber;
 477
 478     /*
 479      * Create the RegisterInfo and EventInfo sub-structures
 480      * Note: disables and clears all GPEs in the block
 481      */
 482     Status = AcpiEvCreateGpeInfoBlocks (GpeBlock);
 483     if (ACPI_FAILURE (Status))
 484     {
 485         ACPI_FREE (GpeBlock);
 486         return_ACPI_STATUS (Status);
 487     }
 488
 489     /* Install the new block in the global lists */
 490
 491     Status = AcpiEvInstallGpeBlock (GpeBlock, InterruptNumber);
 492     if (ACPI_FAILURE (Status))
 493     {
 494         ACPI_FREE (GpeBlock->RegisterInfo);
 495         ACPI_FREE (GpeBlock->EventInfo);
 496         ACPI_FREE (GpeBlock);
 497         return_ACPI_STATUS (Status);
 498     }
 499
 500     AcpiGbl_AllGpesInitialized = FALSE;
 501
 502     /* Find all GPE methods (_Lxx or_Exx) for this block */
 503
 504     WalkInfo.GpeBlock = GpeBlock;
 505     WalkInfo.GpeDevice = GpeDevice;
 506     WalkInfo.ExecuteByOwnerId = FALSE;
 507
 508     Status = AcpiNsWalkNamespace (ACPI_TYPE_METHOD, GpeDevice,
 509                 ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
 510                 AcpiEvMatchGpeMethod, NULL, &WalkInfo, NULL);
 511
 512     /* Return the new block */
 513
 514     if (ReturnGpeBlock)
 515     {
 516         (*ReturnGpeBlock) = GpeBlock;
 517     }
 518
 519     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
 520         "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
 521         (UINT32) GpeBlock->BlockBaseNumber,
 522         (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)),
 523         GpeDevice->Name.Ascii, GpeBlock->RegisterCount, InterruptNumber,
 524         InterruptNumber == AcpiGbl_FADT.SciInterrupt ? " (SCI)" : ""));
 525
 526     /* Update global count of currently available GPEs */
 527
 528     AcpiCurrentGpeCount += GpeBlock->GpeCount;
 529     return_ACPI_STATUS (AE_OK);
 530 }
 531
 532
 533 /*******************************************************************************
 534  *
 535  * FUNCTION:    AcpiEvInitializeGpeBlock
 536  *
 537  * PARAMETERS:  ACPI_GPE_CALLBACK
 538  *
 539  * RETURN:      Status
 540  *
 541  * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have
 542  *              associated methods.
 543  *              Note: Assumes namespace is locked.
 544  *
 545  ******************************************************************************/
 546
 547 ACPI_STATUS
 548 AcpiEvInitializeGpeBlock (
 549     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
 550     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 551     void                    *Ignored)
 552 {
 553     ACPI_STATUS             Status;
 554     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 555     UINT32                  GpeEnabledCount;
 556     UINT32                  GpeIndex;
 557     UINT32                  i;
 558     UINT32                  j;
 559
 560
 561     ACPI_FUNCTION_TRACE (EvInitializeGpeBlock);
 562
 563
 564     /*
 565      * Ignore a null GPE block (e.g., if no GPE block 1 exists), and
 566      * any GPE blocks that have been initialized already.
 567      */
 568     if (!GpeBlock || GpeBlock->Initialized)
 569     {
 570         return_ACPI_STATUS (AE_OK);
 571     }
 572
 573     /*
 574      * Enable all GPEs that have a corresponding method and have the
 575      * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block
 576      * must be enabled via the acpi_enable_gpe() interface.
 577      */
 578     GpeEnabledCount = 0;
 579
 580     for (i = 0; i < GpeBlock->RegisterCount; i++)
 581     {
 582         for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
 583         {
 584             /* Get the info block for this particular GPE */
 585
 586             GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
 587             GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
 588
 589             /*
 590              * Ignore GPEs that have no corresponding _Lxx/_Exx method
 591              * and GPEs that are used to wake the system
 592              */
 593             if ((ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_NONE) ||
 594                 (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_HANDLER) ||
 595                 (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_RAW_HANDLER) ||
 596                 (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE))
 597             {
 598                 continue;
 599             }
 600
 601             Status = AcpiEvAddGpeReference (GpeEventInfo);
 602             if (ACPI_FAILURE (Status))
 603             {
 604                 ACPI_EXCEPTION ((AE_INFO, Status,
 605                     "Could not enable GPE 0x%02X",
 606                     GpeIndex + GpeBlock->BlockBaseNumber));
 607                 continue;
 608             }
 609
 610             GpeEnabledCount++;
 611         }
 612     }
 613
 614     if (GpeEnabledCount)
 615     {
 616         ACPI_INFO ((AE_INFO,
 617             "Enabled %u GPEs in block %02X to %02X", GpeEnabledCount,
 618             (UINT32) GpeBlock->BlockBaseNumber,
 619             (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1))));
 620     }
 621
 622     GpeBlock->Initialized = TRUE;
 623     return_ACPI_STATUS (AE_OK);
 624 }
 625
 626 #endif /* !ACPI_REDUCED_HARDWARE */