1 /*******************************************************************************
3 * Module Name: hwregs - Read/write access functions for the various ACPI
4 * control and status registers.
6 ******************************************************************************/
8 /******************************************************************************
12 * Some or all of this work - Copyright (c) 1999 - 2020, Intel Corp.
13 * All rights reserved.
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights. You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code. No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
38 * The above copyright and patent license is granted only if the following
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision. In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change. Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee. Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution. In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
73 * 3.4. Intel retains all right, title, and interest in and to the Original
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
81 * 4. Disclaimer and Export Compliance
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
115 *****************************************************************************
117 * Alternatively, you may choose to be licensed under the terms of the
120 * Redistribution and use in source and binary forms, with or without
121 * modification, are permitted provided that the following conditions
123 * 1. Redistributions of source code must retain the above copyright
124 * notice, this list of conditions, and the following disclaimer,
125 * without modification.
126 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
127 * substantially similar to the "NO WARRANTY" disclaimer below
128 * ("Disclaimer") and any redistribution must be conditioned upon
129 * including a substantially similar Disclaimer requirement for further
130 * binary redistribution.
131 * 3. Neither the names of the above-listed copyright holders nor the names
132 * of any contributors may be used to endorse or promote products derived
133 * from this software without specific prior written permission.
135 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
136 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
137 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
138 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
139 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
140 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
141 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
142 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
143 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
144 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
145 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
147 * Alternatively, you may choose to be licensed under the terms of the
148 * GNU General Public License ("GPL") version 2 as published by the Free
149 * Software Foundation.
151 *****************************************************************************/
153 #include <contrib/dev/acpica/include/acpi.h>
154 #include <contrib/dev/acpica/include/accommon.h>
155 #include <contrib/dev/acpica/include/acevents.h>
157 #define _COMPONENT ACPI_HARDWARE
158 ACPI_MODULE_NAME ("hwregs")
161 #if (!ACPI_REDUCED_HARDWARE)
163 /* Local Prototypes */
166 AcpiHwGetAccessBitWidth (
168 ACPI_GENERIC_ADDRESS *Reg,
174 ACPI_GENERIC_ADDRESS *RegisterA,
175 ACPI_GENERIC_ADDRESS *RegisterB);
178 AcpiHwWriteMultiple (
180 ACPI_GENERIC_ADDRESS *RegisterA,
181 ACPI_GENERIC_ADDRESS *RegisterB);
183 #endif /* !ACPI_REDUCED_HARDWARE */
186 /******************************************************************************
188 * FUNCTION: AcpiHwGetAccessBitWidth
190 * PARAMETERS: Address - GAS register address
191 * Reg - GAS register structure
192 * MaxBitWidth - Max BitWidth supported (32 or 64)
196 * DESCRIPTION: Obtain optimal access bit width
198 ******************************************************************************/
201 AcpiHwGetAccessBitWidth (
203 ACPI_GENERIC_ADDRESS *Reg,
206 UINT8 AccessBitWidth;
210 * GAS format "register", used by FADT:
211 * 1. Detected if BitOffset is 0 and BitWidth is 8/16/32/64;
212 * 2. AccessSize field is ignored and BitWidth field is used for
213 * determining the boundary of the IO accesses.
214 * GAS format "region", used by APEI registers:
215 * 1. Detected if BitOffset is not 0 or BitWidth is not 8/16/32/64;
216 * 2. AccessSize field is used for determining the boundary of the
218 * 3. BitOffset/BitWidth fields are used to describe the "region".
220 * Note: This algorithm assumes that the "Address" fields should always
221 * contain aligned values.
223 if (!Reg->BitOffset && Reg->BitWidth &&
224 ACPI_IS_POWER_OF_TWO (Reg->BitWidth) &&
225 ACPI_IS_ALIGNED (Reg->BitWidth, 8))
227 AccessBitWidth = Reg->BitWidth;
229 else if (Reg->AccessWidth)
231 AccessBitWidth = ACPI_ACCESS_BIT_WIDTH (Reg->AccessWidth);
235 AccessBitWidth = ACPI_ROUND_UP_POWER_OF_TWO_8 (
236 Reg->BitOffset + Reg->BitWidth);
237 if (AccessBitWidth <= 8)
243 while (!ACPI_IS_ALIGNED (Address, AccessBitWidth >> 3))
245 AccessBitWidth >>= 1;
250 /* Maximum IO port access bit width is 32 */
252 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_IO)
258 * Return access width according to the requested maximum access bit width,
259 * as the caller should know the format of the register and may enforce
262 if (AccessBitWidth < MaxBitWidth)
264 return (AccessBitWidth);
266 return (MaxBitWidth);
270 /******************************************************************************
272 * FUNCTION: AcpiHwValidateRegister
274 * PARAMETERS: Reg - GAS register structure
275 * MaxBitWidth - Max BitWidth supported (32 or 64)
276 * Address - Pointer to where the gas->address
281 * DESCRIPTION: Validate the contents of a GAS register. Checks the GAS
282 * pointer, Address, SpaceId, BitWidth, and BitOffset.
284 ******************************************************************************/
287 AcpiHwValidateRegister (
288 ACPI_GENERIC_ADDRESS *Reg,
296 /* Must have a valid pointer to a GAS structure */
300 return (AE_BAD_PARAMETER);
304 * Copy the target address. This handles possible alignment issues.
305 * Address must not be null. A null address also indicates an optional
306 * ACPI register that is not supported, so no error message.
308 ACPI_MOVE_64_TO_64 (Address, &Reg->Address);
311 return (AE_BAD_ADDRESS);
314 /* Validate the SpaceID */
316 if ((Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
317 (Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
319 ACPI_ERROR ((AE_INFO,
320 "Unsupported address space: 0x%X", Reg->SpaceId));
324 /* Validate the AccessWidth */
326 if (Reg->AccessWidth > 4)
328 ACPI_ERROR ((AE_INFO,
329 "Unsupported register access width: 0x%X", Reg->AccessWidth));
333 /* Validate the BitWidth, convert AccessWidth into number of bits */
335 AccessWidth = AcpiHwGetAccessBitWidth (*Address, Reg, MaxBitWidth);
336 BitWidth = ACPI_ROUND_UP (Reg->BitOffset + Reg->BitWidth, AccessWidth);
337 if (MaxBitWidth < BitWidth)
339 ACPI_WARNING ((AE_INFO,
340 "Requested bit width 0x%X is smaller than register bit width 0x%X",
341 MaxBitWidth, BitWidth));
349 /******************************************************************************
351 * FUNCTION: AcpiHwRead
353 * PARAMETERS: Value - Where the value is returned
354 * Reg - GAS register structure
358 * DESCRIPTION: Read from either memory or IO space. This is a 64-bit max
359 * version of AcpiRead.
361 * LIMITATIONS: <These limitations also apply to AcpiHwWrite>
362 * SpaceID must be SystemMemory or SystemIO.
364 ******************************************************************************/
369 ACPI_GENERIC_ADDRESS *Reg)
381 ACPI_FUNCTION_NAME (HwRead);
384 /* Validate contents of the GAS register */
386 Status = AcpiHwValidateRegister (Reg, 64, &Address);
387 if (ACPI_FAILURE (Status))
393 * Initialize entire 64-bit return value to zero, convert AccessWidth
394 * into number of bits based
397 AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
398 BitWidth = Reg->BitOffset + Reg->BitWidth;
399 BitOffset = Reg->BitOffset;
402 * Two address spaces supported: Memory or IO. PCI_Config is
403 * not supported here because the GAS structure is insufficient
408 if (BitOffset >= AccessWidth)
411 BitOffset -= AccessWidth;
415 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
417 Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
418 Address + Index * ACPI_DIV_8 (AccessWidth),
419 &Value64, AccessWidth);
421 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
423 Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
424 Address + Index * ACPI_DIV_8 (AccessWidth),
425 &Value32, AccessWidth);
426 Value64 = (UINT64) Value32;
431 * Use offset style bit writes because "Index * AccessWidth" is
432 * ensured to be less than 64-bits by AcpiHwValidateRegister().
434 ACPI_SET_BITS (Value, Index * AccessWidth,
435 ACPI_MASK_BITS_ABOVE_64 (AccessWidth), Value64);
437 BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
441 ACPI_DEBUG_PRINT ((ACPI_DB_IO,
442 "Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
443 ACPI_FORMAT_UINT64 (*Value), AccessWidth,
444 ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
450 /******************************************************************************
452 * FUNCTION: AcpiHwWrite
454 * PARAMETERS: Value - Value to be written
455 * Reg - GAS register structure
459 * DESCRIPTION: Write to either memory or IO space. This is a 64-bit max
460 * version of AcpiWrite.
462 ******************************************************************************/
467 ACPI_GENERIC_ADDRESS *Reg)
478 ACPI_FUNCTION_NAME (HwWrite);
481 /* Validate contents of the GAS register */
483 Status = AcpiHwValidateRegister (Reg, 64, &Address);
484 if (ACPI_FAILURE (Status))
489 /* Convert AccessWidth into number of bits based */
491 AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
492 BitWidth = Reg->BitOffset + Reg->BitWidth;
493 BitOffset = Reg->BitOffset;
496 * Two address spaces supported: Memory or IO. PCI_Config is
497 * not supported here because the GAS structure is insufficient
503 * Use offset style bit reads because "Index * AccessWidth" is
504 * ensured to be less than 64-bits by AcpiHwValidateRegister().
506 Value64 = ACPI_GET_BITS (&Value, Index * AccessWidth,
507 ACPI_MASK_BITS_ABOVE_64 (AccessWidth));
509 if (BitOffset >= AccessWidth)
511 BitOffset -= AccessWidth;
515 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
517 Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
518 Address + Index * ACPI_DIV_8 (AccessWidth),
519 Value64, AccessWidth);
521 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
523 Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
524 Address + Index * ACPI_DIV_8 (AccessWidth),
525 (UINT32) Value64, AccessWidth);
530 * Index * AccessWidth is ensured to be less than 32-bits by
531 * AcpiHwValidateRegister().
533 BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
537 ACPI_DEBUG_PRINT ((ACPI_DB_IO,
538 "Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n",
539 ACPI_FORMAT_UINT64 (Value), AccessWidth,
540 ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
546 #if (!ACPI_REDUCED_HARDWARE)
547 /*******************************************************************************
549 * FUNCTION: AcpiHwClearAcpiStatus
555 * DESCRIPTION: Clears all fixed and general purpose status bits
557 ******************************************************************************/
560 AcpiHwClearAcpiStatus (
564 ACPI_CPU_FLAGS LockFlags = 0;
567 ACPI_FUNCTION_TRACE (HwClearAcpiStatus);
570 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n",
571 ACPI_BITMASK_ALL_FIXED_STATUS,
572 ACPI_FORMAT_UINT64 (AcpiGbl_XPm1aStatus.Address)));
574 LockFlags = AcpiOsAcquireLock (AcpiGbl_HardwareLock);
576 /* Clear the fixed events in PM1 A/B */
578 Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_STATUS,
579 ACPI_BITMASK_ALL_FIXED_STATUS);
581 AcpiOsReleaseLock (AcpiGbl_HardwareLock, LockFlags);
583 if (ACPI_FAILURE (Status))
588 /* Clear the GPE Bits in all GPE registers in all GPE blocks */
590 Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL);
593 return_ACPI_STATUS (Status);
597 /*******************************************************************************
599 * FUNCTION: AcpiHwGetBitRegisterInfo
601 * PARAMETERS: RegisterId - Index of ACPI Register to access
603 * RETURN: The bitmask to be used when accessing the register
605 * DESCRIPTION: Map RegisterId into a register bitmask.
607 ******************************************************************************/
609 ACPI_BIT_REGISTER_INFO *
610 AcpiHwGetBitRegisterInfo (
613 ACPI_FUNCTION_ENTRY ();
616 if (RegisterId > ACPI_BITREG_MAX)
618 ACPI_ERROR ((AE_INFO, "Invalid BitRegister ID: 0x%X", RegisterId));
622 return (&AcpiGbl_BitRegisterInfo[RegisterId]);
626 /******************************************************************************
628 * FUNCTION: AcpiHwWritePm1Control
630 * PARAMETERS: Pm1aControl - Value to be written to PM1A control
631 * Pm1bControl - Value to be written to PM1B control
635 * DESCRIPTION: Write the PM1 A/B control registers. These registers are
636 * different than than the PM1 A/B status and enable registers
637 * in that different values can be written to the A/B registers.
638 * Most notably, the SLP_TYP bits can be different, as per the
639 * values returned from the _Sx predefined methods.
641 ******************************************************************************/
644 AcpiHwWritePm1Control (
651 ACPI_FUNCTION_TRACE (HwWritePm1Control);
654 Status = AcpiHwWrite (Pm1aControl, &AcpiGbl_FADT.XPm1aControlBlock);
655 if (ACPI_FAILURE (Status))
657 return_ACPI_STATUS (Status);
660 if (AcpiGbl_FADT.XPm1bControlBlock.Address)
662 Status = AcpiHwWrite (Pm1bControl, &AcpiGbl_FADT.XPm1bControlBlock);
664 return_ACPI_STATUS (Status);
668 /******************************************************************************
670 * FUNCTION: AcpiHwRegisterRead
672 * PARAMETERS: RegisterId - ACPI Register ID
673 * ReturnValue - Where the register value is returned
675 * RETURN: Status and the value read.
677 * DESCRIPTION: Read from the specified ACPI register
679 ******************************************************************************/
691 ACPI_FUNCTION_TRACE (HwRegisterRead);
696 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
698 Status = AcpiHwReadMultiple (&Value,
699 &AcpiGbl_XPm1aStatus,
700 &AcpiGbl_XPm1bStatus);
703 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
705 Status = AcpiHwReadMultiple (&Value,
706 &AcpiGbl_XPm1aEnable,
707 &AcpiGbl_XPm1bEnable);
710 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
712 Status = AcpiHwReadMultiple (&Value,
713 &AcpiGbl_FADT.XPm1aControlBlock,
714 &AcpiGbl_FADT.XPm1bControlBlock);
717 * Zero the write-only bits. From the ACPI specification, "Hardware
718 * Write-Only Bits": "Upon reads to registers with write-only bits,
719 * software masks out all write-only bits."
721 Value &= ~ACPI_PM1_CONTROL_WRITEONLY_BITS;
724 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
726 Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPm2ControlBlock);
727 if (ACPI_SUCCESS (Status))
729 Value = (UINT32) Value64;
733 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
735 Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPmTimerBlock);
736 if (ACPI_SUCCESS (Status))
738 Value = (UINT32) Value64;
743 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
745 Status = AcpiHwReadPort (AcpiGbl_FADT.SmiCommand, &Value, 8);
750 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
752 Status = AE_BAD_PARAMETER;
756 if (ACPI_SUCCESS (Status))
758 *ReturnValue = (UINT32) Value;
761 return_ACPI_STATUS (Status);
765 /******************************************************************************
767 * FUNCTION: AcpiHwRegisterWrite
769 * PARAMETERS: RegisterId - ACPI Register ID
770 * Value - The value to write
774 * DESCRIPTION: Write to the specified ACPI register
776 * NOTE: In accordance with the ACPI specification, this function automatically
777 * preserves the value of the following bits, meaning that these bits cannot be
778 * changed via this interface:
780 * PM1_CONTROL[0] = SCI_EN
785 * 1) Hardware Ignored Bits: When software writes to a register with ignored
786 * bit fields, it preserves the ignored bit fields
787 * 2) SCI_EN: OSPM always preserves this bit position
789 ******************************************************************************/
792 AcpiHwRegisterWrite (
801 ACPI_FUNCTION_TRACE (HwRegisterWrite);
806 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
808 * Handle the "ignored" bit in PM1 Status. According to the ACPI
809 * specification, ignored bits are to be preserved when writing.
810 * Normally, this would mean a read/modify/write sequence. However,
811 * preserving a bit in the status register is different. Writing a
812 * one clears the status, and writing a zero preserves the status.
813 * Therefore, we must always write zero to the ignored bit.
815 * This behavior is clarified in the ACPI 4.0 specification.
817 Value &= ~ACPI_PM1_STATUS_PRESERVED_BITS;
819 Status = AcpiHwWriteMultiple (Value,
820 &AcpiGbl_XPm1aStatus,
821 &AcpiGbl_XPm1bStatus);
824 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
826 Status = AcpiHwWriteMultiple (Value,
827 &AcpiGbl_XPm1aEnable,
828 &AcpiGbl_XPm1bEnable);
831 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
833 * Perform a read first to preserve certain bits (per ACPI spec)
834 * Note: This includes SCI_EN, we never want to change this bit
836 Status = AcpiHwReadMultiple (&ReadValue,
837 &AcpiGbl_FADT.XPm1aControlBlock,
838 &AcpiGbl_FADT.XPm1bControlBlock);
839 if (ACPI_FAILURE (Status))
844 /* Insert the bits to be preserved */
846 ACPI_INSERT_BITS (Value, ACPI_PM1_CONTROL_PRESERVED_BITS, ReadValue);
848 /* Now we can write the data */
850 Status = AcpiHwWriteMultiple (Value,
851 &AcpiGbl_FADT.XPm1aControlBlock,
852 &AcpiGbl_FADT.XPm1bControlBlock);
855 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
857 * For control registers, all reserved bits must be preserved,
858 * as per the ACPI spec.
860 Status = AcpiHwRead (&ReadValue64, &AcpiGbl_FADT.XPm2ControlBlock);
861 if (ACPI_FAILURE (Status))
865 ReadValue = (UINT32) ReadValue64;
867 /* Insert the bits to be preserved */
869 ACPI_INSERT_BITS (Value, ACPI_PM2_CONTROL_PRESERVED_BITS, ReadValue);
871 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPm2ControlBlock);
874 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
876 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPmTimerBlock);
879 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
881 /* SMI_CMD is currently always in IO space */
883 Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand, Value, 8);
888 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
890 Status = AE_BAD_PARAMETER;
895 return_ACPI_STATUS (Status);
899 /******************************************************************************
901 * FUNCTION: AcpiHwReadMultiple
903 * PARAMETERS: Value - Where the register value is returned
904 * RegisterA - First ACPI register (required)
905 * RegisterB - Second ACPI register (optional)
909 * DESCRIPTION: Read from the specified two-part ACPI register (such as PM1 A/B)
911 ******************************************************************************/
916 ACPI_GENERIC_ADDRESS *RegisterA,
917 ACPI_GENERIC_ADDRESS *RegisterB)
925 /* The first register is always required */
927 Status = AcpiHwRead (&Value64, RegisterA);
928 if (ACPI_FAILURE (Status))
932 ValueA = (UINT32) Value64;
934 /* Second register is optional */
936 if (RegisterB->Address)
938 Status = AcpiHwRead (&Value64, RegisterB);
939 if (ACPI_FAILURE (Status))
943 ValueB = (UINT32) Value64;
947 * OR the two return values together. No shifting or masking is necessary,
948 * because of how the PM1 registers are defined in the ACPI specification:
950 * "Although the bits can be split between the two register blocks (each
951 * register block has a unique pointer within the FADT), the bit positions
952 * are maintained. The register block with unimplemented bits (that is,
953 * those implemented in the other register block) always returns zeros,
954 * and writes have no side effects"
956 *Value = (ValueA | ValueB);
961 /******************************************************************************
963 * FUNCTION: AcpiHwWriteMultiple
965 * PARAMETERS: Value - The value to write
966 * RegisterA - First ACPI register (required)
967 * RegisterB - Second ACPI register (optional)
971 * DESCRIPTION: Write to the specified two-part ACPI register (such as PM1 A/B)
973 ******************************************************************************/
976 AcpiHwWriteMultiple (
978 ACPI_GENERIC_ADDRESS *RegisterA,
979 ACPI_GENERIC_ADDRESS *RegisterB)
984 /* The first register is always required */
986 Status = AcpiHwWrite (Value, RegisterA);
987 if (ACPI_FAILURE (Status))
993 * Second register is optional
995 * No bit shifting or clearing is necessary, because of how the PM1
996 * registers are defined in the ACPI specification:
998 * "Although the bits can be split between the two register blocks (each
999 * register block has a unique pointer within the FADT), the bit positions
1000 * are maintained. The register block with unimplemented bits (that is,
1001 * those implemented in the other register block) always returns zeros,
1002 * and writes have no side effects"
1004 if (RegisterB->Address)
1006 Status = AcpiHwWrite (Value, RegisterB);
1012 #endif /* !ACPI_REDUCED_HARDWARE */