arch/all-pc/acpica/source/components/hardware/hwgpe.c

   1 /******************************************************************************
   2  *
   3  * Module Name: hwgpe - Low level GPE enable/disable/clear functions
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include "acpi.h"
  45 #include "accommon.h"
  46 #include "acevents.h"
  47
  48 #define _COMPONENT          ACPI_HARDWARE
  49         ACPI_MODULE_NAME    ("hwgpe")
  50
  51 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
  52
  53 /* Local prototypes */
  54
  55 static ACPI_STATUS
  56 AcpiHwEnableWakeupGpeBlock (
  57     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
  58     ACPI_GPE_BLOCK_INFO     *GpeBlock,
  59     void                    *Context);
  60
  61
  62 /******************************************************************************
  63  *
  64  * FUNCTION:    AcpiHwGetGpeRegisterBit
  65  *
  66  * PARAMETERS:  GpeEventInfo        - Info block for the GPE
  67  *
  68  * RETURN:      Register mask with a one in the GPE bit position
  69  *
  70  * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
  71  *              correct position for the input GPE.
  72  *
  73  ******************************************************************************/
  74
  75 UINT32
  76 AcpiHwGetGpeRegisterBit (
  77     ACPI_GPE_EVENT_INFO     *GpeEventInfo)
  78 {
  79
  80     return ((UINT32) 1 <<
  81         (GpeEventInfo->GpeNumber - GpeEventInfo->RegisterInfo->BaseGpeNumber));
  82 }
  83
  84
  85 /******************************************************************************
  86  *
  87  * FUNCTION:    AcpiHwLowSetGpe
  88  *
  89  * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be disabled
  90  *              Action              - Enable or disable
  91  *
  92  * RETURN:      Status
  93  *
  94  * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
  95  *
  96  ******************************************************************************/
  97
  98 ACPI_STATUS
  99 AcpiHwLowSetGpe (
 100     ACPI_GPE_EVENT_INFO     *GpeEventInfo,
 101     UINT32                  Action)
 102 {
 103     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
 104     ACPI_STATUS             Status;
 105     UINT32                  EnableMask;
 106     UINT32                  RegisterBit;
 107
 108
 109     ACPI_FUNCTION_ENTRY ();
 110
 111
 112     /* Get the info block for the entire GPE register */
 113
 114     GpeRegisterInfo = GpeEventInfo->RegisterInfo;
 115     if (!GpeRegisterInfo)
 116     {
 117         return (AE_NOT_EXIST);
 118     }
 119
 120     /* Get current value of the enable register that contains this GPE */
 121
 122     Status = AcpiHwRead (&EnableMask, &GpeRegisterInfo->EnableAddress);
 123     if (ACPI_FAILURE (Status))
 124     {
 125         return (Status);
 126     }
 127
 128     /* Set or clear just the bit that corresponds to this GPE */
 129
 130     RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 131     switch (Action)
 132     {
 133     case ACPI_GPE_CONDITIONAL_ENABLE:
 134
 135         /* Only enable if the EnableForRun bit is set */
 136
 137         if (!(RegisterBit & GpeRegisterInfo->EnableForRun))
 138         {
 139             return (AE_BAD_PARAMETER);
 140         }
 141
 142         /*lint -fallthrough */
 143
 144     case ACPI_GPE_ENABLE:
 145
 146         ACPI_SET_BIT (EnableMask, RegisterBit);
 147         break;
 148
 149     case ACPI_GPE_DISABLE:
 150
 151         ACPI_CLEAR_BIT (EnableMask, RegisterBit);
 152         break;
 153
 154     default:
 155
 156         ACPI_ERROR ((AE_INFO, "Invalid GPE Action, %u", Action));
 157         return (AE_BAD_PARAMETER);
 158     }
 159
 160     /* Write the updated enable mask */
 161
 162     Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
 163     return (Status);
 164 }
 165
 166
 167 /******************************************************************************
 168  *
 169  * FUNCTION:    AcpiHwClearGpe
 170  *
 171  * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be cleared
 172  *
 173  * RETURN:      Status
 174  *
 175  * DESCRIPTION: Clear the status bit for a single GPE.
 176  *
 177  ******************************************************************************/
 178
 179 ACPI_STATUS
 180 AcpiHwClearGpe (
 181     ACPI_GPE_EVENT_INFO     *GpeEventInfo)
 182 {
 183     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
 184     ACPI_STATUS             Status;
 185     UINT32                  RegisterBit;
 186
 187
 188     ACPI_FUNCTION_ENTRY ();
 189
 190     /* Get the info block for the entire GPE register */
 191
 192     GpeRegisterInfo = GpeEventInfo->RegisterInfo;
 193     if (!GpeRegisterInfo)
 194     {
 195         return (AE_NOT_EXIST);
 196     }
 197
 198     /*
 199      * Write a one to the appropriate bit in the status register to
 200      * clear this GPE.
 201      */
 202     RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 203
 204     Status = AcpiHwWrite (RegisterBit,
 205                     &GpeRegisterInfo->StatusAddress);
 206
 207     return (Status);
 208 }
 209
 210
 211 /******************************************************************************
 212  *
 213  * FUNCTION:    AcpiHwGetGpeStatus
 214  *
 215  * PARAMETERS:  GpeEventInfo        - Info block for the GPE to queried
 216  *              EventStatus         - Where the GPE status is returned
 217  *
 218  * RETURN:      Status
 219  *
 220  * DESCRIPTION: Return the status of a single GPE.
 221  *
 222  ******************************************************************************/
 223
 224 ACPI_STATUS
 225 AcpiHwGetGpeStatus (
 226     ACPI_GPE_EVENT_INFO     *GpeEventInfo,
 227     ACPI_EVENT_STATUS       *EventStatus)
 228 {
 229     UINT32                  InByte;
 230     UINT32                  RegisterBit;
 231     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
 232     ACPI_EVENT_STATUS       LocalEventStatus = 0;
 233     ACPI_STATUS             Status;
 234
 235
 236     ACPI_FUNCTION_ENTRY ();
 237
 238
 239     if (!EventStatus)
 240     {
 241         return (AE_BAD_PARAMETER);
 242     }
 243
 244     /* Get the info block for the entire GPE register */
 245
 246     GpeRegisterInfo = GpeEventInfo->RegisterInfo;
 247
 248     /* Get the register bitmask for this GPE */
 249
 250     RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 251
 252     /* GPE currently enabled? (enabled for runtime?) */
 253
 254     if (RegisterBit & GpeRegisterInfo->EnableForRun)
 255     {
 256         LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
 257     }
 258
 259     /* GPE enabled for wake? */
 260
 261     if (RegisterBit & GpeRegisterInfo->EnableForWake)
 262     {
 263         LocalEventStatus |= ACPI_EVENT_FLAG_WAKE_ENABLED;
 264     }
 265
 266     /* GPE currently active (status bit == 1)? */
 267
 268     Status = AcpiHwRead (&InByte, &GpeRegisterInfo->StatusAddress);
 269     if (ACPI_FAILURE (Status))
 270     {
 271         return (Status);
 272     }
 273
 274     if (RegisterBit & InByte)
 275     {
 276         LocalEventStatus |= ACPI_EVENT_FLAG_SET;
 277     }
 278
 279     /* Set return value */
 280
 281     (*EventStatus) = LocalEventStatus;
 282     return (AE_OK);
 283 }
 284
 285
 286 /******************************************************************************
 287  *
 288  * FUNCTION:    AcpiHwDisableGpeBlock
 289  *
 290  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
 291  *              GpeBlock            - Gpe Block info
 292  *
 293  * RETURN:      Status
 294  *
 295  * DESCRIPTION: Disable all GPEs within a single GPE block
 296  *
 297  ******************************************************************************/
 298
 299 ACPI_STATUS
 300 AcpiHwDisableGpeBlock (
 301     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
 302     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 303     void                    *Context)
 304 {
 305     UINT32                  i;
 306     ACPI_STATUS             Status;
 307
 308
 309     /* Examine each GPE Register within the block */
 310
 311     for (i = 0; i < GpeBlock->RegisterCount; i++)
 312     {
 313         /* Disable all GPEs in this register */
 314
 315         Status = AcpiHwWrite (0x00, &GpeBlock->RegisterInfo[i].EnableAddress);
 316         if (ACPI_FAILURE (Status))
 317         {
 318             return (Status);
 319         }
 320     }
 321
 322     return (AE_OK);
 323 }
 324
 325
 326 /******************************************************************************
 327  *
 328  * FUNCTION:    AcpiHwClearGpeBlock
 329  *
 330  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
 331  *              GpeBlock            - Gpe Block info
 332  *
 333  * RETURN:      Status
 334  *
 335  * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
 336  *
 337  ******************************************************************************/
 338
 339 ACPI_STATUS
 340 AcpiHwClearGpeBlock (
 341     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
 342     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 343     void                    *Context)
 344 {
 345     UINT32                  i;
 346     ACPI_STATUS             Status;
 347
 348
 349     /* Examine each GPE Register within the block */
 350
 351     for (i = 0; i < GpeBlock->RegisterCount; i++)
 352     {
 353         /* Clear status on all GPEs in this register */
 354
 355         Status = AcpiHwWrite (0xFF, &GpeBlock->RegisterInfo[i].StatusAddress);
 356         if (ACPI_FAILURE (Status))
 357         {
 358             return (Status);
 359         }
 360     }
 361
 362     return (AE_OK);
 363 }
 364
 365
 366 /******************************************************************************
 367  *
 368  * FUNCTION:    AcpiHwEnableRuntimeGpeBlock
 369  *
 370  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
 371  *              GpeBlock            - Gpe Block info
 372  *
 373  * RETURN:      Status
 374  *
 375  * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
 376  *              combination wake/run GPEs.
 377  *
 378  ******************************************************************************/
 379
 380 ACPI_STATUS
 381 AcpiHwEnableRuntimeGpeBlock (
 382     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
 383     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 384     void                    *Context)
 385 {
 386     UINT32                  i;
 387     ACPI_STATUS             Status;
 388
 389
 390     /* NOTE: assumes that all GPEs are currently disabled */
 391
 392     /* Examine each GPE Register within the block */
 393
 394     for (i = 0; i < GpeBlock->RegisterCount; i++)
 395     {
 396         if (!GpeBlock->RegisterInfo[i].EnableForRun)
 397         {
 398             continue;
 399         }
 400
 401         /* Enable all "runtime" GPEs in this register */
 402
 403         Status = AcpiHwWrite (GpeBlock->RegisterInfo[i].EnableForRun,
 404                     &GpeBlock->RegisterInfo[i].EnableAddress);
 405         if (ACPI_FAILURE (Status))
 406         {
 407             return (Status);
 408         }
 409     }
 410
 411     return (AE_OK);
 412 }
 413
 414
 415 /******************************************************************************
 416  *
 417  * FUNCTION:    AcpiHwEnableWakeupGpeBlock
 418  *
 419  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
 420  *              GpeBlock            - Gpe Block info
 421  *
 422  * RETURN:      Status
 423  *
 424  * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
 425  *              combination wake/run GPEs.
 426  *
 427  ******************************************************************************/
 428
 429 static ACPI_STATUS
 430 AcpiHwEnableWakeupGpeBlock (
 431     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
 432     ACPI_GPE_BLOCK_INFO     *GpeBlock,
 433     void                    *Context)
 434 {
 435     UINT32                  i;
 436     ACPI_STATUS             Status;
 437
 438
 439     /* Examine each GPE Register within the block */
 440
 441     for (i = 0; i < GpeBlock->RegisterCount; i++)
 442     {
 443         if (!GpeBlock->RegisterInfo[i].EnableForWake)
 444         {
 445             continue;
 446         }
 447
 448         /* Enable all "wake" GPEs in this register */
 449
 450         Status = AcpiHwWrite (GpeBlock->RegisterInfo[i].EnableForWake,
 451                     &GpeBlock->RegisterInfo[i].EnableAddress);
 452         if (ACPI_FAILURE (Status))
 453         {
 454             return (Status);
 455         }
 456     }
 457
 458     return (AE_OK);
 459 }
 460
 461
 462 /******************************************************************************
 463  *
 464  * FUNCTION:    AcpiHwDisableAllGpes
 465  *
 466  * PARAMETERS:  None
 467  *
 468  * RETURN:      Status
 469  *
 470  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
 471  *
 472  ******************************************************************************/
 473
 474 ACPI_STATUS
 475 AcpiHwDisableAllGpes (
 476     void)
 477 {
 478     ACPI_STATUS             Status;
 479
 480
 481     ACPI_FUNCTION_TRACE (HwDisableAllGpes);
 482
 483
 484     Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock, NULL);
 485     Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL);
 486     return_ACPI_STATUS (Status);
 487 }
 488
 489
 490 /******************************************************************************
 491  *
 492  * FUNCTION:    AcpiHwEnableAllRuntimeGpes
 493  *
 494  * PARAMETERS:  None
 495  *
 496  * RETURN:      Status
 497  *
 498  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
 499  *
 500  ******************************************************************************/
 501
 502 ACPI_STATUS
 503 AcpiHwEnableAllRuntimeGpes (
 504     void)
 505 {
 506     ACPI_STATUS             Status;
 507
 508
 509     ACPI_FUNCTION_TRACE (HwEnableAllRuntimeGpes);
 510
 511
 512     Status = AcpiEvWalkGpeList (AcpiHwEnableRuntimeGpeBlock, NULL);
 513     return_ACPI_STATUS (Status);
 514 }
 515
 516
 517 /******************************************************************************
 518  *
 519  * FUNCTION:    AcpiHwEnableAllWakeupGpes
 520  *
 521  * PARAMETERS:  None
 522  *
 523  * RETURN:      Status
 524  *
 525  * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
 526  *
 527  ******************************************************************************/
 528
 529 ACPI_STATUS
 530 AcpiHwEnableAllWakeupGpes (
 531     void)
 532 {
 533     ACPI_STATUS             Status;
 534
 535
 536     ACPI_FUNCTION_TRACE (HwEnableAllWakeupGpes);
 537
 538
 539     Status = AcpiEvWalkGpeList (AcpiHwEnableWakeupGpeBlock, NULL);
 540     return_ACPI_STATUS (Status);
 541 }
 542
 543 #endif /* !ACPI_REDUCED_HARDWARE */