drivers/acpi/acpica/hwgpe.c

   1 /******************************************************************************
   2  *
   3  * Module Name: hwgpe - Low level GPE enable/disable/clear functions
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, 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/acpi.h>
  45 #include "accommon.h"
  46 #include "acevents.h"
  47
  48 #define _COMPONENT          ACPI_HARDWARE
  49 ACPI_MODULE_NAME("hwgpe")
  50 #if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
  51 /* Local prototypes */
  52 static acpi_status
  53 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
  54                                 struct acpi_gpe_block_info *gpe_block,
  55                                 void *context);
  56
  57 /******************************************************************************
  58  *
  59  * FUNCTION:    acpi_hw_get_gpe_register_bit
  60  *
  61  * PARAMETERS:  gpe_event_info      - Info block for the GPE
  62  *
  63  * RETURN:      Register mask with a one in the GPE bit position
  64  *
  65  * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
  66  *              correct position for the input GPE.
  67  *
  68  ******************************************************************************/
  69
  70 u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info)
  71 {
  72
  73         return ((u32)1 <<
  74                 (gpe_event_info->gpe_number -
  75                  gpe_event_info->register_info->base_gpe_number));
  76 }
  77
  78 /******************************************************************************
  79  *
  80  * FUNCTION:    acpi_hw_low_set_gpe
  81  *
  82  * PARAMETERS:  gpe_event_info      - Info block for the GPE to be disabled
  83  *              action              - Enable or disable
  84  *
  85  * RETURN:      Status
  86  *
  87  * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
  88  *
  89  ******************************************************************************/
  90
  91 acpi_status
  92 acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
  93 {
  94         struct acpi_gpe_register_info *gpe_register_info;
  95         acpi_status status;
  96         u32 enable_mask;
  97         u32 register_bit;
  98
  99         ACPI_FUNCTION_ENTRY();
 100
 101         /* Get the info block for the entire GPE register */
 102
 103         gpe_register_info = gpe_event_info->register_info;
 104         if (!gpe_register_info) {
 105                 return (AE_NOT_EXIST);
 106         }
 107
 108         /* Get current value of the enable register that contains this GPE */
 109
 110         status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address);
 111         if (ACPI_FAILURE(status)) {
 112                 return (status);
 113         }
 114
 115         /* Set or clear just the bit that corresponds to this GPE */
 116
 117         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
 118         switch (action) {
 119         case ACPI_GPE_CONDITIONAL_ENABLE:
 120
 121                 /* Only enable if the enable_for_run bit is set */
 122
 123                 if (!(register_bit & gpe_register_info->enable_for_run)) {
 124                         return (AE_BAD_PARAMETER);
 125                 }
 126
 127                 /*lint -fallthrough */
 128
 129         case ACPI_GPE_ENABLE:
 130
 131                 ACPI_SET_BIT(enable_mask, register_bit);
 132                 break;
 133
 134         case ACPI_GPE_DISABLE:
 135
 136                 ACPI_CLEAR_BIT(enable_mask, register_bit);
 137                 break;
 138
 139         default:
 140
 141                 ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u", action));
 142                 return (AE_BAD_PARAMETER);
 143         }
 144
 145         /* Write the updated enable mask */
 146
 147         status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
 148         return (status);
 149 }
 150
 151 /******************************************************************************
 152  *
 153  * FUNCTION:    acpi_hw_clear_gpe
 154  *
 155  * PARAMETERS:  gpe_event_info      - Info block for the GPE to be cleared
 156  *
 157  * RETURN:      Status
 158  *
 159  * DESCRIPTION: Clear the status bit for a single GPE.
 160  *
 161  ******************************************************************************/
 162
 163 acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
 164 {
 165         struct acpi_gpe_register_info *gpe_register_info;
 166         acpi_status status;
 167         u32 register_bit;
 168
 169         ACPI_FUNCTION_ENTRY();
 170
 171         /* Get the info block for the entire GPE register */
 172
 173         gpe_register_info = gpe_event_info->register_info;
 174         if (!gpe_register_info) {
 175                 return (AE_NOT_EXIST);
 176         }
 177
 178         /*
 179          * Write a one to the appropriate bit in the status register to
 180          * clear this GPE.
 181          */
 182         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
 183
 184         status = acpi_hw_write(register_bit,
 185                                &gpe_register_info->status_address);
 186
 187         return (status);
 188 }
 189
 190 /******************************************************************************
 191  *
 192  * FUNCTION:    acpi_hw_get_gpe_status
 193  *
 194  * PARAMETERS:  gpe_event_info      - Info block for the GPE to queried
 195  *              event_status        - Where the GPE status is returned
 196  *
 197  * RETURN:      Status
 198  *
 199  * DESCRIPTION: Return the status of a single GPE.
 200  *
 201  ******************************************************************************/
 202
 203 acpi_status
 204 acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
 205                        acpi_event_status *event_status)
 206 {
 207         u32 in_byte;
 208         u32 register_bit;
 209         struct acpi_gpe_register_info *gpe_register_info;
 210         acpi_event_status local_event_status = 0;
 211         acpi_status status;
 212
 213         ACPI_FUNCTION_ENTRY();
 214
 215         if (!event_status) {
 216                 return (AE_BAD_PARAMETER);
 217         }
 218
 219         /* GPE currently handled? */
 220
 221         if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) !=
 222             ACPI_GPE_DISPATCH_NONE) {
 223                 local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
 224         }
 225
 226         /* Get the info block for the entire GPE register */
 227
 228         gpe_register_info = gpe_event_info->register_info;
 229
 230         /* Get the register bitmask for this GPE */
 231
 232         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
 233
 234         /* GPE currently enabled? (enabled for runtime?) */
 235
 236         if (register_bit & gpe_register_info->enable_for_run) {
 237                 local_event_status |= ACPI_EVENT_FLAG_ENABLED;
 238         }
 239
 240         /* GPE enabled for wake? */
 241
 242         if (register_bit & gpe_register_info->enable_for_wake) {
 243                 local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
 244         }
 245
 246         /* GPE currently active (status bit == 1)? */
 247
 248         status = acpi_hw_read(&in_byte, &gpe_register_info->status_address);
 249         if (ACPI_FAILURE(status)) {
 250                 return (status);
 251         }
 252
 253         if (register_bit & in_byte) {
 254                 local_event_status |= ACPI_EVENT_FLAG_SET;
 255         }
 256
 257         /* Set return value */
 258
 259         (*event_status) = local_event_status;
 260         return (AE_OK);
 261 }
 262
 263 /******************************************************************************
 264  *
 265  * FUNCTION:    acpi_hw_disable_gpe_block
 266  *
 267  * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 268  *              gpe_block           - Gpe Block info
 269  *
 270  * RETURN:      Status
 271  *
 272  * DESCRIPTION: Disable all GPEs within a single GPE block
 273  *
 274  ******************************************************************************/
 275
 276 acpi_status
 277 acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 278                           struct acpi_gpe_block_info *gpe_block, void *context)
 279 {
 280         u32 i;
 281         acpi_status status;
 282
 283         /* Examine each GPE Register within the block */
 284
 285         for (i = 0; i < gpe_block->register_count; i++) {
 286
 287                 /* Disable all GPEs in this register */
 288
 289                 status =
 290                     acpi_hw_write(0x00,
 291                                   &gpe_block->register_info[i].enable_address);
 292                 if (ACPI_FAILURE(status)) {
 293                         return (status);
 294                 }
 295         }
 296
 297         return (AE_OK);
 298 }
 299
 300 /******************************************************************************
 301  *
 302  * FUNCTION:    acpi_hw_clear_gpe_block
 303  *
 304  * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 305  *              gpe_block           - Gpe Block info
 306  *
 307  * RETURN:      Status
 308  *
 309  * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
 310  *
 311  ******************************************************************************/
 312
 313 acpi_status
 314 acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 315                         struct acpi_gpe_block_info *gpe_block, void *context)
 316 {
 317         u32 i;
 318         acpi_status status;
 319
 320         /* Examine each GPE Register within the block */
 321
 322         for (i = 0; i < gpe_block->register_count; i++) {
 323
 324                 /* Clear status on all GPEs in this register */
 325
 326                 status =
 327                     acpi_hw_write(0xFF,
 328                                   &gpe_block->register_info[i].status_address);
 329                 if (ACPI_FAILURE(status)) {
 330                         return (status);
 331                 }
 332         }
 333
 334         return (AE_OK);
 335 }
 336
 337 /******************************************************************************
 338  *
 339  * FUNCTION:    acpi_hw_enable_runtime_gpe_block
 340  *
 341  * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 342  *              gpe_block           - Gpe Block info
 343  *
 344  * RETURN:      Status
 345  *
 346  * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
 347  *              combination wake/run GPEs.
 348  *
 349  ******************************************************************************/
 350
 351 acpi_status
 352 acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 353                                  struct acpi_gpe_block_info * gpe_block,
 354                                  void *context)
 355 {
 356         u32 i;
 357         acpi_status status;
 358
 359         /* NOTE: assumes that all GPEs are currently disabled */
 360
 361         /* Examine each GPE Register within the block */
 362
 363         for (i = 0; i < gpe_block->register_count; i++) {
 364                 if (!gpe_block->register_info[i].enable_for_run) {
 365                         continue;
 366                 }
 367
 368                 /* Enable all "runtime" GPEs in this register */
 369
 370                 status =
 371                     acpi_hw_write(gpe_block->register_info[i].enable_for_run,
 372                                   &gpe_block->register_info[i].enable_address);
 373                 if (ACPI_FAILURE(status)) {
 374                         return (status);
 375                 }
 376         }
 377
 378         return (AE_OK);
 379 }
 380
 381 /******************************************************************************
 382  *
 383  * FUNCTION:    acpi_hw_enable_wakeup_gpe_block
 384  *
 385  * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 386  *              gpe_block           - Gpe Block info
 387  *
 388  * RETURN:      Status
 389  *
 390  * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
 391  *              combination wake/run GPEs.
 392  *
 393  ******************************************************************************/
 394
 395 static acpi_status
 396 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 397                                 struct acpi_gpe_block_info *gpe_block,
 398                                 void *context)
 399 {
 400         u32 i;
 401         acpi_status status;
 402
 403         /* Examine each GPE Register within the block */
 404
 405         for (i = 0; i < gpe_block->register_count; i++) {
 406
 407                 /*
 408                  * Enable all "wake" GPEs in this register and disable the
 409                  * remaining ones.
 410                  */
 411
 412                 status =
 413                     acpi_hw_write(gpe_block->register_info[i].enable_for_wake,
 414                                   &gpe_block->register_info[i].enable_address);
 415                 if (ACPI_FAILURE(status)) {
 416                         return (status);
 417                 }
 418         }
 419
 420         return (AE_OK);
 421 }
 422
 423 /******************************************************************************
 424  *
 425  * FUNCTION:    acpi_hw_disable_all_gpes
 426  *
 427  * PARAMETERS:  None
 428  *
 429  * RETURN:      Status
 430  *
 431  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
 432  *
 433  ******************************************************************************/
 434
 435 acpi_status acpi_hw_disable_all_gpes(void)
 436 {
 437         acpi_status status;
 438
 439         ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
 440
 441         status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
 442         status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
 443         return_ACPI_STATUS(status);
 444 }
 445
 446 /******************************************************************************
 447  *
 448  * FUNCTION:    acpi_hw_enable_all_runtime_gpes
 449  *
 450  * PARAMETERS:  None
 451  *
 452  * RETURN:      Status
 453  *
 454  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
 455  *
 456  ******************************************************************************/
 457
 458 acpi_status acpi_hw_enable_all_runtime_gpes(void)
 459 {
 460         acpi_status status;
 461
 462         ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
 463
 464         status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
 465         return_ACPI_STATUS(status);
 466 }
 467
 468 /******************************************************************************
 469  *
 470  * FUNCTION:    acpi_hw_enable_all_wakeup_gpes
 471  *
 472  * PARAMETERS:  None
 473  *
 474  * RETURN:      Status
 475  *
 476  * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
 477  *
 478  ******************************************************************************/
 479
 480 acpi_status acpi_hw_enable_all_wakeup_gpes(void)
 481 {
 482         acpi_status status;
 483
 484         ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
 485
 486         status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
 487         return_ACPI_STATUS(status);
 488 }
 489
 490 #endif                          /* !ACPI_REDUCED_HARDWARE */