sys/contrib/dev/acpica-unix-20031203/events/evxfevnt.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
   4  *              $Revision: 73 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2003, 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 prton 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
 118 #define __EVXFEVNT_C__
 119
 120 #include "acpi.h"
 121 #include "acevents.h"
 122 #include "acnamesp.h"
 123
 124 #define _COMPONENT          ACPI_EVENTS
 125         ACPI_MODULE_NAME    ("evxfevnt")
 126
 127
 128 /*******************************************************************************
 129  *
 130  * FUNCTION:    AcpiEnable
 131  *
 132  * PARAMETERS:  None
 133  *
 134  * RETURN:      Status
 135  *
 136  * DESCRIPTION: Transfers the system into ACPI mode.
 137  *
 138  ******************************************************************************/
 139
 140 ACPI_STATUS
 141 AcpiEnable (void)
 142 {
 143     ACPI_STATUS             Status = AE_OK;
 144
 145
 146     ACPI_FUNCTION_TRACE ("AcpiEnable");
 147
 148
 149     /* Make sure we have the FADT*/
 150
 151     if (!AcpiGbl_FADT)
 152     {
 153         ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "No FADT information present!\n"));
 154         return_ACPI_STATUS (AE_NO_ACPI_TABLES);
 155     }
 156
 157     if (AcpiHwGetMode() == ACPI_SYS_MODE_ACPI)
 158     {
 159         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "System is already in ACPI mode\n"));
 160     }
 161     else
 162     {
 163         /* Transition to ACPI mode */
 164
 165         Status = AcpiHwSetMode (ACPI_SYS_MODE_ACPI);
 166         if (ACPI_FAILURE (Status))
 167         {
 168             ACPI_REPORT_ERROR (("Could not transition to ACPI mode.\n"));
 169             return_ACPI_STATUS (Status);
 170         }
 171
 172         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "Transition to ACPI mode successful\n"));
 173     }
 174
 175     return_ACPI_STATUS (Status);
 176 }
 177
 178
 179 /*******************************************************************************
 180  *
 181  * FUNCTION:    AcpiDisable
 182  *
 183  * PARAMETERS:  None
 184  *
 185  * RETURN:      Status
 186  *
 187  * DESCRIPTION: Transfers the system into LEGACY mode.
 188  *
 189  ******************************************************************************/
 190
 191 ACPI_STATUS
 192 AcpiDisable (void)
 193 {
 194     ACPI_STATUS             Status = AE_OK;
 195
 196
 197     ACPI_FUNCTION_TRACE ("AcpiDisable");
 198
 199
 200     if (!AcpiGbl_FADT)
 201     {
 202         ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "No FADT information present!\n"));
 203         return_ACPI_STATUS (AE_NO_ACPI_TABLES);
 204     }
 205
 206     if (AcpiHwGetMode() == ACPI_SYS_MODE_LEGACY)
 207     {
 208         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "System is already in legacy (non-ACPI) mode\n"));
 209     }
 210     else
 211     {
 212         /* Transition to LEGACY mode */
 213
 214         Status = AcpiHwSetMode (ACPI_SYS_MODE_LEGACY);
 215
 216         if (ACPI_FAILURE (Status))
 217         {
 218             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not exit ACPI mode to legacy mode"));
 219             return_ACPI_STATUS (Status);
 220         }
 221
 222         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "ACPI mode disabled\n"));
 223     }
 224
 225     return_ACPI_STATUS (Status);
 226 }
 227
 228
 229 /*******************************************************************************
 230  *
 231  * FUNCTION:    AcpiEnableEvent
 232  *
 233  * PARAMETERS:  Event           - The fixed eventto be enabled
 234  *              Flags           - Reserved
 235  *
 236  * RETURN:      Status
 237  *
 238  * DESCRIPTION: Enable an ACPI event (fixed)
 239  *
 240  ******************************************************************************/
 241
 242 ACPI_STATUS
 243 AcpiEnableEvent (
 244     UINT32                  Event,
 245     UINT32                  Flags)
 246 {
 247     ACPI_STATUS             Status = AE_OK;
 248     UINT32                  Value;
 249
 250
 251     ACPI_FUNCTION_TRACE ("AcpiEnableEvent");
 252
 253
 254     /* Decode the Fixed Event */
 255
 256     if (Event > ACPI_EVENT_MAX)
 257     {
 258         return_ACPI_STATUS (AE_BAD_PARAMETER);
 259     }
 260
 261     /*
 262      * Enable the requested fixed event (by writing a one to the
 263      * enable register bit)
 264      */
 265     Status = AcpiSetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
 266                 1, ACPI_MTX_LOCK);
 267     if (ACPI_FAILURE (Status))
 268     {
 269         return_ACPI_STATUS (Status);
 270     }
 271
 272     /* Make sure that the hardware responded */
 273
 274     Status = AcpiGetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
 275                     &Value, ACPI_MTX_LOCK);
 276     if (ACPI_FAILURE (Status))
 277     {
 278         return_ACPI_STATUS (Status);
 279     }
 280
 281     if (Value != 1)
 282     {
 283         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 284             "Could not enable %s event\n", AcpiUtGetEventName (Event)));
 285         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
 286     }
 287
 288     return_ACPI_STATUS (Status);
 289 }
 290
 291
 292 /*******************************************************************************
 293  *
 294  * FUNCTION:    AcpiEnableGpe
 295  *
 296  * PARAMETERS:  GpeDevice       - Parent GPE Device
 297  *              GpeNumber       - GPE level within the GPE block
 298  *              Flags           - Just enable, or also wake enable?
 299  *                                Called from ISR or not
 300  *
 301  * RETURN:      Status
 302  *
 303  * DESCRIPTION: Enable an ACPI event (general purpose)
 304  *
 305  ******************************************************************************/
 306
 307 ACPI_STATUS
 308 AcpiEnableGpe (
 309     ACPI_HANDLE             GpeDevice,
 310     UINT32                  GpeNumber,
 311     UINT32                  Flags)
 312 {
 313     ACPI_STATUS             Status = AE_OK;
 314     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 315
 316
 317     ACPI_FUNCTION_TRACE ("AcpiEnableGpe");
 318
 319
 320     /* Use semaphore lock if not executing at interrupt level */
 321
 322     if (Flags & ACPI_NOT_ISR)
 323     {
 324         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 325         if (ACPI_FAILURE (Status))
 326         {
 327             return_ACPI_STATUS (Status);
 328         }
 329     }
 330
 331     /* Ensure that we have a valid GPE number */
 332
 333     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 334     if (!GpeEventInfo)
 335     {
 336         Status = AE_BAD_PARAMETER;
 337         goto UnlockAndExit;
 338     }
 339
 340     /* Enable the requested GPE number */
 341
 342     Status = AcpiHwEnableGpe (GpeEventInfo);
 343     if (ACPI_FAILURE (Status))
 344     {
 345         goto UnlockAndExit;
 346     }
 347
 348     if (Flags & ACPI_EVENT_WAKE_ENABLE)
 349     {
 350         AcpiHwEnableGpeForWakeup (GpeEventInfo);
 351     }
 352
 353 UnlockAndExit:
 354     if (Flags & ACPI_NOT_ISR)
 355     {
 356         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 357     }
 358     return_ACPI_STATUS (Status);
 359 }
 360
 361
 362 /*******************************************************************************
 363  *
 364  * FUNCTION:    AcpiDisableEvent
 365  *
 366  * PARAMETERS:  Event           - The fixed eventto be enabled
 367  *              Flags           - Reserved
 368  *
 369  * RETURN:      Status
 370  *
 371  * DESCRIPTION: Disable an ACPI event (fixed)
 372  *
 373  ******************************************************************************/
 374
 375 ACPI_STATUS
 376 AcpiDisableEvent (
 377     UINT32                  Event,
 378     UINT32                  Flags)
 379 {
 380     ACPI_STATUS             Status = AE_OK;
 381     UINT32                  Value;
 382
 383
 384     ACPI_FUNCTION_TRACE ("AcpiDisableEvent");
 385
 386
 387     /* Decode the Fixed Event */
 388
 389     if (Event > ACPI_EVENT_MAX)
 390     {
 391         return_ACPI_STATUS (AE_BAD_PARAMETER);
 392     }
 393
 394     /*
 395      * Disable the requested fixed event (by writing a zero to the
 396      * enable register bit)
 397      */
 398     Status = AcpiSetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
 399                 0, ACPI_MTX_LOCK);
 400     if (ACPI_FAILURE (Status))
 401     {
 402         return_ACPI_STATUS (Status);
 403     }
 404
 405     Status = AcpiGetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
 406                 &Value, ACPI_MTX_LOCK);
 407     if (ACPI_FAILURE (Status))
 408     {
 409         return_ACPI_STATUS (Status);
 410     }
 411
 412     if (Value != 0)
 413     {
 414         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 415             "Could not disable %s events\n", AcpiUtGetEventName (Event)));
 416         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
 417     }
 418
 419     return_ACPI_STATUS (Status);
 420 }
 421
 422
 423 /*******************************************************************************
 424  *
 425  * FUNCTION:    AcpiDisableGpe
 426  *
 427  * PARAMETERS:  GpeDevice       - Parent GPE Device
 428  *              GpeNumber       - GPE level within the GPE block
 429  *              Flags           - Just enable, or also wake enable?
 430  *                                Called from ISR or not
 431  *
 432  * RETURN:      Status
 433  *
 434  * DESCRIPTION: Disable an ACPI event (general purpose)
 435  *
 436  ******************************************************************************/
 437
 438 ACPI_STATUS
 439 AcpiDisableGpe (
 440     ACPI_HANDLE             GpeDevice,
 441     UINT32                  GpeNumber,
 442     UINT32                  Flags)
 443 {
 444     ACPI_STATUS             Status = AE_OK;
 445     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 446
 447
 448     ACPI_FUNCTION_TRACE ("AcpiDisableGpe");
 449
 450
 451     /* Use semaphore lock if not executing at interrupt level */
 452
 453     if (Flags & ACPI_NOT_ISR)
 454     {
 455         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 456         if (ACPI_FAILURE (Status))
 457         {
 458             return_ACPI_STATUS (Status);
 459         }
 460     }
 461
 462     /* Ensure that we have a valid GPE number */
 463
 464     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 465     if (!GpeEventInfo)
 466     {
 467         Status = AE_BAD_PARAMETER;
 468         goto UnlockAndExit;
 469     }
 470
 471     /*
 472      * Only disable the requested GPE number for wake if specified.
 473      * Otherwise, turn it totally off
 474      */
 475     if (Flags & ACPI_EVENT_WAKE_DISABLE)
 476     {
 477         AcpiHwDisableGpeForWakeup (GpeEventInfo);
 478     }
 479     else
 480     {
 481         Status = AcpiHwDisableGpe (GpeEventInfo);
 482     }
 483
 484 UnlockAndExit:
 485     if (Flags & ACPI_NOT_ISR)
 486     {
 487         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 488     }
 489     return_ACPI_STATUS (Status);
 490 }
 491
 492
 493 /*******************************************************************************
 494  *
 495  * FUNCTION:    AcpiClearEvent
 496  *
 497  * PARAMETERS:  Event           - The fixed event to be cleared
 498  *
 499  * RETURN:      Status
 500  *
 501  * DESCRIPTION: Clear an ACPI event (fixed)
 502  *
 503  ******************************************************************************/
 504
 505 ACPI_STATUS
 506 AcpiClearEvent (
 507     UINT32                  Event)
 508 {
 509     ACPI_STATUS             Status = AE_OK;
 510
 511
 512     ACPI_FUNCTION_TRACE ("AcpiClearEvent");
 513
 514
 515     /* Decode the Fixed Event */
 516
 517     if (Event > ACPI_EVENT_MAX)
 518     {
 519         return_ACPI_STATUS (AE_BAD_PARAMETER);
 520     }
 521
 522     /*
 523      * Clear the requested fixed event (By writing a one to the
 524      * status register bit)
 525      */
 526     Status = AcpiSetRegister (AcpiGbl_FixedEventInfo[Event].StatusRegisterId,
 527             1, ACPI_MTX_LOCK);
 528
 529     return_ACPI_STATUS (Status);
 530 }
 531
 532
 533 /*******************************************************************************
 534  *
 535  * FUNCTION:    AcpiClearGpe
 536  *
 537  * PARAMETERS:  GpeDevice       - Parent GPE Device
 538  *              GpeNumber       - GPE level within the GPE block
 539  *              Flags           - Called from an ISR or not
 540  *
 541  * RETURN:      Status
 542  *
 543  * DESCRIPTION: Clear an ACPI event (general purpose)
 544  *
 545  ******************************************************************************/
 546
 547 ACPI_STATUS
 548 AcpiClearGpe (
 549     ACPI_HANDLE             GpeDevice,
 550     UINT32                  GpeNumber,
 551     UINT32                  Flags)
 552 {
 553     ACPI_STATUS             Status = AE_OK;
 554     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 555
 556
 557     ACPI_FUNCTION_TRACE ("AcpiClearGpe");
 558
 559
 560     /* Use semaphore lock if not executing at interrupt level */
 561
 562     if (Flags & ACPI_NOT_ISR)
 563     {
 564         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 565         if (ACPI_FAILURE (Status))
 566         {
 567             return_ACPI_STATUS (Status);
 568         }
 569     }
 570
 571     /* Ensure that we have a valid GPE number */
 572
 573     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 574     if (!GpeEventInfo)
 575     {
 576         Status = AE_BAD_PARAMETER;
 577         goto UnlockAndExit;
 578     }
 579
 580     Status = AcpiHwClearGpe (GpeEventInfo);
 581
 582 UnlockAndExit:
 583     if (Flags & ACPI_NOT_ISR)
 584     {
 585         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 586     }
 587     return_ACPI_STATUS (Status);
 588 }
 589
 590
 591 /*******************************************************************************
 592  *
 593  * FUNCTION:    AcpiGetEventStatus
 594  *
 595  * PARAMETERS:  Event           - The fixed event
 596  *              Event Status    - Where the current status of the event will
 597  *                                be returned
 598  *
 599  * RETURN:      Status
 600  *
 601  * DESCRIPTION: Obtains and returns the current status of the event
 602  *
 603  ******************************************************************************/
 604
 605 ACPI_STATUS
 606 AcpiGetEventStatus (
 607     UINT32                  Event,
 608     ACPI_EVENT_STATUS       *EventStatus)
 609 {
 610     ACPI_STATUS             Status = AE_OK;
 611
 612
 613     ACPI_FUNCTION_TRACE ("AcpiGetEventStatus");
 614
 615
 616     if (!EventStatus)
 617     {
 618         return_ACPI_STATUS (AE_BAD_PARAMETER);
 619     }
 620
 621     /* Decode the Fixed Event */
 622
 623     if (Event > ACPI_EVENT_MAX)
 624     {
 625         return_ACPI_STATUS (AE_BAD_PARAMETER);
 626     }
 627
 628     /* Get the status of the requested fixed event */
 629
 630     Status = AcpiGetRegister (AcpiGbl_FixedEventInfo[Event].StatusRegisterId,
 631                     EventStatus, ACPI_MTX_LOCK);
 632
 633     return_ACPI_STATUS (Status);
 634 }
 635
 636
 637 /*******************************************************************************
 638  *
 639  * FUNCTION:    AcpiGetGpeStatus
 640  *
 641  * PARAMETERS:  GpeDevice       - Parent GPE Device
 642  *              GpeNumber       - GPE level within the GPE block
 643  *              Flags           - Called from an ISR or not
 644  *              Event Status    - Where the current status of the event will
 645  *                                be returned
 646  *
 647  * RETURN:      Status
 648  *
 649  * DESCRIPTION: Get status of an event (general purpose)
 650  *
 651  ******************************************************************************/
 652
 653 ACPI_STATUS
 654 AcpiGetGpeStatus (
 655     ACPI_HANDLE             GpeDevice,
 656     UINT32                  GpeNumber,
 657     UINT32                  Flags,
 658     ACPI_EVENT_STATUS       *EventStatus)
 659 {
 660     ACPI_STATUS             Status = AE_OK;
 661     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 662
 663
 664     ACPI_FUNCTION_TRACE ("AcpiGetGpeStatus");
 665
 666
 667     /* Use semaphore lock if not executing at interrupt level */
 668
 669     if (Flags & ACPI_NOT_ISR)
 670     {
 671         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 672         if (ACPI_FAILURE (Status))
 673         {
 674             return_ACPI_STATUS (Status);
 675         }
 676     }
 677
 678     /* Ensure that we have a valid GPE number */
 679
 680     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 681     if (!GpeEventInfo)
 682     {
 683         Status = AE_BAD_PARAMETER;
 684         goto UnlockAndExit;
 685     }
 686
 687     /* Obtain status on the requested GPE number */
 688
 689     Status = AcpiHwGetGpeStatus (GpeEventInfo, EventStatus);
 690
 691 UnlockAndExit:
 692     if (Flags & ACPI_NOT_ISR)
 693     {
 694         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 695     }
 696     return_ACPI_STATUS (Status);
 697 }
 698
 699
 700 /*******************************************************************************
 701  *
 702  * FUNCTION:    AcpiInstallGpeBlock
 703  *
 704  * PARAMETERS:  GpeDevice           - Handle to the parent GPE Block Device
 705  *              GpeBlockAddress     - Address and SpaceID
 706  *              RegisterCount       - Number of GPE register pairs in the block
 707  *              InterruptLevel      - H/W interrupt for the block
 708  *
 709  * RETURN:      Status
 710  *
 711  * DESCRIPTION: Create and Install a block of GPE registers
 712  *
 713  ******************************************************************************/
 714
 715 ACPI_STATUS
 716 AcpiInstallGpeBlock (
 717     ACPI_HANDLE             GpeDevice,
 718     ACPI_GENERIC_ADDRESS    *GpeBlockAddress,
 719     UINT32                  RegisterCount,
 720     UINT32                  InterruptLevel)
 721 {
 722     ACPI_STATUS             Status;
 723     ACPI_OPERAND_OBJECT     *ObjDesc;
 724     ACPI_NAMESPACE_NODE     *Node;
 725     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 726
 727
 728     ACPI_FUNCTION_TRACE ("AcpiInstallGpeBlock");
 729
 730
 731     if ((!GpeDevice)       ||
 732         (!GpeBlockAddress) ||
 733         (!RegisterCount))
 734     {
 735         return_ACPI_STATUS (AE_BAD_PARAMETER);
 736     }
 737
 738     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 739     if (ACPI_FAILURE (Status))
 740     {
 741         return (Status);
 742     }
 743
 744     Node = AcpiNsMapHandleToNode (GpeDevice);
 745     if (!Node)
 746     {
 747         Status = AE_BAD_PARAMETER;
 748         goto UnlockAndExit;
 749     }
 750
 751     /*
 752      * For user-installed GPE Block Devices, the GpeBlockBaseNumber
 753      * is always zero
 754      */
 755     Status = AcpiEvCreateGpeBlock (Node, GpeBlockAddress, RegisterCount,
 756                     0, InterruptLevel, &GpeBlock);
 757     if (ACPI_FAILURE (Status))
 758     {
 759         goto UnlockAndExit;
 760     }
 761
 762     /* Get the DeviceObject attached to the node */
 763
 764     ObjDesc = AcpiNsGetAttachedObject (Node);
 765     if (!ObjDesc)
 766     {
 767         /* No object, create a new one */
 768
 769         ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_DEVICE);
 770         if (!ObjDesc)
 771         {
 772             Status = AE_NO_MEMORY;
 773             goto UnlockAndExit;
 774         }
 775
 776         Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_DEVICE);
 777
 778         /* Remove local reference to the object */
 779
 780         AcpiUtRemoveReference (ObjDesc);
 781
 782         if (ACPI_FAILURE (Status))
 783         {
 784             goto UnlockAndExit;
 785         }
 786     }
 787
 788     /* Install the GPE block in the DeviceObject */
 789
 790     ObjDesc->Device.GpeBlock = GpeBlock;
 791
 792
 793 UnlockAndExit:
 794     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 795     return_ACPI_STATUS (Status);
 796 }
 797
 798
 799 /*******************************************************************************
 800  *
 801  * FUNCTION:    AcpiRemoveGpeBlock
 802  *
 803  * PARAMETERS:  GpeDevice           - Handle to the parent GPE Block Device
 804  *
 805  * RETURN:      Status
 806  *
 807  * DESCRIPTION: Remove a previously installed block of GPE registers
 808  *
 809  ******************************************************************************/
 810
 811 ACPI_STATUS
 812 AcpiRemoveGpeBlock (
 813     ACPI_HANDLE             GpeDevice)
 814 {
 815     ACPI_OPERAND_OBJECT     *ObjDesc;
 816     ACPI_STATUS             Status;
 817     ACPI_NAMESPACE_NODE     *Node;
 818
 819
 820     ACPI_FUNCTION_TRACE ("AcpiRemoveGpeBlock");
 821
 822
 823     if (!GpeDevice)
 824     {
 825         return_ACPI_STATUS (AE_BAD_PARAMETER);
 826     }
 827
 828     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 829     if (ACPI_FAILURE (Status))
 830     {
 831         return (Status);
 832     }
 833
 834     Node = AcpiNsMapHandleToNode (GpeDevice);
 835     if (!Node)
 836     {
 837         Status = AE_BAD_PARAMETER;
 838         goto UnlockAndExit;
 839     }
 840
 841     /* Get the DeviceObject attached to the node */
 842
 843     ObjDesc = AcpiNsGetAttachedObject (Node);
 844     if (!ObjDesc ||
 845         !ObjDesc->Device.GpeBlock)
 846     {
 847         return_ACPI_STATUS (AE_NULL_OBJECT);
 848     }
 849
 850     /* Delete the GPE block (but not the DeviceObject) */
 851
 852     Status = AcpiEvDeleteGpeBlock (ObjDesc->Device.GpeBlock);
 853     if (ACPI_SUCCESS (Status))
 854     {
 855         ObjDesc->Device.GpeBlock = NULL;
 856     }
 857
 858 UnlockAndExit:
 859     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 860     return_ACPI_STATUS (Status);
 861 }
 862