1 /******************************************************************************* 2 * 3 * Module Name: hwregs - Read/write access functions for the various ACPI 4 * control and status registers. 5 * 6 ******************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2016, 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 ("hwregs") 51 52 53 #if (!ACPI_REDUCED_HARDWARE) 54 55 /* Local Prototypes */ 56 57 static UINT8 58 AcpiHwGetAccessBitWidth ( 59 UINT64 Address, 60 ACPI_GENERIC_ADDRESS *Reg, 61 UINT8 MaxBitWidth); 62 63 static ACPI_STATUS 64 AcpiHwReadMultiple ( 65 UINT32 *Value, 66 ACPI_GENERIC_ADDRESS *RegisterA, 67 ACPI_GENERIC_ADDRESS *RegisterB); 68 69 static ACPI_STATUS 70 AcpiHwWriteMultiple ( 71 UINT32 Value, 72 ACPI_GENERIC_ADDRESS *RegisterA, 73 ACPI_GENERIC_ADDRESS *RegisterB); 74 75 #endif /* !ACPI_REDUCED_HARDWARE */ 76 77 78 /****************************************************************************** 79 * 80 * FUNCTION: AcpiHwGetAccessBitWidth 81 * 82 * PARAMETERS: Address - GAS register address 83 * Reg - GAS register structure 84 * MaxBitWidth - Max BitWidth supported (32 or 64) 85 * 86 * RETURN: Status 87 * 88 * DESCRIPTION: Obtain optimal access bit width 89 * 90 ******************************************************************************/ 91 92 static UINT8 93 AcpiHwGetAccessBitWidth ( 94 UINT64 Address, 95 ACPI_GENERIC_ADDRESS *Reg, 96 UINT8 MaxBitWidth) 97 { 98 UINT8 AccessBitWidth; 99 100 101 /* 102 * GAS format "register", used by FADT: 103 * 1. Detected if BitOffset is 0 and BitWidth is 8/16/32/64; 104 * 2. AccessSize field is ignored and BitWidth field is used for 105 * determining the boundary of the IO accesses. 106 * GAS format "region", used by APEI registers: 107 * 1. Detected if BitOffset is not 0 or BitWidth is not 8/16/32/64; 108 * 2. AccessSize field is used for determining the boundary of the 109 * IO accesses; 110 * 3. BitOffset/BitWidth fields are used to describe the "region". 111 * 112 * Note: This algorithm assumes that the "Address" fields should always 113 * contain aligned values. 114 */ 115 if (!Reg->BitOffset && Reg->BitWidth && 116 ACPI_IS_POWER_OF_TWO (Reg->BitWidth) && 117 ACPI_IS_ALIGNED (Reg->BitWidth, 8)) 118 { 119 AccessBitWidth = Reg->BitWidth; 120 } 121 else if (Reg->AccessWidth) 122 { 123 AccessBitWidth = (1 << (Reg->AccessWidth + 2)); 124 } 125 else 126 { 127 AccessBitWidth = ACPI_ROUND_UP_POWER_OF_TWO_8 ( 128 Reg->BitOffset + Reg->BitWidth); 129 if (AccessBitWidth <= 8) 130 { 131 AccessBitWidth = 8; 132 } 133 else 134 { 135 while (!ACPI_IS_ALIGNED (Address, AccessBitWidth >> 3)) 136 { 137 AccessBitWidth >>= 1; 138 } 139 } 140 } 141 142 /* Maximum IO port access bit width is 32 */ 143 144 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_IO) 145 { 146 MaxBitWidth = 32; 147 } 148 149 /* 150 * Return access width according to the requested maximum access bit width, 151 * as the caller should know the format of the register and may enforce 152 * a 32-bit accesses. 153 */ 154 if (AccessBitWidth < MaxBitWidth) 155 { 156 return (AccessBitWidth); 157 } 158 return (MaxBitWidth); 159 } 160 161 162 /****************************************************************************** 163 * 164 * FUNCTION: AcpiHwValidateRegister 165 * 166 * PARAMETERS: Reg - GAS register structure 167 * MaxBitWidth - Max BitWidth supported (32 or 64) 168 * Address - Pointer to where the gas->address 169 * is returned 170 * 171 * RETURN: Status 172 * 173 * DESCRIPTION: Validate the contents of a GAS register. Checks the GAS 174 * pointer, Address, SpaceId, BitWidth, and BitOffset. 175 * 176 ******************************************************************************/ 177 178 ACPI_STATUS 179 AcpiHwValidateRegister ( 180 ACPI_GENERIC_ADDRESS *Reg, 181 UINT8 MaxBitWidth, 182 UINT64 *Address) 183 { 184 UINT8 BitWidth; 185 UINT8 AccessWidth; 186 187 188 /* Must have a valid pointer to a GAS structure */ 189 190 if (!Reg) 191 { 192 return (AE_BAD_PARAMETER); 193 } 194 195 /* 196 * Copy the target address. This handles possible alignment issues. 197 * Address must not be null. A null address also indicates an optional 198 * ACPI register that is not supported, so no error message. 199 */ 200 ACPI_MOVE_64_TO_64 (Address, &Reg->Address); 201 if (!(*Address)) 202 { 203 return (AE_BAD_ADDRESS); 204 } 205 206 /* Validate the SpaceID */ 207 208 if ((Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) && 209 (Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_IO)) 210 { 211 ACPI_ERROR ((AE_INFO, 212 "Unsupported address space: 0x%X", Reg->SpaceId)); 213 return (AE_SUPPORT); 214 } 215 216 /* Validate the AccessWidth */ 217 218 if (Reg->AccessWidth > 4) 219 { 220 ACPI_ERROR ((AE_INFO, 221 "Unsupported register access width: 0x%X", Reg->AccessWidth)); 222 return (AE_SUPPORT); 223 } 224 225 /* Validate the BitWidth, convert AccessWidth into number of bits */ 226 227 AccessWidth = AcpiHwGetAccessBitWidth (*Address, Reg, MaxBitWidth); 228 BitWidth = ACPI_ROUND_UP (Reg->BitOffset + Reg->BitWidth, AccessWidth); 229 if (MaxBitWidth < BitWidth) 230 { 231 ACPI_WARNING ((AE_INFO, 232 "Requested bit width 0x%X is smaller than register bit width 0x%X", 233 MaxBitWidth, BitWidth)); 234 return (AE_SUPPORT); 235 } 236 237 return (AE_OK); 238 } 239 240 241 /****************************************************************************** 242 * 243 * FUNCTION: AcpiHwRead 244 * 245 * PARAMETERS: Value - Where the value is returned 246 * Reg - GAS register structure 247 * 248 * RETURN: Status 249 * 250 * DESCRIPTION: Read from either memory or IO space. This is a 32-bit max 251 * version of AcpiRead, used internally since the overhead of 252 * 64-bit values is not needed. 253 * 254 * LIMITATIONS: <These limitations also apply to AcpiHwWrite> 255 * SpaceID must be SystemMemory or SystemIO. 256 * 257 ******************************************************************************/ 258 259 ACPI_STATUS 260 AcpiHwRead ( 261 UINT32 *Value, 262 ACPI_GENERIC_ADDRESS *Reg) 263 { 264 UINT64 Address; 265 UINT8 AccessWidth; 266 UINT32 BitWidth; 267 UINT8 BitOffset; 268 UINT64 Value64; 269 UINT32 Value32; 270 UINT8 Index; 271 ACPI_STATUS Status; 272 273 274 ACPI_FUNCTION_NAME (HwRead); 275 276 277 /* Validate contents of the GAS register */ 278 279 Status = AcpiHwValidateRegister (Reg, 32, &Address); 280 if (ACPI_FAILURE (Status)) 281 { 282 return (Status); 283 } 284 285 /* 286 * Initialize entire 32-bit return value to zero, convert AccessWidth 287 * into number of bits based 288 */ 289 *Value = 0; 290 AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32); 291 BitWidth = Reg->BitOffset + Reg->BitWidth; 292 BitOffset = Reg->BitOffset; 293 294 /* 295 * Two address spaces supported: Memory or IO. PCI_Config is 296 * not supported here because the GAS structure is insufficient 297 */ 298 Index = 0; 299 while (BitWidth) 300 { 301 if (BitOffset >= AccessWidth) 302 { 303 Value32 = 0; 304 BitOffset -= AccessWidth; 305 } 306 else 307 { 308 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY) 309 { 310 Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS) 311 Address + Index * ACPI_DIV_8 (AccessWidth), 312 &Value64, AccessWidth); 313 Value32 = (UINT32) Value64; 314 } 315 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */ 316 { 317 Status = AcpiHwReadPort ((ACPI_IO_ADDRESS) 318 Address + Index * ACPI_DIV_8 (AccessWidth), 319 &Value32, AccessWidth); 320 } 321 } 322 323 /* 324 * Use offset style bit writes because "Index * AccessWidth" is 325 * ensured to be less than 32-bits by AcpiHwValidateRegister(). 326 */ 327 ACPI_SET_BITS (Value, Index * AccessWidth, 328 ACPI_MASK_BITS_ABOVE_32 (AccessWidth), Value32); 329 330 BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth; 331 Index++; 332 } 333 334 ACPI_DEBUG_PRINT ((ACPI_DB_IO, 335 "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n", 336 *Value, AccessWidth, ACPI_FORMAT_UINT64 (Address), 337 AcpiUtGetRegionName (Reg->SpaceId))); 338 339 return (Status); 340 } 341 342 343 /****************************************************************************** 344 * 345 * FUNCTION: AcpiHwWrite 346 * 347 * PARAMETERS: Value - Value to be written 348 * Reg - GAS register structure 349 * 350 * RETURN: Status 351 * 352 * DESCRIPTION: Write to either memory or IO space. This is a 32-bit max 353 * version of AcpiWrite, used internally since the overhead of 354 * 64-bit values is not needed. 355 * 356 ******************************************************************************/ 357 358 ACPI_STATUS 359 AcpiHwWrite ( 360 UINT32 Value, 361 ACPI_GENERIC_ADDRESS *Reg) 362 { 363 UINT64 Address; 364 UINT8 AccessWidth; 365 UINT32 BitWidth; 366 UINT8 BitOffset; 367 UINT64 Value64; 368 UINT32 Value32; 369 UINT8 Index; 370 ACPI_STATUS Status; 371 372 373 ACPI_FUNCTION_NAME (HwWrite); 374 375 376 /* Validate contents of the GAS register */ 377 378 Status = AcpiHwValidateRegister (Reg, 32, &Address); 379 if (ACPI_FAILURE (Status)) 380 { 381 return (Status); 382 } 383 384 /* Convert AccessWidth into number of bits based */ 385 386 AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32); 387 BitWidth = Reg->BitOffset + Reg->BitWidth; 388 BitOffset = Reg->BitOffset; 389 390 /* 391 * Two address spaces supported: Memory or IO. PCI_Config is 392 * not supported here because the GAS structure is insufficient 393 */ 394 Index = 0; 395 while (BitWidth) 396 { 397 /* 398 * Use offset style bit reads because "Index * AccessWidth" is 399 * ensured to be less than 32-bits by AcpiHwValidateRegister(). 400 */ 401 Value32 = ACPI_GET_BITS (&Value, Index * AccessWidth, 402 ACPI_MASK_BITS_ABOVE_32 (AccessWidth)); 403 404 if (BitOffset >= AccessWidth) 405 { 406 BitOffset -= AccessWidth; 407 } 408 else 409 { 410 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY) 411 { 412 Value64 = (UINT64) Value32; 413 Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS) 414 Address + Index * ACPI_DIV_8 (AccessWidth), 415 Value64, AccessWidth); 416 } 417 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */ 418 { 419 Status = AcpiHwWritePort ((ACPI_IO_ADDRESS) 420 Address + Index * ACPI_DIV_8 (AccessWidth), 421 Value32, AccessWidth); 422 } 423 } 424 425 /* 426 * Index * AccessWidth is ensured to be less than 32-bits by 427 * AcpiHwValidateRegister(). 428 */ 429 BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth; 430 Index++; 431 } 432 433 ACPI_DEBUG_PRINT ((ACPI_DB_IO, 434 "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n", 435 Value, AccessWidth, ACPI_FORMAT_UINT64 (Address), 436 AcpiUtGetRegionName (Reg->SpaceId))); 437 438 return (Status); 439 } 440 441 442 #if (!ACPI_REDUCED_HARDWARE) 443 /******************************************************************************* 444 * 445 * FUNCTION: AcpiHwClearAcpiStatus 446 * 447 * PARAMETERS: None 448 * 449 * RETURN: Status 450 * 451 * DESCRIPTION: Clears all fixed and general purpose status bits 452 * 453 ******************************************************************************/ 454 455 ACPI_STATUS 456 AcpiHwClearAcpiStatus ( 457 void) 458 { 459 ACPI_STATUS Status; 460 ACPI_CPU_FLAGS LockFlags = 0; 461 462 463 ACPI_FUNCTION_TRACE (HwClearAcpiStatus); 464 465 466 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n", 467 ACPI_BITMASK_ALL_FIXED_STATUS, 468 ACPI_FORMAT_UINT64 (AcpiGbl_XPm1aStatus.Address))); 469 470 LockFlags = AcpiOsAcquireLock (AcpiGbl_HardwareLock); 471 472 /* Clear the fixed events in PM1 A/B */ 473 474 Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_STATUS, 475 ACPI_BITMASK_ALL_FIXED_STATUS); 476 477 AcpiOsReleaseLock (AcpiGbl_HardwareLock, LockFlags); 478 479 if (ACPI_FAILURE (Status)) 480 { 481 goto Exit; 482 } 483 484 /* Clear the GPE Bits in all GPE registers in all GPE blocks */ 485 486 Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL); 487 488 Exit: 489 return_ACPI_STATUS (Status); 490 } 491 492 493 /******************************************************************************* 494 * 495 * FUNCTION: AcpiHwGetBitRegisterInfo 496 * 497 * PARAMETERS: RegisterId - Index of ACPI Register to access 498 * 499 * RETURN: The bitmask to be used when accessing the register 500 * 501 * DESCRIPTION: Map RegisterId into a register bitmask. 502 * 503 ******************************************************************************/ 504 505 ACPI_BIT_REGISTER_INFO * 506 AcpiHwGetBitRegisterInfo ( 507 UINT32 RegisterId) 508 { 509 ACPI_FUNCTION_ENTRY (); 510 511 512 if (RegisterId > ACPI_BITREG_MAX) 513 { 514 ACPI_ERROR ((AE_INFO, "Invalid BitRegister ID: 0x%X", RegisterId)); 515 return (NULL); 516 } 517 518 return (&AcpiGbl_BitRegisterInfo[RegisterId]); 519 } 520 521 522 /****************************************************************************** 523 * 524 * FUNCTION: AcpiHwWritePm1Control 525 * 526 * PARAMETERS: Pm1aControl - Value to be written to PM1A control 527 * Pm1bControl - Value to be written to PM1B control 528 * 529 * RETURN: Status 530 * 531 * DESCRIPTION: Write the PM1 A/B control registers. These registers are 532 * different than than the PM1 A/B status and enable registers 533 * in that different values can be written to the A/B registers. 534 * Most notably, the SLP_TYP bits can be different, as per the 535 * values returned from the _Sx predefined methods. 536 * 537 ******************************************************************************/ 538 539 ACPI_STATUS 540 AcpiHwWritePm1Control ( 541 UINT32 Pm1aControl, 542 UINT32 Pm1bControl) 543 { 544 ACPI_STATUS Status; 545 546 547 ACPI_FUNCTION_TRACE (HwWritePm1Control); 548 549 550 Status = AcpiHwWrite (Pm1aControl, &AcpiGbl_FADT.XPm1aControlBlock); 551 if (ACPI_FAILURE (Status)) 552 { 553 return_ACPI_STATUS (Status); 554 } 555 556 if (AcpiGbl_FADT.XPm1bControlBlock.Address) 557 { 558 Status = AcpiHwWrite (Pm1bControl, &AcpiGbl_FADT.XPm1bControlBlock); 559 } 560 return_ACPI_STATUS (Status); 561 } 562 563 564 /****************************************************************************** 565 * 566 * FUNCTION: AcpiHwRegisterRead 567 * 568 * PARAMETERS: RegisterId - ACPI Register ID 569 * ReturnValue - Where the register value is returned 570 * 571 * RETURN: Status and the value read. 572 * 573 * DESCRIPTION: Read from the specified ACPI register 574 * 575 ******************************************************************************/ 576 577 ACPI_STATUS 578 AcpiHwRegisterRead ( 579 UINT32 RegisterId, 580 UINT32 *ReturnValue) 581 { 582 UINT32 Value = 0; 583 ACPI_STATUS Status; 584 585 586 ACPI_FUNCTION_TRACE (HwRegisterRead); 587 588 589 switch (RegisterId) 590 { 591 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */ 592 593 Status = AcpiHwReadMultiple (&Value, 594 &AcpiGbl_XPm1aStatus, 595 &AcpiGbl_XPm1bStatus); 596 break; 597 598 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */ 599 600 Status = AcpiHwReadMultiple (&Value, 601 &AcpiGbl_XPm1aEnable, 602 &AcpiGbl_XPm1bEnable); 603 break; 604 605 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */ 606 607 Status = AcpiHwReadMultiple (&Value, 608 &AcpiGbl_FADT.XPm1aControlBlock, 609 &AcpiGbl_FADT.XPm1bControlBlock); 610 611 /* 612 * Zero the write-only bits. From the ACPI specification, "Hardware 613 * Write-Only Bits": "Upon reads to registers with write-only bits, 614 * software masks out all write-only bits." 615 */ 616 Value &= ~ACPI_PM1_CONTROL_WRITEONLY_BITS; 617 break; 618 619 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ 620 621 Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPm2ControlBlock); 622 break; 623 624 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ 625 626 Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPmTimerBlock); 627 break; 628 629 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ 630 631 Status = AcpiHwReadPort (AcpiGbl_FADT.SmiCommand, &Value, 8); 632 break; 633 634 default: 635 636 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X", 637 RegisterId)); 638 Status = AE_BAD_PARAMETER; 639 break; 640 } 641 642 if (ACPI_SUCCESS (Status)) 643 { 644 *ReturnValue = Value; 645 } 646 647 return_ACPI_STATUS (Status); 648 } 649 650 651 /****************************************************************************** 652 * 653 * FUNCTION: AcpiHwRegisterWrite 654 * 655 * PARAMETERS: RegisterId - ACPI Register ID 656 * Value - The value to write 657 * 658 * RETURN: Status 659 * 660 * DESCRIPTION: Write to the specified ACPI register 661 * 662 * NOTE: In accordance with the ACPI specification, this function automatically 663 * preserves the value of the following bits, meaning that these bits cannot be 664 * changed via this interface: 665 * 666 * PM1_CONTROL[0] = SCI_EN 667 * PM1_CONTROL[9] 668 * PM1_STATUS[11] 669 * 670 * ACPI References: 671 * 1) Hardware Ignored Bits: When software writes to a register with ignored 672 * bit fields, it preserves the ignored bit fields 673 * 2) SCI_EN: OSPM always preserves this bit position 674 * 675 ******************************************************************************/ 676 677 ACPI_STATUS 678 AcpiHwRegisterWrite ( 679 UINT32 RegisterId, 680 UINT32 Value) 681 { 682 ACPI_STATUS Status; 683 UINT32 ReadValue; 684 685 686 ACPI_FUNCTION_TRACE (HwRegisterWrite); 687 688 689 switch (RegisterId) 690 { 691 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */ 692 /* 693 * Handle the "ignored" bit in PM1 Status. According to the ACPI 694 * specification, ignored bits are to be preserved when writing. 695 * Normally, this would mean a read/modify/write sequence. However, 696 * preserving a bit in the status register is different. Writing a 697 * one clears the status, and writing a zero preserves the status. 698 * Therefore, we must always write zero to the ignored bit. 699 * 700 * This behavior is clarified in the ACPI 4.0 specification. 701 */ 702 Value &= ~ACPI_PM1_STATUS_PRESERVED_BITS; 703 704 Status = AcpiHwWriteMultiple (Value, 705 &AcpiGbl_XPm1aStatus, 706 &AcpiGbl_XPm1bStatus); 707 break; 708 709 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */ 710 711 Status = AcpiHwWriteMultiple (Value, 712 &AcpiGbl_XPm1aEnable, 713 &AcpiGbl_XPm1bEnable); 714 break; 715 716 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */ 717 /* 718 * Perform a read first to preserve certain bits (per ACPI spec) 719 * Note: This includes SCI_EN, we never want to change this bit 720 */ 721 Status = AcpiHwReadMultiple (&ReadValue, 722 &AcpiGbl_FADT.XPm1aControlBlock, 723 &AcpiGbl_FADT.XPm1bControlBlock); 724 if (ACPI_FAILURE (Status)) 725 { 726 goto Exit; 727 } 728 729 /* Insert the bits to be preserved */ 730 731 ACPI_INSERT_BITS (Value, ACPI_PM1_CONTROL_PRESERVED_BITS, ReadValue); 732 733 /* Now we can write the data */ 734 735 Status = AcpiHwWriteMultiple (Value, 736 &AcpiGbl_FADT.XPm1aControlBlock, 737 &AcpiGbl_FADT.XPm1bControlBlock); 738 break; 739 740 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ 741 /* 742 * For control registers, all reserved bits must be preserved, 743 * as per the ACPI spec. 744 */ 745 Status = AcpiHwRead (&ReadValue, &AcpiGbl_FADT.XPm2ControlBlock); 746 if (ACPI_FAILURE (Status)) 747 { 748 goto Exit; 749 } 750 751 /* Insert the bits to be preserved */ 752 753 ACPI_INSERT_BITS (Value, ACPI_PM2_CONTROL_PRESERVED_BITS, ReadValue); 754 755 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPm2ControlBlock); 756 break; 757 758 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ 759 760 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPmTimerBlock); 761 break; 762 763 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ 764 765 /* SMI_CMD is currently always in IO space */ 766 767 Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand, Value, 8); 768 break; 769 770 default: 771 772 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X", 773 RegisterId)); 774 Status = AE_BAD_PARAMETER; 775 break; 776 } 777 778 Exit: 779 return_ACPI_STATUS (Status); 780 } 781 782 783 /****************************************************************************** 784 * 785 * FUNCTION: AcpiHwReadMultiple 786 * 787 * PARAMETERS: Value - Where the register value is returned 788 * RegisterA - First ACPI register (required) 789 * RegisterB - Second ACPI register (optional) 790 * 791 * RETURN: Status 792 * 793 * DESCRIPTION: Read from the specified two-part ACPI register (such as PM1 A/B) 794 * 795 ******************************************************************************/ 796 797 static ACPI_STATUS 798 AcpiHwReadMultiple ( 799 UINT32 *Value, 800 ACPI_GENERIC_ADDRESS *RegisterA, 801 ACPI_GENERIC_ADDRESS *RegisterB) 802 { 803 UINT32 ValueA = 0; 804 UINT32 ValueB = 0; 805 ACPI_STATUS Status; 806 807 808 /* The first register is always required */ 809 810 Status = AcpiHwRead (&ValueA, RegisterA); 811 if (ACPI_FAILURE (Status)) 812 { 813 return (Status); 814 } 815 816 /* Second register is optional */ 817 818 if (RegisterB->Address) 819 { 820 Status = AcpiHwRead (&ValueB, RegisterB); 821 if (ACPI_FAILURE (Status)) 822 { 823 return (Status); 824 } 825 } 826 827 /* 828 * OR the two return values together. No shifting or masking is necessary, 829 * because of how the PM1 registers are defined in the ACPI specification: 830 * 831 * "Although the bits can be split between the two register blocks (each 832 * register block has a unique pointer within the FADT), the bit positions 833 * are maintained. The register block with unimplemented bits (that is, 834 * those implemented in the other register block) always returns zeros, 835 * and writes have no side effects" 836 */ 837 *Value = (ValueA | ValueB); 838 return (AE_OK); 839 } 840 841 842 /****************************************************************************** 843 * 844 * FUNCTION: AcpiHwWriteMultiple 845 * 846 * PARAMETERS: Value - The value to write 847 * RegisterA - First ACPI register (required) 848 * RegisterB - Second ACPI register (optional) 849 * 850 * RETURN: Status 851 * 852 * DESCRIPTION: Write to the specified two-part ACPI register (such as PM1 A/B) 853 * 854 ******************************************************************************/ 855 856 static ACPI_STATUS 857 AcpiHwWriteMultiple ( 858 UINT32 Value, 859 ACPI_GENERIC_ADDRESS *RegisterA, 860 ACPI_GENERIC_ADDRESS *RegisterB) 861 { 862 ACPI_STATUS Status; 863 864 865 /* The first register is always required */ 866 867 Status = AcpiHwWrite (Value, RegisterA); 868 if (ACPI_FAILURE (Status)) 869 { 870 return (Status); 871 } 872 873 /* 874 * Second register is optional 875 * 876 * No bit shifting or clearing is necessary, because of how the PM1 877 * registers are defined in the ACPI specification: 878 * 879 * "Although the bits can be split between the two register blocks (each 880 * register block has a unique pointer within the FADT), the bit positions 881 * are maintained. The register block with unimplemented bits (that is, 882 * those implemented in the other register block) always returns zeros, 883 * and writes have no side effects" 884 */ 885 if (RegisterB->Address) 886 { 887 Status = AcpiHwWrite (Value, RegisterB); 888 } 889 890 return (Status); 891 } 892 893 #endif /* !ACPI_REDUCED_HARDWARE */ 894