sys/contrib/dev/acpica/events/evxfevnt.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2009, 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
 117 #define __EVXFEVNT_C__
 118
 119 #include <contrib/dev/acpica/include/acpi.h>
 120 #include <contrib/dev/acpica/include/accommon.h>
 121 #include <contrib/dev/acpica/include/acevents.h>
 122 #include <contrib/dev/acpica/include/acnamesp.h>
 123 #include <contrib/dev/acpica/include/actables.h>
 124
 125 #define _COMPONENT          ACPI_EVENTS
 126         ACPI_MODULE_NAME    ("evxfevnt")
 127
 128 /* Local prototypes */
 129
 130 static ACPI_STATUS
 131 AcpiEvGetGpeDevice (
 132     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
 133     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 134     void                    *Context);
 135
 136
 137 /*******************************************************************************
 138  *
 139  * FUNCTION:    AcpiEnable
 140  *
 141  * PARAMETERS:  None
 142  *
 143  * RETURN:      Status
 144  *
 145  * DESCRIPTION: Transfers the system into ACPI mode.
 146  *
 147  ******************************************************************************/
 148
 149 ACPI_STATUS
 150 AcpiEnable (
 151     void)
 152 {
 153     ACPI_STATUS             Status = AE_OK;
 154
 155
 156     ACPI_FUNCTION_TRACE (AcpiEnable);
 157
 158
 159     /* ACPI tables must be present */
 160
 161     if (!AcpiTbTablesLoaded ())
 162     {
 163         return_ACPI_STATUS (AE_NO_ACPI_TABLES);
 164     }
 165
 166     /* Check current mode */
 167
 168     if (AcpiHwGetMode() == ACPI_SYS_MODE_ACPI)
 169     {
 170         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "System is already in ACPI mode\n"));
 171     }
 172     else
 173     {
 174         /* Transition to ACPI mode */
 175
 176         Status = AcpiHwSetMode (ACPI_SYS_MODE_ACPI);
 177         if (ACPI_FAILURE (Status))
 178         {
 179             ACPI_ERROR ((AE_INFO, "Could not transition to ACPI mode"));
 180             return_ACPI_STATUS (Status);
 181         }
 182
 183         ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
 184             "Transition to ACPI mode successful\n"));
 185     }
 186
 187     return_ACPI_STATUS (Status);
 188 }
 189
 190 ACPI_EXPORT_SYMBOL (AcpiEnable)
 191
 192
 193 /*******************************************************************************
 194  *
 195  * FUNCTION:    AcpiDisable
 196  *
 197  * PARAMETERS:  None
 198  *
 199  * RETURN:      Status
 200  *
 201  * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
 202  *
 203  ******************************************************************************/
 204
 205 ACPI_STATUS
 206 AcpiDisable (
 207     void)
 208 {
 209     ACPI_STATUS             Status = AE_OK;
 210
 211
 212     ACPI_FUNCTION_TRACE (AcpiDisable);
 213
 214
 215     if (AcpiHwGetMode() == ACPI_SYS_MODE_LEGACY)
 216     {
 217         ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
 218             "System is already in legacy (non-ACPI) mode\n"));
 219     }
 220     else
 221     {
 222         /* Transition to LEGACY mode */
 223
 224         Status = AcpiHwSetMode (ACPI_SYS_MODE_LEGACY);
 225
 226         if (ACPI_FAILURE (Status))
 227         {
 228             ACPI_ERROR ((AE_INFO,
 229                 "Could not exit ACPI mode to legacy mode"));
 230             return_ACPI_STATUS (Status);
 231         }
 232
 233         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "ACPI mode disabled\n"));
 234     }
 235
 236     return_ACPI_STATUS (Status);
 237 }
 238
 239 ACPI_EXPORT_SYMBOL (AcpiDisable)
 240
 241
 242 /*******************************************************************************
 243  *
 244  * FUNCTION:    AcpiEnableEvent
 245  *
 246  * PARAMETERS:  Event           - The fixed eventto be enabled
 247  *              Flags           - Reserved
 248  *
 249  * RETURN:      Status
 250  *
 251  * DESCRIPTION: Enable an ACPI event (fixed)
 252  *
 253  ******************************************************************************/
 254
 255 ACPI_STATUS
 256 AcpiEnableEvent (
 257     UINT32                  Event,
 258     UINT32                  Flags)
 259 {
 260     ACPI_STATUS             Status = AE_OK;
 261     UINT32                  Value;
 262
 263
 264     ACPI_FUNCTION_TRACE (AcpiEnableEvent);
 265
 266
 267     /* Decode the Fixed Event */
 268
 269     if (Event > ACPI_EVENT_MAX)
 270     {
 271         return_ACPI_STATUS (AE_BAD_PARAMETER);
 272     }
 273
 274     /*
 275      * Enable the requested fixed event (by writing a one to the enable
 276      * register bit)
 277      */
 278     Status = AcpiWriteBitRegister (
 279                 AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
 280                 ACPI_ENABLE_EVENT);
 281     if (ACPI_FAILURE (Status))
 282     {
 283         return_ACPI_STATUS (Status);
 284     }
 285
 286     /* Make sure that the hardware responded */
 287
 288     Status = AcpiReadBitRegister (
 289                 AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &Value);
 290     if (ACPI_FAILURE (Status))
 291     {
 292         return_ACPI_STATUS (Status);
 293     }
 294
 295     if (Value != 1)
 296     {
 297         ACPI_ERROR ((AE_INFO,
 298             "Could not enable %s event", AcpiUtGetEventName (Event)));
 299         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
 300     }
 301
 302     return_ACPI_STATUS (Status);
 303 }
 304
 305 ACPI_EXPORT_SYMBOL (AcpiEnableEvent)
 306
 307
 308 /*******************************************************************************
 309  *
 310  * FUNCTION:    AcpiSetGpeType
 311  *
 312  * PARAMETERS:  GpeDevice       - Parent GPE Device
 313  *              GpeNumber       - GPE level within the GPE block
 314  *              Type            - New GPE type
 315  *
 316  * RETURN:      Status
 317  *
 318  * DESCRIPTION: Set the type of an individual GPE
 319  *
 320  ******************************************************************************/
 321
 322 ACPI_STATUS
 323 AcpiSetGpeType (
 324     ACPI_HANDLE             GpeDevice,
 325     UINT32                  GpeNumber,
 326     UINT8                   Type)
 327 {
 328     ACPI_STATUS             Status = AE_OK;
 329     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 330
 331
 332     ACPI_FUNCTION_TRACE (AcpiSetGpeType);
 333
 334
 335     /* Ensure that we have a valid GPE number */
 336
 337     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 338     if (!GpeEventInfo)
 339     {
 340         Status = AE_BAD_PARAMETER;
 341         goto UnlockAndExit;
 342     }
 343
 344     if ((GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK) == Type)
 345     {
 346         return_ACPI_STATUS (AE_OK);
 347     }
 348
 349     /* Set the new type (will disable GPE if currently enabled) */
 350
 351     Status = AcpiEvSetGpeType (GpeEventInfo, Type);
 352
 353 UnlockAndExit:
 354     return_ACPI_STATUS (Status);
 355 }
 356
 357 ACPI_EXPORT_SYMBOL (AcpiSetGpeType)
 358
 359
 360 /*******************************************************************************
 361  *
 362  * FUNCTION:    AcpiEnableGpe
 363  *
 364  * PARAMETERS:  GpeDevice       - Parent GPE Device
 365  *              GpeNumber       - GPE level within the GPE block
 366  *              Flags           - Just enable, or also wake enable?
 367  *                                Called from ISR or not
 368  *
 369  * RETURN:      Status
 370  *
 371  * DESCRIPTION: Enable an ACPI event (general purpose)
 372  *
 373  ******************************************************************************/
 374
 375 ACPI_STATUS
 376 AcpiEnableGpe (
 377     ACPI_HANDLE             GpeDevice,
 378     UINT32                  GpeNumber,
 379     UINT32                  Flags)
 380 {
 381     ACPI_STATUS             Status = AE_OK;
 382     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 383
 384
 385     ACPI_FUNCTION_TRACE (AcpiEnableGpe);
 386
 387
 388     /* Use semaphore lock if not executing at interrupt level */
 389
 390     if (Flags & ACPI_NOT_ISR)
 391     {
 392         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 393         if (ACPI_FAILURE (Status))
 394         {
 395             return_ACPI_STATUS (Status);
 396         }
 397     }
 398
 399     /* Ensure that we have a valid GPE number */
 400
 401     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 402     if (!GpeEventInfo)
 403     {
 404         Status = AE_BAD_PARAMETER;
 405         goto UnlockAndExit;
 406     }
 407
 408     /* Perform the enable */
 409
 410     Status = AcpiEvEnableGpe (GpeEventInfo, TRUE);
 411
 412 UnlockAndExit:
 413     if (Flags & ACPI_NOT_ISR)
 414     {
 415         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 416     }
 417     return_ACPI_STATUS (Status);
 418 }
 419
 420 ACPI_EXPORT_SYMBOL (AcpiEnableGpe)
 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 disable, or also wake disable?
 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     Status = AcpiEvDisableGpe (GpeEventInfo);
 472
 473 UnlockAndExit:
 474     if (Flags & ACPI_NOT_ISR)
 475     {
 476         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 477     }
 478     return_ACPI_STATUS (Status);
 479 }
 480
 481 ACPI_EXPORT_SYMBOL (AcpiDisableGpe)
 482
 483
 484 /*******************************************************************************
 485  *
 486  * FUNCTION:    AcpiDisableEvent
 487  *
 488  * PARAMETERS:  Event           - The fixed eventto be enabled
 489  *              Flags           - Reserved
 490  *
 491  * RETURN:      Status
 492  *
 493  * DESCRIPTION: Disable an ACPI event (fixed)
 494  *
 495  ******************************************************************************/
 496
 497 ACPI_STATUS
 498 AcpiDisableEvent (
 499     UINT32                  Event,
 500     UINT32                  Flags)
 501 {
 502     ACPI_STATUS             Status = AE_OK;
 503     UINT32                  Value;
 504
 505
 506     ACPI_FUNCTION_TRACE (AcpiDisableEvent);
 507
 508
 509     /* Decode the Fixed Event */
 510
 511     if (Event > ACPI_EVENT_MAX)
 512     {
 513         return_ACPI_STATUS (AE_BAD_PARAMETER);
 514     }
 515
 516     /*
 517      * Disable the requested fixed event (by writing a zero to the enable
 518      * register bit)
 519      */
 520     Status = AcpiWriteBitRegister (
 521                 AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
 522                 ACPI_DISABLE_EVENT);
 523     if (ACPI_FAILURE (Status))
 524     {
 525         return_ACPI_STATUS (Status);
 526     }
 527
 528     Status = AcpiReadBitRegister (
 529                 AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &Value);
 530     if (ACPI_FAILURE (Status))
 531     {
 532         return_ACPI_STATUS (Status);
 533     }
 534
 535     if (Value != 0)
 536     {
 537         ACPI_ERROR ((AE_INFO,
 538             "Could not disable %s events", AcpiUtGetEventName (Event)));
 539         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
 540     }
 541
 542     return_ACPI_STATUS (Status);
 543 }
 544
 545 ACPI_EXPORT_SYMBOL (AcpiDisableEvent)
 546
 547
 548 /*******************************************************************************
 549  *
 550  * FUNCTION:    AcpiClearEvent
 551  *
 552  * PARAMETERS:  Event           - The fixed event to be cleared
 553  *
 554  * RETURN:      Status
 555  *
 556  * DESCRIPTION: Clear an ACPI event (fixed)
 557  *
 558  ******************************************************************************/
 559
 560 ACPI_STATUS
 561 AcpiClearEvent (
 562     UINT32                  Event)
 563 {
 564     ACPI_STATUS             Status = AE_OK;
 565
 566
 567     ACPI_FUNCTION_TRACE (AcpiClearEvent);
 568
 569
 570     /* Decode the Fixed Event */
 571
 572     if (Event > ACPI_EVENT_MAX)
 573     {
 574         return_ACPI_STATUS (AE_BAD_PARAMETER);
 575     }
 576
 577     /*
 578      * Clear the requested fixed event (By writing a one to the status
 579      * register bit)
 580      */
 581     Status = AcpiWriteBitRegister (
 582                 AcpiGbl_FixedEventInfo[Event].StatusRegisterId,
 583                 ACPI_CLEAR_STATUS);
 584
 585     return_ACPI_STATUS (Status);
 586 }
 587
 588 ACPI_EXPORT_SYMBOL (AcpiClearEvent)
 589
 590
 591 /*******************************************************************************
 592  *
 593  * FUNCTION:    AcpiClearGpe
 594  *
 595  * PARAMETERS:  GpeDevice       - Parent GPE Device
 596  *              GpeNumber       - GPE level within the GPE block
 597  *              Flags           - Called from an ISR or not
 598  *
 599  * RETURN:      Status
 600  *
 601  * DESCRIPTION: Clear an ACPI event (general purpose)
 602  *
 603  ******************************************************************************/
 604
 605 ACPI_STATUS
 606 AcpiClearGpe (
 607     ACPI_HANDLE             GpeDevice,
 608     UINT32                  GpeNumber,
 609     UINT32                  Flags)
 610 {
 611     ACPI_STATUS             Status = AE_OK;
 612     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 613
 614
 615     ACPI_FUNCTION_TRACE (AcpiClearGpe);
 616
 617
 618     /* Use semaphore lock if not executing at interrupt level */
 619
 620     if (Flags & ACPI_NOT_ISR)
 621     {
 622         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 623         if (ACPI_FAILURE (Status))
 624         {
 625             return_ACPI_STATUS (Status);
 626         }
 627     }
 628
 629     /* Ensure that we have a valid GPE number */
 630
 631     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 632     if (!GpeEventInfo)
 633     {
 634         Status = AE_BAD_PARAMETER;
 635         goto UnlockAndExit;
 636     }
 637
 638     Status = AcpiHwClearGpe (GpeEventInfo);
 639
 640 UnlockAndExit:
 641     if (Flags & ACPI_NOT_ISR)
 642     {
 643         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 644     }
 645     return_ACPI_STATUS (Status);
 646 }
 647
 648 ACPI_EXPORT_SYMBOL (AcpiClearGpe)
 649
 650
 651 /*******************************************************************************
 652  *
 653  * FUNCTION:    AcpiGetEventStatus
 654  *
 655  * PARAMETERS:  Event           - The fixed event
 656  *              EventStatus     - Where the current status of the event will
 657  *                                be returned
 658  *
 659  * RETURN:      Status
 660  *
 661  * DESCRIPTION: Obtains and returns the current status of the event
 662  *
 663  ******************************************************************************/
 664
 665 ACPI_STATUS
 666 AcpiGetEventStatus (
 667     UINT32                  Event,
 668     ACPI_EVENT_STATUS       *EventStatus)
 669 {
 670     ACPI_STATUS             Status = AE_OK;
 671
 672
 673     ACPI_FUNCTION_TRACE (AcpiGetEventStatus);
 674
 675
 676     if (!EventStatus)
 677     {
 678         return_ACPI_STATUS (AE_BAD_PARAMETER);
 679     }
 680
 681     /* Decode the Fixed Event */
 682
 683     if (Event > ACPI_EVENT_MAX)
 684     {
 685         return_ACPI_STATUS (AE_BAD_PARAMETER);
 686     }
 687
 688     /* Get the status of the requested fixed event */
 689
 690     Status = AcpiReadBitRegister (
 691                 AcpiGbl_FixedEventInfo[Event].StatusRegisterId, EventStatus);
 692
 693     return_ACPI_STATUS (Status);
 694 }
 695
 696 ACPI_EXPORT_SYMBOL (AcpiGetEventStatus)
 697
 698
 699 /*******************************************************************************
 700  *
 701  * FUNCTION:    AcpiGetGpeStatus
 702  *
 703  * PARAMETERS:  GpeDevice       - Parent GPE Device
 704  *              GpeNumber       - GPE level within the GPE block
 705  *              Flags           - Called from an ISR or not
 706  *              EventStatus     - Where the current status of the event will
 707  *                                be returned
 708  *
 709  * RETURN:      Status
 710  *
 711  * DESCRIPTION: Get status of an event (general purpose)
 712  *
 713  ******************************************************************************/
 714
 715 ACPI_STATUS
 716 AcpiGetGpeStatus (
 717     ACPI_HANDLE             GpeDevice,
 718     UINT32                  GpeNumber,
 719     UINT32                  Flags,
 720     ACPI_EVENT_STATUS       *EventStatus)
 721 {
 722     ACPI_STATUS             Status = AE_OK;
 723     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 724
 725
 726     ACPI_FUNCTION_TRACE (AcpiGetGpeStatus);
 727
 728
 729     /* Use semaphore lock if not executing at interrupt level */
 730
 731     if (Flags & ACPI_NOT_ISR)
 732     {
 733         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 734         if (ACPI_FAILURE (Status))
 735         {
 736             return_ACPI_STATUS (Status);
 737         }
 738     }
 739
 740     /* Ensure that we have a valid GPE number */
 741
 742     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 743     if (!GpeEventInfo)
 744     {
 745         Status = AE_BAD_PARAMETER;
 746         goto UnlockAndExit;
 747     }
 748
 749     /* Obtain status on the requested GPE number */
 750
 751     Status = AcpiHwGetGpeStatus (GpeEventInfo, EventStatus);
 752
 753 UnlockAndExit:
 754     if (Flags & ACPI_NOT_ISR)
 755     {
 756         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 757     }
 758     return_ACPI_STATUS (Status);
 759 }
 760
 761 ACPI_EXPORT_SYMBOL (AcpiGetGpeStatus)
 762
 763
 764 /*******************************************************************************
 765  *
 766  * FUNCTION:    AcpiInstallGpeBlock
 767  *
 768  * PARAMETERS:  GpeDevice           - Handle to the parent GPE Block Device
 769  *              GpeBlockAddress     - Address and SpaceID
 770  *              RegisterCount       - Number of GPE register pairs in the block
 771  *              InterruptNumber     - H/W interrupt for the block
 772  *
 773  * RETURN:      Status
 774  *
 775  * DESCRIPTION: Create and Install a block of GPE registers
 776  *
 777  ******************************************************************************/
 778
 779 ACPI_STATUS
 780 AcpiInstallGpeBlock (
 781     ACPI_HANDLE             GpeDevice,
 782     ACPI_GENERIC_ADDRESS    *GpeBlockAddress,
 783     UINT32                  RegisterCount,
 784     UINT32                  InterruptNumber)
 785 {
 786     ACPI_STATUS             Status;
 787     ACPI_OPERAND_OBJECT     *ObjDesc;
 788     ACPI_NAMESPACE_NODE     *Node;
 789     ACPI_GPE_BLOCK_INFO     *GpeBlock;
 790
 791
 792     ACPI_FUNCTION_TRACE (AcpiInstallGpeBlock);
 793
 794
 795     if ((!GpeDevice)       ||
 796         (!GpeBlockAddress) ||
 797         (!RegisterCount))
 798     {
 799         return_ACPI_STATUS (AE_BAD_PARAMETER);
 800     }
 801
 802     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 803     if (ACPI_FAILURE (Status))
 804     {
 805         return (Status);
 806     }
 807
 808     Node = AcpiNsMapHandleToNode (GpeDevice);
 809     if (!Node)
 810     {
 811         Status = AE_BAD_PARAMETER;
 812         goto UnlockAndExit;
 813     }
 814
 815     /*
 816      * For user-installed GPE Block Devices, the GpeBlockBaseNumber
 817      * is always zero
 818      */
 819     Status = AcpiEvCreateGpeBlock (Node, GpeBlockAddress, RegisterCount,
 820                 0, InterruptNumber, &GpeBlock);
 821     if (ACPI_FAILURE (Status))
 822     {
 823         goto UnlockAndExit;
 824     }
 825
 826     /* Run the _PRW methods and enable the GPEs */
 827
 828     Status = AcpiEvInitializeGpeBlock (Node, GpeBlock);
 829     if (ACPI_FAILURE (Status))
 830     {
 831         goto UnlockAndExit;
 832     }
 833
 834     /* Get the DeviceObject attached to the node */
 835
 836     ObjDesc = AcpiNsGetAttachedObject (Node);
 837     if (!ObjDesc)
 838     {
 839         /* No object, create a new one */
 840
 841         ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_DEVICE);
 842         if (!ObjDesc)
 843         {
 844             Status = AE_NO_MEMORY;
 845             goto UnlockAndExit;
 846         }
 847
 848         Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_DEVICE);
 849
 850         /* Remove local reference to the object */
 851
 852         AcpiUtRemoveReference (ObjDesc);
 853
 854         if (ACPI_FAILURE (Status))
 855         {
 856             goto UnlockAndExit;
 857         }
 858     }
 859
 860     /* Install the GPE block in the DeviceObject */
 861
 862     ObjDesc->Device.GpeBlock = GpeBlock;
 863
 864
 865 UnlockAndExit:
 866     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 867     return_ACPI_STATUS (Status);
 868 }
 869
 870 ACPI_EXPORT_SYMBOL (AcpiInstallGpeBlock)
 871
 872
 873 /*******************************************************************************
 874  *
 875  * FUNCTION:    AcpiRemoveGpeBlock
 876  *
 877  * PARAMETERS:  GpeDevice           - Handle to the parent GPE Block Device
 878  *
 879  * RETURN:      Status
 880  *
 881  * DESCRIPTION: Remove a previously installed block of GPE registers
 882  *
 883  ******************************************************************************/
 884
 885 ACPI_STATUS
 886 AcpiRemoveGpeBlock (
 887     ACPI_HANDLE             GpeDevice)
 888 {
 889     ACPI_OPERAND_OBJECT     *ObjDesc;
 890     ACPI_STATUS             Status;
 891     ACPI_NAMESPACE_NODE     *Node;
 892
 893
 894     ACPI_FUNCTION_TRACE (AcpiRemoveGpeBlock);
 895
 896
 897     if (!GpeDevice)
 898     {
 899         return_ACPI_STATUS (AE_BAD_PARAMETER);
 900     }
 901
 902     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 903     if (ACPI_FAILURE (Status))
 904     {
 905         return (Status);
 906     }
 907
 908     Node = AcpiNsMapHandleToNode (GpeDevice);
 909     if (!Node)
 910     {
 911         Status = AE_BAD_PARAMETER;
 912         goto UnlockAndExit;
 913     }
 914
 915     /* Get the DeviceObject attached to the node */
 916
 917     ObjDesc = AcpiNsGetAttachedObject (Node);
 918     if (!ObjDesc ||
 919         !ObjDesc->Device.GpeBlock)
 920     {
 921         return_ACPI_STATUS (AE_NULL_OBJECT);
 922     }
 923
 924     /* Delete the GPE block (but not the DeviceObject) */
 925
 926     Status = AcpiEvDeleteGpeBlock (ObjDesc->Device.GpeBlock);
 927     if (ACPI_SUCCESS (Status))
 928     {
 929         ObjDesc->Device.GpeBlock = NULL;
 930     }
 931
 932 UnlockAndExit:
 933     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 934     return_ACPI_STATUS (Status);
 935 }
 936
 937 ACPI_EXPORT_SYMBOL (AcpiRemoveGpeBlock)
 938
 939
 940 /*******************************************************************************
 941  *
 942  * FUNCTION:    AcpiGetGpeDevice
 943  *
 944  * PARAMETERS:  Index               - System GPE index (0-CurrentGpeCount)
 945  *              GpeDevice           - Where the parent GPE Device is returned
 946  *
 947  * RETURN:      Status
 948  *
 949  * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
 950  *              gpe device indicates that the gpe number is contained in one of
 951  *              the FADT-defined gpe blocks. Otherwise, the GPE block device.
 952  *
 953  ******************************************************************************/
 954
 955 ACPI_STATUS
 956 AcpiGetGpeDevice (
 957     UINT32                  Index,
 958     ACPI_HANDLE             *GpeDevice)
 959 {
 960     ACPI_GPE_DEVICE_INFO    Info;
 961     ACPI_STATUS             Status;
 962
 963
 964     ACPI_FUNCTION_TRACE (AcpiGetGpeDevice);
 965
 966
 967     if (!GpeDevice)
 968     {
 969         return_ACPI_STATUS (AE_BAD_PARAMETER);
 970     }
 971
 972     if (Index >= AcpiCurrentGpeCount)
 973     {
 974         return_ACPI_STATUS (AE_NOT_EXIST);
 975     }
 976
 977     /* Setup and walk the GPE list */
 978
 979     Info.Index = Index;
 980     Info.Status = AE_NOT_EXIST;
 981     Info.GpeDevice = NULL;
 982     Info.NextBlockBaseIndex = 0;
 983
 984     Status = AcpiEvWalkGpeList (AcpiEvGetGpeDevice, &Info);
 985     if (ACPI_FAILURE (Status))
 986     {
 987         return_ACPI_STATUS (Status);
 988     }
 989
 990     *GpeDevice = ACPI_CAST_PTR (ACPI_HANDLE, Info.GpeDevice);
 991     return_ACPI_STATUS (Info.Status);
 992 }
 993
 994 ACPI_EXPORT_SYMBOL (AcpiGetGpeDevice)
 995
 996
 997 /*******************************************************************************
 998  *
 999  * FUNCTION:    AcpiEvGetGpeDevice
1000  *
1001  * PARAMETERS:  GPE_WALK_CALLBACK
1002  *
1003  * RETURN:      Status
1004  *
1005  * DESCRIPTION: Matches the input GPE index (0-CurrentGpeCount) with a GPE
1006  *              block device. NULL if the GPE is one of the FADT-defined GPEs.
1007  *
1008  ******************************************************************************/
1009
1010 static ACPI_STATUS
1011 AcpiEvGetGpeDevice (
1012     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
1013     ACPI_GPE_BLOCK_INFO     *GpeBlock,
1014     void                    *Context)
1015 {
1016     ACPI_GPE_DEVICE_INFO    *Info = Context;
1017
1018
1019     /* Increment Index by the number of GPEs in this block */
1020
1021     Info->NextBlockBaseIndex +=
1022         (GpeBlock->RegisterCount * ACPI_GPE_REGISTER_WIDTH);
1023
1024     if (Info->Index < Info->NextBlockBaseIndex)
1025     {
1026         /*
1027          * The GPE index is within this block, get the node. Leave the node
1028          * NULL for the FADT-defined GPEs
1029          */
1030         if ((GpeBlock->Node)->Type == ACPI_TYPE_DEVICE)
1031         {
1032             Info->GpeDevice = GpeBlock->Node;
1033         }
1034
1035         Info->Status = AE_OK;
1036         return (AE_CTRL_END);
1037     }
1038
1039     return (AE_OK);
1040 }
1041
1042
1043 /******************************************************************************
1044  *
1045  * FUNCTION:    AcpiDisableAllGpes
1046  *
1047  * PARAMETERS:  None
1048  *
1049  * RETURN:      Status
1050  *
1051  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
1052  *
1053  ******************************************************************************/
1054
1055 ACPI_STATUS
1056 AcpiDisableAllGpes (
1057     void)
1058 {
1059     ACPI_STATUS             Status;
1060
1061
1062     ACPI_FUNCTION_TRACE (AcpiDisableAllGpes);
1063
1064
1065     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
1066     if (ACPI_FAILURE (Status))
1067     {
1068         return_ACPI_STATUS (Status);
1069     }
1070
1071     Status = AcpiHwDisableAllGpes ();
1072     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
1073
1074     return_ACPI_STATUS (Status);
1075 }
1076
1077
1078 /******************************************************************************
1079  *
1080  * FUNCTION:    AcpiEnableAllRuntimeGpes
1081  *
1082  * PARAMETERS:  None
1083  *
1084  * RETURN:      Status
1085  *
1086  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
1087  *
1088  ******************************************************************************/
1089
1090 ACPI_STATUS
1091 AcpiEnableAllRuntimeGpes (
1092     void)
1093 {
1094     ACPI_STATUS             Status;
1095
1096
1097     ACPI_FUNCTION_TRACE (AcpiEnableAllRuntimeGpes);
1098
1099
1100     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
1101     if (ACPI_FAILURE (Status))
1102     {
1103         return_ACPI_STATUS (Status);
1104     }
1105
1106     Status = AcpiHwEnableAllRuntimeGpes ();
1107     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
1108
1109     return_ACPI_STATUS (Status);
1110 }
1111
1112