6/sys/contrib/dev/acpica/evgpeblk.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evgpeblk - GPE block creation and initialization.
   4  *              $Revision: 39 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #include <contrib/dev/acpica/acpi.h>
 118 #include <contrib/dev/acpica/acevents.h>
 119 #include <contrib/dev/acpica/acnamesp.h>
 120
 121 #define _COMPONENT          ACPI_EVENTS
 122         ACPI_MODULE_NAME    ("evgpeblk")
 123
 124
 125 /*******************************************************************************
 126  *
 127  * FUNCTION:    AcpiEvValidGpeEvent
 128  *
 129  * PARAMETERS:  GpeEventInfo                - Info for this GPE
 130  *
 131  * RETURN:      TRUE if the GpeEvent is valid
 132  *
 133  * DESCRIPTION: Validate a GPE event.  DO NOT CALL FROM INTERRUPT LEVEL.
 134  *              Should be called only when the GPE lists are semaphore locked
 135  *              and not subject to change.
 136  *
 137  ******************************************************************************/
 138
 139 BOOLEAN
 140 AcpiEvValidGpeEvent (
 141     ACPI_GPE_EVENT_INFO     *GpeEventInfo)
 142 {
 143     ACPI_GPE_XRUPT_INFO     *GpeXruptBlock;
 144     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 145
 146
 147     ACPI_FUNCTION_ENTRY ();
 148
 149
 150     /* No need for spin lock since we are not changing any list elements */
 151
 152     /* Walk the GPE interrupt levels */
 153
 154     GpeXruptBlock = AcpiGbl_GpeXruptListHead;
 155     while (GpeXruptBlock)
 156     {
 157         GpeBlock = GpeXruptBlock->GpeBlockListHead;
 158
 159         /* Walk the GPE blocks on this interrupt level */
 160
 161         while (GpeBlock)
 162         {
 163             if ((&GpeBlock->EventInfo[0] <= GpeEventInfo) &&
 164                 (&GpeBlock->EventInfo[((ACPI_SIZE) GpeBlock->RegisterCount) * 8] > GpeEventInfo))
 165             {
 166                 return (TRUE);
 167             }
 168
 169             GpeBlock = GpeBlock->Next;
 170         }
 171
 172         GpeXruptBlock = GpeXruptBlock->Next;
 173     }
 174
 175     return (FALSE);
 176 }
 177
 178
 179 /*******************************************************************************
 180  *
 181  * FUNCTION:    AcpiEvWalkGpeList
 182  *
 183  * PARAMETERS:  GpeWalkCallback     - Routine called for each GPE block
 184  *              Flags               - ACPI_NOT_ISR or ACPI_ISR
 185  *
 186  * RETURN:      Status
 187  *
 188  * DESCRIPTION: Walk the GPE lists.
 189  *
 190  ******************************************************************************/
 191
 192 ACPI_STATUS
 193 AcpiEvWalkGpeList (
 194     ACPI_GPE_CALLBACK       GpeWalkCallback,
 195     UINT32                  Flags)
 196 {
 197     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 198     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo;
 199     ACPI_STATUS             Status = AE_OK;
 200
 201
 202     ACPI_FUNCTION_TRACE ("EvWalkGpeList");
 203
 204
 205     AcpiOsAcquireLock (AcpiGbl_GpeLock, Flags);
 206
 207     /* Walk the interrupt level descriptor list */
 208
 209     GpeXruptInfo = AcpiGbl_GpeXruptListHead;
 210     while (GpeXruptInfo)
 211     {
 212         /* Walk all Gpe Blocks attached to this interrupt level */
 213
 214         GpeBlock = GpeXruptInfo->GpeBlockListHead;
 215         while (GpeBlock)
 216         {
 217             /* One callback per GPE block */
 218
 219             Status = GpeWalkCallback (GpeXruptInfo, GpeBlock);
 220             if (ACPI_FAILURE (Status))
 221             {
 222                 goto UnlockAndExit;
 223             }
 224
 225             GpeBlock = GpeBlock->Next;
 226         }
 227
 228         GpeXruptInfo = GpeXruptInfo->Next;
 229     }
 230
 231 UnlockAndExit:
 232     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 233     return_ACPI_STATUS (Status);
 234 }
 235
 236
 237 /******************************************************************************
 238  *
 239  * FUNCTION:    AcpiEvDeleteGpeHandlers
 240  *
 241  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
 242  *              GpeBlock            - Gpe Block info
 243  *
 244  * RETURN:      Status
 245  *
 246  * DESCRIPTION: Delete all Handler objects found in the GPE data structs.
 247  *              Used only prior to termination.
 248  *
 249  ******************************************************************************/
 250
 251 ACPI_STATUS
 252 AcpiEvDeleteGpeHandlers (
 253     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
 254     ACPI_GPE_BLOCK_INFO     *GpeBlock)
 255 {
 256     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 257     ACPI_NATIVE_UINT        i;
 258     ACPI_NATIVE_UINT        j;
 259
 260
 261     ACPI_FUNCTION_TRACE ("EvDeleteGpeHandlers");
 262
 263
 264     /* Examine each GPE Register within the block */
 265
 266     for (i = 0; i < GpeBlock->RegisterCount; i++)
 267     {
 268         /* Now look at the individual GPEs in this byte register */
 269
 270         for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
 271         {
 272             GpeEventInfo = &GpeBlock->EventInfo[(i * ACPI_GPE_REGISTER_WIDTH) + j];
 273
 274             if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) == ACPI_GPE_DISPATCH_HANDLER)
 275             {
 276                 ACPI_MEM_FREE (GpeEventInfo->Dispatch.Handler);
 277                 GpeEventInfo->Dispatch.Handler = NULL;
 278                 GpeEventInfo->Flags &= ~ACPI_GPE_DISPATCH_MASK;
 279             }
 280         }
 281     }
 282
 283     return_ACPI_STATUS (AE_OK);
 284 }
 285
 286
 287 /*******************************************************************************
 288  *
 289  * FUNCTION:    AcpiEvSaveMethodInfo
 290  *
 291  * PARAMETERS:  Callback from WalkNamespace
 292  *
 293  * RETURN:      Status
 294  *
 295  * DESCRIPTION: Called from AcpiWalkNamespace.  Expects each object to be a
 296  *              control method under the _GPE portion of the namespace.
 297  *              Extract the name and GPE type from the object, saving this
 298  *              information for quick lookup during GPE dispatch
 299  *
 300  *              The name of each GPE control method is of the form:
 301  *              "_Lxx" or "_Exx"
 302  *              Where:
 303  *                  L      - means that the GPE is level triggered
 304  *                  E      - means that the GPE is edge triggered
 305  *                  xx     - is the GPE number [in HEX]
 306  *
 307  ******************************************************************************/
 308
 309 static ACPI_STATUS
 310 AcpiEvSaveMethodInfo (
 311     ACPI_HANDLE             ObjHandle,
 312     UINT32                  Level,
 313     void                    *ObjDesc,
 314     void                    **ReturnValue)
 315 {
 316     ACPI_GPE_BLOCK_INFO     *GpeBlock = (void *) ObjDesc;
 317     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 318     UINT32                  GpeNumber;
 319     char                    Name[ACPI_NAME_SIZE + 1];
 320     UINT8                   Type;
 321     ACPI_STATUS             Status;
 322
 323
 324     ACPI_FUNCTION_TRACE ("EvSaveMethodInfo");
 325
 326
 327     /*
 328      * _Lxx and _Exx GPE method support
 329      *
 330      * 1) Extract the name from the object and convert to a string
 331      */
 332     ACPI_MOVE_32_TO_32 (Name,
 333                         &((ACPI_NAMESPACE_NODE *) ObjHandle)->Name.Integer);
 334     Name[ACPI_NAME_SIZE] = 0;
 335
 336     /*
 337      * 2) Edge/Level determination is based on the 2nd character
 338      *    of the method name
 339      *
 340      * NOTE: Default GPE type is RUNTIME.  May be changed later to WAKE
 341      * if a _PRW object is found that points to this GPE.
 342      */
 343     switch (Name[1])
 344     {
 345     case 'L':
 346         Type = ACPI_GPE_LEVEL_TRIGGERED;
 347         break;
 348
 349     case 'E':
 350         Type = ACPI_GPE_EDGE_TRIGGERED;
 351         break;
 352
 353     default:
 354         /* Unknown method type, just ignore it! */
 355
 356         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 357             "Unknown GPE method type: %s (name not of form _Lxx or _Exx)\n",
 358             Name));
 359         return_ACPI_STATUS (AE_OK);
 360     }
 361
 362     /* Convert the last two characters of the name to the GPE Number */
 363
 364     GpeNumber = ACPI_STRTOUL (&Name[2], NULL, 16);
 365     if (GpeNumber == ACPI_UINT32_MAX)
 366     {
 367         /* Conversion failed; invalid method, just ignore it */
 368
 369         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 370             "Could not extract GPE number from name: %s (name is not of form _Lxx or _Exx)\n",
 371             Name));
 372         return_ACPI_STATUS (AE_OK);
 373     }
 374
 375     /* Ensure that we have a valid GPE number for this GPE block */
 376
 377     if ((GpeNumber < GpeBlock->BlockBaseNumber) ||
 378         (GpeNumber >= (GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8))))
 379     {
 380         /*
 381          * Not valid for this GPE block, just ignore it
 382          * However, it may be valid for a different GPE block, since GPE0 and GPE1
 383          * methods both appear under \_GPE.
 384          */
 385         return_ACPI_STATUS (AE_OK);
 386     }
 387
 388     /*
 389      * Now we can add this information to the GpeEventInfo block
 390      * for use during dispatch of this GPE.  Default type is RUNTIME, although
 391      * this may change when the _PRW methods are executed later.
 392      */
 393     GpeEventInfo = &GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber];
 394
 395     GpeEventInfo->Flags = (UINT8) (Type | ACPI_GPE_DISPATCH_METHOD |
 396                                           ACPI_GPE_TYPE_RUNTIME);
 397
 398     GpeEventInfo->Dispatch.MethodNode = (ACPI_NAMESPACE_NODE *) ObjHandle;
 399
 400     /* Update enable mask, but don't enable the HW GPE as of yet */
 401
 402     Status = AcpiEvEnableGpe (GpeEventInfo, FALSE);
 403
 404     ACPI_DEBUG_PRINT ((ACPI_DB_LOAD,
 405         "Registered GPE method %s as GPE number 0x%.2X\n",
 406         Name, GpeNumber));
 407     return_ACPI_STATUS (Status);
 408 }
 409
 410
 411 /*******************************************************************************
 412  *
 413  * FUNCTION:    AcpiEvMatchPrwAndGpe
 414  *
 415  * PARAMETERS:  Callback from WalkNamespace
 416  *
 417  * RETURN:      Status.  NOTE: We ignore errors so that the _PRW walk is
 418  *              not aborted on a single _PRW failure.
 419  *
 420  * DESCRIPTION: Called from AcpiWalkNamespace.  Expects each object to be a
 421  *              Device.  Run the _PRW method.  If present, extract the GPE
 422  *              number and mark the GPE as a WAKE GPE.
 423  *
 424  ******************************************************************************/
 425
 426 static ACPI_STATUS
 427 AcpiEvMatchPrwAndGpe (
 428     ACPI_HANDLE             ObjHandle,
 429     UINT32                  Level,
 430     void                    *Info,
 431     void                    **ReturnValue)
 432 {
 433     ACPI_GPE_WALK_INFO      *GpeInfo = (void *) Info;
 434     ACPI_NAMESPACE_NODE     *GpeDevice;
 435     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 436     ACPI_NAMESPACE_NODE     *TargetGpeDevice;
 437     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 438     ACPI_OPERAND_OBJECT     *PkgDesc;
 439     ACPI_OPERAND_OBJECT     *ObjDesc;
 440     UINT32                  GpeNumber;
 441     ACPI_STATUS             Status;
 442
 443
 444     ACPI_FUNCTION_TRACE ("EvMatchPrwAndGpe");
 445
 446
 447     /* Check for a _PRW method under this device */
 448
 449     Status = AcpiUtEvaluateObject (ObjHandle, METHOD_NAME__PRW,
 450                 ACPI_BTYPE_PACKAGE, &PkgDesc);
 451     if (ACPI_FAILURE (Status))
 452     {
 453         /* Ignore all errors from _PRW, we don't want to abort the subsystem */
 454
 455         return_ACPI_STATUS (AE_OK);
 456     }
 457
 458     /* The returned _PRW package must have at least two elements */
 459
 460     if (PkgDesc->Package.Count < 2)
 461     {
 462         goto Cleanup;
 463     }
 464
 465     /* Extract pointers from the input context */
 466
 467     GpeDevice = GpeInfo->GpeDevice;
 468     GpeBlock = GpeInfo->GpeBlock;
 469
 470     /*
 471      * The _PRW object must return a package, we are only interested
 472      * in the first element
 473      */
 474     ObjDesc = PkgDesc->Package.Elements[0];
 475
 476     if (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_INTEGER)
 477     {
 478         /* Use FADT-defined GPE device (from definition of _PRW) */
 479
 480         TargetGpeDevice = AcpiGbl_FadtGpeDevice;
 481
 482         /* Integer is the GPE number in the FADT described GPE blocks */
 483
 484         GpeNumber = (UINT32) ObjDesc->Integer.Value;
 485     }
 486     else if (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_PACKAGE)
 487     {
 488         /* Package contains a GPE reference and GPE number within a GPE block */
 489
 490         if ((ObjDesc->Package.Count < 2) ||
 491             (ACPI_GET_OBJECT_TYPE (ObjDesc->Package.Elements[0]) != ACPI_TYPE_LOCAL_REFERENCE) ||
 492             (ACPI_GET_OBJECT_TYPE (ObjDesc->Package.Elements[1]) != ACPI_TYPE_INTEGER))
 493         {
 494             goto Cleanup;
 495         }
 496
 497         /* Get GPE block reference and decode */
 498
 499         TargetGpeDevice = ObjDesc->Package.Elements[0]->Reference.Node;
 500         GpeNumber = (UINT32) ObjDesc->Package.Elements[1]->Integer.Value;
 501     }
 502     else
 503     {
 504         /* Unknown type, just ignore it */
 505
 506         goto Cleanup;
 507     }
 508
 509     /*
 510      * Is this GPE within this block?
 511      *
 512      * TRUE iff these conditions are true:
 513      *     1) The GPE devices match.
 514      *     2) The GPE index(number) is within the range of the Gpe Block
 515      *          associated with the GPE device.
 516      */
 517     if ((GpeDevice == TargetGpeDevice) &&
 518         (GpeNumber >= GpeBlock->BlockBaseNumber) &&
 519         (GpeNumber < GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8)))
 520     {
 521         GpeEventInfo = &GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber];
 522
 523         /* Mark GPE for WAKE-ONLY but WAKE_DISABLED */
 524
 525         GpeEventInfo->Flags &= ~(ACPI_GPE_WAKE_ENABLED | ACPI_GPE_RUN_ENABLED);
 526         Status = AcpiEvSetGpeType (GpeEventInfo, ACPI_GPE_TYPE_WAKE);
 527         if (ACPI_FAILURE (Status))
 528         {
 529             goto Cleanup;
 530         }
 531         Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo, ACPI_GPE_DISABLE);
 532     }
 533
 534 Cleanup:
 535     AcpiUtRemoveReference (PkgDesc);
 536     return_ACPI_STATUS (AE_OK);
 537 }
 538
 539
 540 /*******************************************************************************
 541  *
 542  * FUNCTION:    AcpiEvGetGpeXruptBlock
 543  *
 544  * PARAMETERS:  InterruptLevel      - Interrupt for a GPE block
 545  *
 546  * RETURN:      A GPE interrupt block
 547  *
 548  * DESCRIPTION: Get or Create a GPE interrupt block.  There is one interrupt
 549  *              block per unique interrupt level used for GPEs.
 550  *              Should be called only when the GPE lists are semaphore locked
 551  *              and not subject to change.
 552  *
 553  ******************************************************************************/
 554
 555 static ACPI_GPE_XRUPT_INFO *
 556 AcpiEvGetGpeXruptBlock (
 557     UINT32                  InterruptLevel)
 558 {
 559     ACPI_GPE_XRUPT_INFO     *NextGpeXrupt;
 560     ACPI_GPE_XRUPT_INFO     *GpeXrupt;
 561     ACPI_STATUS             Status;
 562
 563
 564     ACPI_FUNCTION_TRACE ("EvGetGpeXruptBlock");
 565
 566
 567     /* No need for spin lock since we are not changing any list elements here */
 568
 569     NextGpeXrupt = AcpiGbl_GpeXruptListHead;
 570     while (NextGpeXrupt)
 571     {
 572         if (NextGpeXrupt->InterruptLevel == InterruptLevel)
 573         {
 574             return_PTR (NextGpeXrupt);
 575         }
 576
 577         NextGpeXrupt = NextGpeXrupt->Next;
 578     }
 579
 580     /* Not found, must allocate a new xrupt descriptor */
 581
 582     GpeXrupt = ACPI_MEM_CALLOCATE (sizeof (ACPI_GPE_XRUPT_INFO));
 583     if (!GpeXrupt)
 584     {
 585         return_PTR (NULL);
 586     }
 587
 588     GpeXrupt->InterruptLevel = InterruptLevel;
 589
 590     /* Install new interrupt descriptor with spin lock */
 591
 592     AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 593     if (AcpiGbl_GpeXruptListHead)
 594     {
 595         NextGpeXrupt = AcpiGbl_GpeXruptListHead;
 596         while (NextGpeXrupt->Next)
 597         {
 598             NextGpeXrupt = NextGpeXrupt->Next;
 599         }
 600
 601         NextGpeXrupt->Next = GpeXrupt;
 602         GpeXrupt->Previous = NextGpeXrupt;
 603     }
 604     else
 605     {
 606         AcpiGbl_GpeXruptListHead = GpeXrupt;
 607     }
 608     AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 609
 610     /* Install new interrupt handler if not SCI_INT */
 611
 612     if (InterruptLevel != AcpiGbl_FADT->SciInt)
 613     {
 614         Status = AcpiOsInstallInterruptHandler (InterruptLevel,
 615                     AcpiEvGpeXruptHandler, GpeXrupt);
 616         if (ACPI_FAILURE (Status))
 617         {
 618             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 619                 "Could not install GPE interrupt handler at level 0x%X\n",
 620                 InterruptLevel));
 621             return_PTR (NULL);
 622         }
 623     }
 624
 625     return_PTR (GpeXrupt);
 626 }
 627
 628
 629 /*******************************************************************************
 630  *
 631  * FUNCTION:    AcpiEvDeleteGpeXrupt
 632  *
 633  * PARAMETERS:  GpeXrupt        - A GPE interrupt info block
 634  *
 635  * RETURN:      Status
 636  *
 637  * DESCRIPTION: Remove and free a GpeXrupt block.  Remove an associated
 638  *              interrupt handler if not the SCI interrupt.
 639  *
 640  ******************************************************************************/
 641
 642 static ACPI_STATUS
 643 AcpiEvDeleteGpeXrupt (
 644     ACPI_GPE_XRUPT_INFO     *GpeXrupt)
 645 {
 646     ACPI_STATUS             Status;
 647
 648
 649     ACPI_FUNCTION_TRACE ("EvDeleteGpeXrupt");
 650
 651
 652     /* We never want to remove the SCI interrupt handler */
 653
 654     if (GpeXrupt->InterruptLevel == AcpiGbl_FADT->SciInt)
 655     {
 656         GpeXrupt->GpeBlockListHead = NULL;
 657         return_ACPI_STATUS (AE_OK);
 658     }
 659
 660     /* Disable this interrupt */
 661
 662     Status = AcpiOsRemoveInterruptHandler (GpeXrupt->InterruptLevel,
 663                                     AcpiEvGpeXruptHandler);
 664     if (ACPI_FAILURE (Status))
 665     {
 666         return_ACPI_STATUS (Status);
 667     }
 668
 669     /* Unlink the interrupt block with lock */
 670
 671     AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 672     if (GpeXrupt->Previous)
 673     {
 674         GpeXrupt->Previous->Next = GpeXrupt->Next;
 675     }
 676
 677     if (GpeXrupt->Next)
 678     {
 679         GpeXrupt->Next->Previous = GpeXrupt->Previous;
 680     }
 681     AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 682
 683     /* Free the block */
 684
 685     ACPI_MEM_FREE (GpeXrupt);
 686     return_ACPI_STATUS (AE_OK);
 687 }
 688
 689
 690 /*******************************************************************************
 691  *
 692  * FUNCTION:    AcpiEvInstallGpeBlock
 693  *
 694  * PARAMETERS:  GpeBlock        - New GPE block
 695  *              InterruptLevel  - Level to be associated with this GPE block
 696  *
 697  * RETURN:      Status
 698  *
 699  * DESCRIPTION: Install new GPE block with mutex support
 700  *
 701  ******************************************************************************/
 702
 703 static ACPI_STATUS
 704 AcpiEvInstallGpeBlock (
 705     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 706     UINT32                  InterruptLevel)
 707 {
 708     ACPI_GPE_BLOCK_INFO     *NextGpeBlock;
 709     ACPI_GPE_XRUPT_INFO     *GpeXruptBlock;
 710     ACPI_STATUS             Status;
 711
 712
 713     ACPI_FUNCTION_TRACE ("EvInstallGpeBlock");
 714
 715
 716     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 717     if (ACPI_FAILURE (Status))
 718     {
 719         return_ACPI_STATUS (Status);
 720     }
 721
 722     GpeXruptBlock = AcpiEvGetGpeXruptBlock (InterruptLevel);
 723     if (!GpeXruptBlock)
 724     {
 725         Status = AE_NO_MEMORY;
 726         goto UnlockAndExit;
 727     }
 728
 729     /* Install the new block at the end of the list for this interrupt with lock */
 730
 731     AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 732     if (GpeXruptBlock->GpeBlockListHead)
 733     {
 734         NextGpeBlock = GpeXruptBlock->GpeBlockListHead;
 735         while (NextGpeBlock->Next)
 736         {
 737             NextGpeBlock = NextGpeBlock->Next;
 738         }
 739
 740         NextGpeBlock->Next = GpeBlock;
 741         GpeBlock->Previous = NextGpeBlock;
 742     }
 743     else
 744     {
 745         GpeXruptBlock->GpeBlockListHead = GpeBlock;
 746     }
 747
 748     GpeBlock->XruptBlock = GpeXruptBlock;
 749     AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 750
 751 UnlockAndExit:
 752     Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 753     return_ACPI_STATUS (Status);
 754 }
 755
 756
 757 /*******************************************************************************
 758  *
 759  * FUNCTION:    AcpiEvDeleteGpeBlock
 760  *
 761  * PARAMETERS:  GpeBlock        - Existing GPE block
 762  *
 763  * RETURN:      Status
 764  *
 765  * DESCRIPTION: Remove a GPE block
 766  *
 767  ******************************************************************************/
 768
 769 ACPI_STATUS
 770 AcpiEvDeleteGpeBlock (
 771     ACPI_GPE_BLOCK_INFO     *GpeBlock)
 772 {
 773     ACPI_STATUS             Status;
 774
 775
 776     ACPI_FUNCTION_TRACE ("EvInstallGpeBlock");
 777
 778
 779     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 780     if (ACPI_FAILURE (Status))
 781     {
 782         return_ACPI_STATUS (Status);
 783     }
 784
 785     /* Disable all GPEs in this block */
 786
 787     Status = AcpiHwDisableGpeBlock (GpeBlock->XruptBlock, GpeBlock);
 788
 789     if (!GpeBlock->Previous && !GpeBlock->Next)
 790     {
 791         /* This is the last GpeBlock on this interrupt */
 792
 793         Status = AcpiEvDeleteGpeXrupt (GpeBlock->XruptBlock);
 794         if (ACPI_FAILURE (Status))
 795         {
 796             goto UnlockAndExit;
 797         }
 798     }
 799     else
 800     {
 801         /* Remove the block on this interrupt with lock */
 802
 803         AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 804         if (GpeBlock->Previous)
 805         {
 806             GpeBlock->Previous->Next = GpeBlock->Next;
 807         }
 808         else
 809         {
 810             GpeBlock->XruptBlock->GpeBlockListHead = GpeBlock->Next;
 811         }
 812
 813         if (GpeBlock->Next)
 814         {
 815             GpeBlock->Next->Previous = GpeBlock->Previous;
 816         }
 817         AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 818     }
 819
 820     /* Free the GpeBlock */
 821
 822     ACPI_MEM_FREE (GpeBlock->RegisterInfo);
 823     ACPI_MEM_FREE (GpeBlock->EventInfo);
 824     ACPI_MEM_FREE (GpeBlock);
 825
 826 UnlockAndExit:
 827     Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 828     return_ACPI_STATUS (Status);
 829 }
 830
 831
 832 /*******************************************************************************
 833  *
 834  * FUNCTION:    AcpiEvCreateGpeInfoBlocks
 835  *
 836  * PARAMETERS:  GpeBlock    - New GPE block
 837  *
 838  * RETURN:      Status
 839  *
 840  * DESCRIPTION: Create the RegisterInfo and EventInfo blocks for this GPE block
 841  *
 842  ******************************************************************************/
 843
 844 static ACPI_STATUS
 845 AcpiEvCreateGpeInfoBlocks (
 846     ACPI_GPE_BLOCK_INFO     *GpeBlock)
 847 {
 848     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo = NULL;
 849     ACPI_GPE_EVENT_INFO     *GpeEventInfo = NULL;
 850     ACPI_GPE_EVENT_INFO     *ThisEvent;
 851     ACPI_GPE_REGISTER_INFO  *ThisRegister;
 852     ACPI_NATIVE_UINT        i;
 853     ACPI_NATIVE_UINT        j;
 854     ACPI_STATUS             Status;
 855
 856
 857     ACPI_FUNCTION_TRACE ("EvCreateGpeInfoBlocks");
 858
 859
 860     /* Allocate the GPE register information block */
 861
 862     GpeRegisterInfo = ACPI_MEM_CALLOCATE (
 863                                 (ACPI_SIZE) GpeBlock->RegisterCount *
 864                                 sizeof (ACPI_GPE_REGISTER_INFO));
 865     if (!GpeRegisterInfo)
 866     {
 867         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 868             "Could not allocate the GpeRegisterInfo table\n"));
 869         return_ACPI_STATUS (AE_NO_MEMORY);
 870     }
 871
 872     /*
 873      * Allocate the GPE EventInfo block.  There are eight distinct GPEs
 874      * per register.  Initialization to zeros is sufficient.
 875      */
 876     GpeEventInfo = ACPI_MEM_CALLOCATE (
 877                         ((ACPI_SIZE) GpeBlock->RegisterCount * ACPI_GPE_REGISTER_WIDTH) *
 878                         sizeof (ACPI_GPE_EVENT_INFO));
 879     if (!GpeEventInfo)
 880     {
 881         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not allocate the GpeEventInfo table\n"));
 882         Status = AE_NO_MEMORY;
 883         goto ErrorExit;
 884     }
 885
 886     /* Save the new Info arrays in the GPE block */
 887
 888     GpeBlock->RegisterInfo = GpeRegisterInfo;
 889     GpeBlock->EventInfo    = GpeEventInfo;
 890
 891     /*
 892      * Initialize the GPE Register and Event structures.  A goal of these
 893      * tables is to hide the fact that there are two separate GPE register sets
 894      * in a given gpe hardware block, the status registers occupy the first half,
 895      * and the enable registers occupy the second half.
 896      */
 897     ThisRegister = GpeRegisterInfo;
 898     ThisEvent    = GpeEventInfo;
 899
 900     for (i = 0; i < GpeBlock->RegisterCount; i++)
 901     {
 902         /* Init the RegisterInfo for this GPE register (8 GPEs) */
 903
 904         ThisRegister->BaseGpeNumber = (UINT8) (GpeBlock->BlockBaseNumber +
 905                                                  (i * ACPI_GPE_REGISTER_WIDTH));
 906
 907         ACPI_STORE_ADDRESS (ThisRegister->StatusAddress.Address,
 908                                 (ACPI_GET_ADDRESS (GpeBlock->BlockAddress.Address)
 909                                 + i));
 910
 911         ACPI_STORE_ADDRESS (ThisRegister->EnableAddress.Address,
 912                                 (ACPI_GET_ADDRESS (GpeBlock->BlockAddress.Address)
 913                                 + i
 914                                 + GpeBlock->RegisterCount));
 915
 916         ThisRegister->StatusAddress.AddressSpaceId    = GpeBlock->BlockAddress.AddressSpaceId;
 917         ThisRegister->EnableAddress.AddressSpaceId    = GpeBlock->BlockAddress.AddressSpaceId;
 918         ThisRegister->StatusAddress.RegisterBitWidth  = ACPI_GPE_REGISTER_WIDTH;
 919         ThisRegister->EnableAddress.RegisterBitWidth  = ACPI_GPE_REGISTER_WIDTH;
 920         ThisRegister->StatusAddress.RegisterBitOffset = ACPI_GPE_REGISTER_WIDTH;
 921         ThisRegister->EnableAddress.RegisterBitOffset = ACPI_GPE_REGISTER_WIDTH;
 922
 923         /* Init the EventInfo for each GPE within this register */
 924
 925         for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
 926         {
 927             ThisEvent->RegisterBit  = AcpiGbl_DecodeTo8bit[j];
 928             ThisEvent->RegisterInfo = ThisRegister;
 929             ThisEvent++;
 930         }
 931
 932         /*
 933          * Clear the status/enable registers.  Note that status registers
 934          * are cleared by writing a '1', while enable registers are cleared
 935          * by writing a '0'.
 936          */
 937         Status = AcpiHwLowLevelWrite (ACPI_GPE_REGISTER_WIDTH, 0x00,
 938                     &ThisRegister->EnableAddress);
 939         if (ACPI_FAILURE (Status))
 940         {
 941             goto ErrorExit;
 942         }
 943
 944         Status = AcpiHwLowLevelWrite (ACPI_GPE_REGISTER_WIDTH, 0xFF,
 945                     &ThisRegister->StatusAddress);
 946         if (ACPI_FAILURE (Status))
 947         {
 948             goto ErrorExit;
 949         }
 950
 951         ThisRegister++;
 952     }
 953
 954     return_ACPI_STATUS (AE_OK);
 955
 956
 957 ErrorExit:
 958     if (GpeRegisterInfo)
 959     {
 960         ACPI_MEM_FREE (GpeRegisterInfo);
 961     }
 962     if (GpeEventInfo)
 963     {
 964         ACPI_MEM_FREE (GpeEventInfo);
 965     }
 966
 967     return_ACPI_STATUS (Status);
 968 }
 969
 970
 971 /*******************************************************************************
 972  *
 973  * FUNCTION:    AcpiEvCreateGpeBlock
 974  *
 975  * PARAMETERS:  GpeDevice           - Handle to the parent GPE block
 976  *              GpeBlockAddress     - Address and SpaceID
 977  *              RegisterCount       - Number of GPE register pairs in the block
 978  *              GpeBlockBaseNumber  - Starting GPE number for the block
 979  *              InterruptLevel      - H/W interrupt for the block
 980  *              ReturnGpeBlock      - Where the new block descriptor is returned
 981  *
 982  * RETURN:      Status
 983  *
 984  * DESCRIPTION: Create and Install a block of GPE registers
 985  *
 986  ******************************************************************************/
 987
 988 ACPI_STATUS
 989 AcpiEvCreateGpeBlock (
 990     ACPI_NAMESPACE_NODE     *GpeDevice,
 991     ACPI_GENERIC_ADDRESS    *GpeBlockAddress,
 992     UINT32                  RegisterCount,
 993     UINT8                   GpeBlockBaseNumber,
 994     UINT32                  InterruptLevel,
 995     ACPI_GPE_BLOCK_INFO     **ReturnGpeBlock)
 996 {
 997     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 998     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 999     ACPI_NATIVE_UINT        i;
1000     ACPI_NATIVE_UINT        j;
1001     UINT32                  WakeGpeCount;
1002     UINT32                  GpeEnabledCount;
1003     ACPI_STATUS             Status;
1004     ACPI_GPE_WALK_INFO      GpeInfo;
1005
1006
1007     ACPI_FUNCTION_TRACE ("EvCreateGpeBlock");
1008
1009
1010     if (!RegisterCount)
1011     {
1012         return_ACPI_STATUS (AE_OK);
1013     }
1014
1015     /* Allocate a new GPE block */
1016
1017     GpeBlock = ACPI_MEM_CALLOCATE (sizeof (ACPI_GPE_BLOCK_INFO));
1018     if (!GpeBlock)
1019     {
1020         return_ACPI_STATUS (AE_NO_MEMORY);
1021     }
1022
1023     /* Initialize the new GPE block */
1024
1025     GpeBlock->RegisterCount   = RegisterCount;
1026     GpeBlock->BlockBaseNumber = GpeBlockBaseNumber;
1027     GpeBlock->Node            = GpeDevice;
1028
1029     ACPI_MEMCPY (&GpeBlock->BlockAddress, GpeBlockAddress, sizeof (ACPI_GENERIC_ADDRESS));
1030
1031     /* Create the RegisterInfo and EventInfo sub-structures */
1032
1033     Status = AcpiEvCreateGpeInfoBlocks (GpeBlock);
1034     if (ACPI_FAILURE (Status))
1035     {
1036         ACPI_MEM_FREE (GpeBlock);
1037         return_ACPI_STATUS (Status);
1038     }
1039
1040     /* Install the new block in the global list(s) */
1041
1042     Status = AcpiEvInstallGpeBlock (GpeBlock, InterruptLevel);
1043     if (ACPI_FAILURE (Status))
1044     {
1045         ACPI_MEM_FREE (GpeBlock);
1046         return_ACPI_STATUS (Status);
1047     }
1048
1049     /* Find all GPE methods (_Lxx, _Exx) for this block */
1050
1051     Status = AcpiNsWalkNamespace (ACPI_TYPE_METHOD, GpeDevice,
1052                     ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK, AcpiEvSaveMethodInfo,
1053                     GpeBlock, NULL);
1054
1055     /*
1056      * Runtime option: Should Wake GPEs be enabled at runtime?  The default
1057      * is No,they should only be enabled just as the machine goes to sleep.
1058      */
1059     if (AcpiGbl_LeaveWakeGpesDisabled)
1060     {
1061         /*
1062          * Differentiate RUNTIME vs WAKE GPEs, via the _PRW control methods.
1063          * (Each GPE that has one or more _PRWs that reference it is by
1064          * definition a WAKE GPE and will not be enabled while the machine
1065          * is running.)
1066          */
1067         GpeInfo.GpeBlock = GpeBlock;
1068         GpeInfo.GpeDevice = GpeDevice;
1069
1070         Status = AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1071                         ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK, AcpiEvMatchPrwAndGpe,
1072                         &GpeInfo, NULL);
1073     }
1074
1075     /*
1076      * Enable all GPEs in this block that are 1) "runtime" or "run/wake" GPEs,
1077      * and 2) have a corresponding _Lxx or _Exx method.  All other GPEs must
1078      * be enabled via the AcpiEnableGpe() external interface.
1079      */
1080     WakeGpeCount = 0;
1081     GpeEnabledCount = 0;
1082
1083     for (i = 0; i < GpeBlock->RegisterCount; i++)
1084     {
1085         for (j = 0; j < 8; j++)
1086         {
1087             /* Get the info block for this particular GPE */
1088
1089             GpeEventInfo = &GpeBlock->EventInfo[(i * ACPI_GPE_REGISTER_WIDTH) + j];
1090
1091             if (((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) == ACPI_GPE_DISPATCH_METHOD) &&
1092                  (GpeEventInfo->Flags & ACPI_GPE_TYPE_RUNTIME))
1093             {
1094                 GpeEnabledCount++;
1095             }
1096
1097             if (GpeEventInfo->Flags & ACPI_GPE_TYPE_WAKE)
1098             {
1099                 WakeGpeCount++;
1100             }
1101         }
1102     }
1103
1104     /* Dump info about this GPE block */
1105
1106     ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
1107         "GPE %02X to %02X [%4.4s] %u regs on int 0x%X\n",
1108         (UINT32) GpeBlock->BlockBaseNumber,
1109         (UINT32) (GpeBlock->BlockBaseNumber +
1110                 ((GpeBlock->RegisterCount * ACPI_GPE_REGISTER_WIDTH) -1)),
1111         GpeDevice->Name.Ascii,
1112         GpeBlock->RegisterCount,
1113         InterruptLevel));
1114
1115     /* Enable all valid GPEs found above */
1116
1117     Status = AcpiHwEnableRuntimeGpeBlock (NULL, GpeBlock);
1118
1119     ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
1120             "Found %u Wake, Enabled %u Runtime GPEs in this block\n",
1121             WakeGpeCount, GpeEnabledCount));
1122
1123     /* Return the new block */
1124
1125     if (ReturnGpeBlock)
1126     {
1127         (*ReturnGpeBlock) = GpeBlock;
1128     }
1129
1130     return_ACPI_STATUS (AE_OK);
1131 }
1132
1133
1134 /*******************************************************************************
1135  *
1136  * FUNCTION:    AcpiEvGpeInitialize
1137  *
1138  * PARAMETERS:  None
1139  *
1140  * RETURN:      Status
1141  *
1142  * DESCRIPTION: Initialize the GPE data structures
1143  *
1144  ******************************************************************************/
1145
1146 ACPI_STATUS
1147 AcpiEvGpeInitialize (
1148     void)
1149 {
1150     UINT32                  RegisterCount0 = 0;
1151     UINT32                  RegisterCount1 = 0;
1152     UINT32                  GpeNumberMax = 0;
1153     ACPI_STATUS             Status;
1154
1155
1156     ACPI_FUNCTION_TRACE ("EvGpeInitialize");
1157
1158
1159     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
1160     if (ACPI_FAILURE (Status))
1161     {
1162         return_ACPI_STATUS (Status);
1163     }
1164
1165     /*
1166      * Initialize the GPE Block(s) defined in the FADT
1167      *
1168      * Why the GPE register block lengths are divided by 2:  From the ACPI Spec,
1169      * section "General-Purpose Event Registers", we have:
1170      *
1171      * "Each register block contains two registers of equal length
1172      *  GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the
1173      *  GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN
1174      *  The length of the GPE1_STS and GPE1_EN registers is equal to
1175      *  half the GPE1_LEN. If a generic register block is not supported
1176      *  then its respective block pointer and block length values in the
1177      *  FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need
1178      *  to be the same size."
1179      */
1180
1181     /*
1182      * Determine the maximum GPE number for this machine.
1183      *
1184      * Note: both GPE0 and GPE1 are optional, and either can exist without
1185      * the other.
1186      *
1187      * If EITHER the register length OR the block address are zero, then that
1188      * particular block is not supported.
1189      */
1190     if (AcpiGbl_FADT->Gpe0BlkLen &&
1191         ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe0Blk.Address))
1192     {
1193         /* GPE block 0 exists (has both length and address > 0) */
1194
1195         RegisterCount0 = (UINT16) (AcpiGbl_FADT->Gpe0BlkLen / 2);
1196
1197         GpeNumberMax = (RegisterCount0 * ACPI_GPE_REGISTER_WIDTH) - 1;
1198
1199         /* Install GPE Block 0 */
1200
1201         Status = AcpiEvCreateGpeBlock (AcpiGbl_FadtGpeDevice, &AcpiGbl_FADT->XGpe0Blk,
1202                     RegisterCount0, 0, AcpiGbl_FADT->SciInt, &AcpiGbl_GpeFadtBlocks[0]);
1203
1204         if (ACPI_FAILURE (Status))
1205         {
1206             ACPI_REPORT_ERROR ((
1207                 "Could not create GPE Block 0, %s\n",
1208                 AcpiFormatException (Status)));
1209         }
1210     }
1211
1212     if (AcpiGbl_FADT->Gpe1BlkLen &&
1213         ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe1Blk.Address))
1214     {
1215         /* GPE block 1 exists (has both length and address > 0) */
1216
1217         RegisterCount1 = (UINT16) (AcpiGbl_FADT->Gpe1BlkLen / 2);
1218
1219         /* Check for GPE0/GPE1 overlap (if both banks exist) */
1220
1221         if ((RegisterCount0) &&
1222             (GpeNumberMax >= AcpiGbl_FADT->Gpe1Base))
1223         {
1224             ACPI_REPORT_ERROR ((
1225                 "GPE0 block (GPE 0 to %d) overlaps the GPE1 block (GPE %d to %d) - Ignoring GPE1\n",
1226                 GpeNumberMax, AcpiGbl_FADT->Gpe1Base,
1227                 AcpiGbl_FADT->Gpe1Base +
1228                 ((RegisterCount1 * ACPI_GPE_REGISTER_WIDTH) - 1)));
1229
1230             /* Ignore GPE1 block by setting the register count to zero */
1231
1232             RegisterCount1 = 0;
1233         }
1234         else
1235         {
1236             /* Install GPE Block 1 */
1237
1238             Status = AcpiEvCreateGpeBlock (AcpiGbl_FadtGpeDevice, &AcpiGbl_FADT->XGpe1Blk,
1239                         RegisterCount1, AcpiGbl_FADT->Gpe1Base,
1240                         AcpiGbl_FADT->SciInt, &AcpiGbl_GpeFadtBlocks[1]);
1241
1242             if (ACPI_FAILURE (Status))
1243             {
1244                 ACPI_REPORT_ERROR ((
1245                     "Could not create GPE Block 1, %s\n",
1246                     AcpiFormatException (Status)));
1247             }
1248
1249             /*
1250              * GPE0 and GPE1 do not have to be contiguous in the GPE number
1251              * space. However, GPE0 always starts at GPE number zero.
1252              */
1253             GpeNumberMax = AcpiGbl_FADT->Gpe1Base +
1254                                 ((RegisterCount1 * ACPI_GPE_REGISTER_WIDTH) - 1);
1255         }
1256     }
1257
1258     /* Exit if there are no GPE registers */
1259
1260     if ((RegisterCount0 + RegisterCount1) == 0)
1261     {
1262         /* GPEs are not required by ACPI, this is OK */
1263
1264         ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
1265                 "There are no GPE blocks defined in the FADT\n"));
1266         Status = AE_OK;
1267         goto Cleanup;
1268     }
1269
1270     /* Check for Max GPE number out-of-range */
1271
1272     if (GpeNumberMax > ACPI_GPE_MAX)
1273     {
1274         ACPI_REPORT_ERROR (("Maximum GPE number from FADT is too large: 0x%X\n",
1275             GpeNumberMax));
1276         Status = AE_BAD_VALUE;
1277         goto Cleanup;
1278     }
1279
1280 Cleanup:
1281     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
1282     return_ACPI_STATUS (AE_OK);
1283 }
1284
1285