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