1 /****************************************************************************** 2 * 3 * Module Name: evgpeblk - GPE block creation and initialization. 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2016, 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 #include "acpi.h" 117 #include "accommon.h" 118 #include "acevents.h" 119 #include "acnamesp.h" 120 121 #define _COMPONENT ACPI_EVENTS 122 ACPI_MODULE_NAME ("evgpeblk") 123 124 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */ 125 126 /* Local prototypes */ 127 128 static ACPI_STATUS 129 AcpiEvInstallGpeBlock ( 130 ACPI_GPE_BLOCK_INFO *GpeBlock, 131 UINT32 InterruptNumber); 132 133 static ACPI_STATUS 134 AcpiEvCreateGpeInfoBlocks ( 135 ACPI_GPE_BLOCK_INFO *GpeBlock); 136 137 138 /******************************************************************************* 139 * 140 * FUNCTION: AcpiEvInstallGpeBlock 141 * 142 * PARAMETERS: GpeBlock - New GPE block 143 * InterruptNumber - Xrupt to be associated with this 144 * GPE block 145 * 146 * RETURN: Status 147 * 148 * DESCRIPTION: Install new GPE block with mutex support 149 * 150 ******************************************************************************/ 151 152 static ACPI_STATUS 153 AcpiEvInstallGpeBlock ( 154 ACPI_GPE_BLOCK_INFO *GpeBlock, 155 UINT32 InterruptNumber) 156 { 157 ACPI_GPE_BLOCK_INFO *NextGpeBlock; 158 ACPI_GPE_XRUPT_INFO *GpeXruptBlock; 159 ACPI_STATUS Status; 160 ACPI_CPU_FLAGS Flags; 161 162 163 ACPI_FUNCTION_TRACE (EvInstallGpeBlock); 164 165 166 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS); 167 if (ACPI_FAILURE (Status)) 168 { 169 return_ACPI_STATUS (Status); 170 } 171 172 Status = AcpiEvGetGpeXruptBlock (InterruptNumber, &GpeXruptBlock); 173 if (ACPI_FAILURE (Status)) 174 { 175 goto UnlockAndExit; 176 } 177 178 /* Install the new block at the end of the list with lock */ 179 180 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock); 181 if (GpeXruptBlock->GpeBlockListHead) 182 { 183 NextGpeBlock = GpeXruptBlock->GpeBlockListHead; 184 while (NextGpeBlock->Next) 185 { 186 NextGpeBlock = NextGpeBlock->Next; 187 } 188 189 NextGpeBlock->Next = GpeBlock; 190 GpeBlock->Previous = NextGpeBlock; 191 } 192 else 193 { 194 GpeXruptBlock->GpeBlockListHead = GpeBlock; 195 } 196 197 GpeBlock->XruptBlock = GpeXruptBlock; 198 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags); 199 200 201 UnlockAndExit: 202 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS); 203 return_ACPI_STATUS (Status); 204 } 205 206 207 /******************************************************************************* 208 * 209 * FUNCTION: AcpiEvDeleteGpeBlock 210 * 211 * PARAMETERS: GpeBlock - Existing GPE block 212 * 213 * RETURN: Status 214 * 215 * DESCRIPTION: Remove a GPE block 216 * 217 ******************************************************************************/ 218 219 ACPI_STATUS 220 AcpiEvDeleteGpeBlock ( 221 ACPI_GPE_BLOCK_INFO *GpeBlock) 222 { 223 ACPI_STATUS Status; 224 ACPI_CPU_FLAGS Flags; 225 226 227 ACPI_FUNCTION_TRACE (EvInstallGpeBlock); 228 229 230 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS); 231 if (ACPI_FAILURE (Status)) 232 { 233 return_ACPI_STATUS (Status); 234 } 235 236 /* Disable all GPEs in this block */ 237 238 Status = AcpiHwDisableGpeBlock (GpeBlock->XruptBlock, GpeBlock, NULL); 239 240 if (!GpeBlock->Previous && !GpeBlock->Next) 241 { 242 /* This is the last GpeBlock on this interrupt */ 243 244 Status = AcpiEvDeleteGpeXrupt (GpeBlock->XruptBlock); 245 if (ACPI_FAILURE (Status)) 246 { 247 goto UnlockAndExit; 248 } 249 } 250 else 251 { 252 /* Remove the block on this interrupt with lock */ 253 254 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock); 255 if (GpeBlock->Previous) 256 { 257 GpeBlock->Previous->Next = GpeBlock->Next; 258 } 259 else 260 { 261 GpeBlock->XruptBlock->GpeBlockListHead = GpeBlock->Next; 262 } 263 264 if (GpeBlock->Next) 265 { 266 GpeBlock->Next->Previous = GpeBlock->Previous; 267 } 268 269 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags); 270 } 271 272 AcpiCurrentGpeCount -= GpeBlock->GpeCount; 273 274 /* Free the GpeBlock */ 275 276 ACPI_FREE (GpeBlock->RegisterInfo); 277 ACPI_FREE (GpeBlock->EventInfo); 278 ACPI_FREE (GpeBlock); 279 280 UnlockAndExit: 281 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS); 282 return_ACPI_STATUS (Status); 283 } 284 285 286 /******************************************************************************* 287 * 288 * FUNCTION: AcpiEvCreateGpeInfoBlocks 289 * 290 * PARAMETERS: GpeBlock - New GPE block 291 * 292 * RETURN: Status 293 * 294 * DESCRIPTION: Create the RegisterInfo and EventInfo blocks for this GPE block 295 * 296 ******************************************************************************/ 297 298 static ACPI_STATUS 299 AcpiEvCreateGpeInfoBlocks ( 300 ACPI_GPE_BLOCK_INFO *GpeBlock) 301 { 302 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo = NULL; 303 ACPI_GPE_EVENT_INFO *GpeEventInfo = NULL; 304 ACPI_GPE_EVENT_INFO *ThisEvent; 305 ACPI_GPE_REGISTER_INFO *ThisRegister; 306 UINT32 i; 307 UINT32 j; 308 ACPI_STATUS Status; 309 310 311 ACPI_FUNCTION_TRACE (EvCreateGpeInfoBlocks); 312 313 314 /* Allocate the GPE register information block */ 315 316 GpeRegisterInfo = ACPI_ALLOCATE_ZEROED ( 317 (ACPI_SIZE) GpeBlock->RegisterCount * 318 sizeof (ACPI_GPE_REGISTER_INFO)); 319 if (!GpeRegisterInfo) 320 { 321 ACPI_ERROR ((AE_INFO, 322 "Could not allocate the GpeRegisterInfo table")); 323 return_ACPI_STATUS (AE_NO_MEMORY); 324 } 325 326 /* 327 * Allocate the GPE EventInfo block. There are eight distinct GPEs 328 * per register. Initialization to zeros is sufficient. 329 */ 330 GpeEventInfo = ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) GpeBlock->GpeCount * 331 sizeof (ACPI_GPE_EVENT_INFO)); 332 if (!GpeEventInfo) 333 { 334 ACPI_ERROR ((AE_INFO, 335 "Could not allocate the GpeEventInfo table")); 336 Status = AE_NO_MEMORY; 337 goto ErrorExit; 338 } 339 340 /* Save the new Info arrays in the GPE block */ 341 342 GpeBlock->RegisterInfo = GpeRegisterInfo; 343 GpeBlock->EventInfo = GpeEventInfo; 344 345 /* 346 * Initialize the GPE Register and Event structures. A goal of these 347 * tables is to hide the fact that there are two separate GPE register 348 * sets in a given GPE hardware block, the status registers occupy the 349 * first half, and the enable registers occupy the second half. 350 */ 351 ThisRegister = GpeRegisterInfo; 352 ThisEvent = GpeEventInfo; 353 354 for (i = 0; i < GpeBlock->RegisterCount; i++) 355 { 356 /* Init the RegisterInfo for this GPE register (8 GPEs) */ 357 358 ThisRegister->BaseGpeNumber = (UINT16) 359 (GpeBlock->BlockBaseNumber + (i * ACPI_GPE_REGISTER_WIDTH)); 360 361 ThisRegister->StatusAddress.Address = 362 GpeBlock->Address + i; 363 364 ThisRegister->EnableAddress.Address = 365 GpeBlock->Address + i + GpeBlock->RegisterCount; 366 367 ThisRegister->StatusAddress.SpaceId = GpeBlock->SpaceId; 368 ThisRegister->EnableAddress.SpaceId = GpeBlock->SpaceId; 369 ThisRegister->StatusAddress.BitWidth = ACPI_GPE_REGISTER_WIDTH; 370 ThisRegister->EnableAddress.BitWidth = ACPI_GPE_REGISTER_WIDTH; 371 ThisRegister->StatusAddress.BitOffset = 0; 372 ThisRegister->EnableAddress.BitOffset = 0; 373 374 /* Init the EventInfo for each GPE within this register */ 375 376 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) 377 { 378 ThisEvent->GpeNumber = (UINT8) (ThisRegister->BaseGpeNumber + j); 379 ThisEvent->RegisterInfo = ThisRegister; 380 ThisEvent++; 381 } 382 383 /* Disable all GPEs within this register */ 384 385 Status = AcpiHwWrite (0x00, &ThisRegister->EnableAddress); 386 if (ACPI_FAILURE (Status)) 387 { 388 goto ErrorExit; 389 } 390 391 /* Clear any pending GPE events within this register */ 392 393 Status = AcpiHwWrite (0xFF, &ThisRegister->StatusAddress); 394 if (ACPI_FAILURE (Status)) 395 { 396 goto ErrorExit; 397 } 398 399 ThisRegister++; 400 } 401 402 return_ACPI_STATUS (AE_OK); 403 404 405 ErrorExit: 406 if (GpeRegisterInfo) 407 { 408 ACPI_FREE (GpeRegisterInfo); 409 } 410 if (GpeEventInfo) 411 { 412 ACPI_FREE (GpeEventInfo); 413 } 414 415 return_ACPI_STATUS (Status); 416 } 417 418 419 /******************************************************************************* 420 * 421 * FUNCTION: AcpiEvCreateGpeBlock 422 * 423 * PARAMETERS: GpeDevice - Handle to the parent GPE block 424 * GpeBlockAddress - Address and SpaceID 425 * RegisterCount - Number of GPE register pairs in the block 426 * GpeBlockBaseNumber - Starting GPE number for the block 427 * InterruptNumber - H/W interrupt for the block 428 * ReturnGpeBlock - Where the new block descriptor is returned 429 * 430 * RETURN: Status 431 * 432 * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within 433 * the block are disabled at exit. 434 * Note: Assumes namespace is locked. 435 * 436 ******************************************************************************/ 437 438 ACPI_STATUS 439 AcpiEvCreateGpeBlock ( 440 ACPI_NAMESPACE_NODE *GpeDevice, 441 UINT64 Address, 442 UINT8 SpaceId, 443 UINT32 RegisterCount, 444 UINT16 GpeBlockBaseNumber, 445 UINT32 InterruptNumber, 446 ACPI_GPE_BLOCK_INFO **ReturnGpeBlock) 447 { 448 ACPI_STATUS Status; 449 ACPI_GPE_BLOCK_INFO *GpeBlock; 450 ACPI_GPE_WALK_INFO WalkInfo; 451 452 453 ACPI_FUNCTION_TRACE (EvCreateGpeBlock); 454 455 456 if (!RegisterCount) 457 { 458 return_ACPI_STATUS (AE_OK); 459 } 460 461 /* Allocate a new GPE block */ 462 463 GpeBlock = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_BLOCK_INFO)); 464 if (!GpeBlock) 465 { 466 return_ACPI_STATUS (AE_NO_MEMORY); 467 } 468 469 /* Initialize the new GPE block */ 470 471 GpeBlock->Address = Address; 472 GpeBlock->SpaceId = SpaceId; 473 GpeBlock->Node = GpeDevice; 474 GpeBlock->GpeCount = (UINT16) (RegisterCount * ACPI_GPE_REGISTER_WIDTH); 475 GpeBlock->Initialized = FALSE; 476 GpeBlock->RegisterCount = RegisterCount; 477 GpeBlock->BlockBaseNumber = GpeBlockBaseNumber; 478 479 /* 480 * Create the RegisterInfo and EventInfo sub-structures 481 * Note: disables and clears all GPEs in the block 482 */ 483 Status = AcpiEvCreateGpeInfoBlocks (GpeBlock); 484 if (ACPI_FAILURE (Status)) 485 { 486 ACPI_FREE (GpeBlock); 487 return_ACPI_STATUS (Status); 488 } 489 490 /* Install the new block in the global lists */ 491 492 Status = AcpiEvInstallGpeBlock (GpeBlock, InterruptNumber); 493 if (ACPI_FAILURE (Status)) 494 { 495 ACPI_FREE (GpeBlock->RegisterInfo); 496 ACPI_FREE (GpeBlock->EventInfo); 497 ACPI_FREE (GpeBlock); 498 return_ACPI_STATUS (Status); 499 } 500 501 AcpiGbl_AllGpesInitialized = FALSE; 502 503 /* Find all GPE methods (_Lxx or_Exx) for this block */ 504 505 WalkInfo.GpeBlock = GpeBlock; 506 WalkInfo.GpeDevice = GpeDevice; 507 WalkInfo.ExecuteByOwnerId = FALSE; 508 509 Status = AcpiNsWalkNamespace (ACPI_TYPE_METHOD, GpeDevice, 510 ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK, 511 AcpiEvMatchGpeMethod, NULL, &WalkInfo, NULL); 512 513 /* Return the new block */ 514 515 if (ReturnGpeBlock) 516 { 517 (*ReturnGpeBlock) = GpeBlock; 518 } 519 520 ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, 521 " Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n", 522 (UINT32) GpeBlock->BlockBaseNumber, 523 (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)), 524 GpeDevice->Name.Ascii, GpeBlock->RegisterCount, InterruptNumber, 525 InterruptNumber == AcpiGbl_FADT.SciInterrupt ? " (SCI)" : "")); 526 527 /* Update global count of currently available GPEs */ 528 529 AcpiCurrentGpeCount += GpeBlock->GpeCount; 530 return_ACPI_STATUS (AE_OK); 531 } 532 533 534 /******************************************************************************* 535 * 536 * FUNCTION: AcpiEvInitializeGpeBlock 537 * 538 * PARAMETERS: ACPI_GPE_CALLBACK 539 * 540 * RETURN: Status 541 * 542 * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have 543 * associated methods. 544 * Note: Assumes namespace is locked. 545 * 546 ******************************************************************************/ 547 548 ACPI_STATUS 549 AcpiEvInitializeGpeBlock ( 550 ACPI_GPE_XRUPT_INFO *GpeXruptInfo, 551 ACPI_GPE_BLOCK_INFO *GpeBlock, 552 void *Ignored) 553 { 554 ACPI_STATUS Status; 555 ACPI_GPE_EVENT_INFO *GpeEventInfo; 556 UINT32 GpeEnabledCount; 557 UINT32 GpeIndex; 558 UINT32 i; 559 UINT32 j; 560 561 562 ACPI_FUNCTION_TRACE (EvInitializeGpeBlock); 563 564 565 /* 566 * Ignore a null GPE block (e.g., if no GPE block 1 exists), and 567 * any GPE blocks that have been initialized already. 568 */ 569 if (!GpeBlock || GpeBlock->Initialized) 570 { 571 return_ACPI_STATUS (AE_OK); 572 } 573 574 /* 575 * Enable all GPEs that have a corresponding method and have the 576 * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block 577 * must be enabled via the acpi_enable_gpe() interface. 578 */ 579 GpeEnabledCount = 0; 580 581 for (i = 0; i < GpeBlock->RegisterCount; i++) 582 { 583 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) 584 { 585 /* Get the info block for this particular GPE */ 586 587 GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j; 588 GpeEventInfo = &GpeBlock->EventInfo[GpeIndex]; 589 590 /* 591 * Ignore GPEs that have no corresponding _Lxx/_Exx method 592 * and GPEs that are used to wake the system 593 */ 594 if ((ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_NONE) || 595 (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_HANDLER) || 596 (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) == ACPI_GPE_DISPATCH_RAW_HANDLER) || 597 (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE)) 598 { 599 continue; 600 } 601 602 Status = AcpiEvAddGpeReference (GpeEventInfo); 603 if (ACPI_FAILURE (Status)) 604 { 605 ACPI_EXCEPTION ((AE_INFO, Status, 606 "Could not enable GPE 0x%02X", 607 GpeIndex + GpeBlock->BlockBaseNumber)); 608 continue; 609 } 610 611 GpeEnabledCount++; 612 } 613 } 614 615 if (GpeEnabledCount) 616 { 617 ACPI_INFO ((AE_INFO, 618 "Enabled %u GPEs in block %02X to %02X", GpeEnabledCount, 619 (UINT32) GpeBlock->BlockBaseNumber, 620 (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)))); 621 } 622 623 GpeBlock->Initialized = TRUE; 624 return_ACPI_STATUS (AE_OK); 625 } 626 627 #endif /* !ACPI_REDUCED_HARDWARE */ 628