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 - 2017, 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 = (1 << (Reg->AccessWidth + 2));
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 32-bit max
359 * version of AcpiRead, used internally since the overhead of
360 * 64-bit values is not needed.
362 * LIMITATIONS: <These limitations also apply to AcpiHwWrite>
363 * SpaceID must be SystemMemory or SystemIO.
365 ******************************************************************************/
370 ACPI_GENERIC_ADDRESS *Reg)
382 ACPI_FUNCTION_NAME (HwRead);
385 /* Validate contents of the GAS register */
387 Status = AcpiHwValidateRegister (Reg, 32, &Address);
388 if (ACPI_FAILURE (Status))
394 * Initialize entire 32-bit return value to zero, convert AccessWidth
395 * into number of bits based
398 AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32);
399 BitWidth = Reg->BitOffset + Reg->BitWidth;
400 BitOffset = Reg->BitOffset;
403 * Two address spaces supported: Memory or IO. PCI_Config is
404 * not supported here because the GAS structure is insufficient
409 if (BitOffset >= AccessWidth)
412 BitOffset -= AccessWidth;
416 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
418 Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
419 Address + Index * ACPI_DIV_8 (AccessWidth),
420 &Value64, AccessWidth);
421 Value32 = (UINT32) Value64;
423 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
425 Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
426 Address + Index * ACPI_DIV_8 (AccessWidth),
427 &Value32, AccessWidth);
432 * Use offset style bit writes because "Index * AccessWidth" is
433 * ensured to be less than 32-bits by AcpiHwValidateRegister().
435 ACPI_SET_BITS (Value, Index * AccessWidth,
436 ACPI_MASK_BITS_ABOVE_32 (AccessWidth), Value32);
438 BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
442 ACPI_DEBUG_PRINT ((ACPI_DB_IO,
443 "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n",
444 *Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
445 AcpiUtGetRegionName (Reg->SpaceId)));
451 /******************************************************************************
453 * FUNCTION: AcpiHwWrite
455 * PARAMETERS: Value - Value to be written
456 * Reg - GAS register structure
460 * DESCRIPTION: Write to either memory or IO space. This is a 32-bit max
461 * version of AcpiWrite, used internally since the overhead of
462 * 64-bit values is not needed.
464 ******************************************************************************/
469 ACPI_GENERIC_ADDRESS *Reg)
481 ACPI_FUNCTION_NAME (HwWrite);
484 /* Validate contents of the GAS register */
486 Status = AcpiHwValidateRegister (Reg, 32, &Address);
487 if (ACPI_FAILURE (Status))
492 /* Convert AccessWidth into number of bits based */
494 AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32);
495 BitWidth = Reg->BitOffset + Reg->BitWidth;
496 BitOffset = Reg->BitOffset;
499 * Two address spaces supported: Memory or IO. PCI_Config is
500 * not supported here because the GAS structure is insufficient
506 * Use offset style bit reads because "Index * AccessWidth" is
507 * ensured to be less than 32-bits by AcpiHwValidateRegister().
509 Value32 = ACPI_GET_BITS (&Value, Index * AccessWidth,
510 ACPI_MASK_BITS_ABOVE_32 (AccessWidth));
512 if (BitOffset >= AccessWidth)
514 BitOffset -= AccessWidth;
518 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
520 Value64 = (UINT64) Value32;
521 Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
522 Address + Index * ACPI_DIV_8 (AccessWidth),
523 Value64, AccessWidth);
525 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
527 Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
528 Address + Index * ACPI_DIV_8 (AccessWidth),
529 Value32, AccessWidth);
534 * Index * AccessWidth is ensured to be less than 32-bits by
535 * AcpiHwValidateRegister().
537 BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
541 ACPI_DEBUG_PRINT ((ACPI_DB_IO,
542 "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
543 Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
544 AcpiUtGetRegionName (Reg->SpaceId)));
550 #if (!ACPI_REDUCED_HARDWARE)
551 /*******************************************************************************
553 * FUNCTION: AcpiHwClearAcpiStatus
559 * DESCRIPTION: Clears all fixed and general purpose status bits
561 ******************************************************************************/
564 AcpiHwClearAcpiStatus (
568 ACPI_CPU_FLAGS LockFlags = 0;
571 ACPI_FUNCTION_TRACE (HwClearAcpiStatus);
574 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n",
575 ACPI_BITMASK_ALL_FIXED_STATUS,
576 ACPI_FORMAT_UINT64 (AcpiGbl_XPm1aStatus.Address)));
578 LockFlags = AcpiOsAcquireLock (AcpiGbl_HardwareLock);
580 /* Clear the fixed events in PM1 A/B */
582 Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_STATUS,
583 ACPI_BITMASK_ALL_FIXED_STATUS);
585 AcpiOsReleaseLock (AcpiGbl_HardwareLock, LockFlags);
587 if (ACPI_FAILURE (Status))
592 /* Clear the GPE Bits in all GPE registers in all GPE blocks */
594 Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL);
597 return_ACPI_STATUS (Status);
601 /*******************************************************************************
603 * FUNCTION: AcpiHwGetBitRegisterInfo
605 * PARAMETERS: RegisterId - Index of ACPI Register to access
607 * RETURN: The bitmask to be used when accessing the register
609 * DESCRIPTION: Map RegisterId into a register bitmask.
611 ******************************************************************************/
613 ACPI_BIT_REGISTER_INFO *
614 AcpiHwGetBitRegisterInfo (
617 ACPI_FUNCTION_ENTRY ();
620 if (RegisterId > ACPI_BITREG_MAX)
622 ACPI_ERROR ((AE_INFO, "Invalid BitRegister ID: 0x%X", RegisterId));
626 return (&AcpiGbl_BitRegisterInfo[RegisterId]);
630 /******************************************************************************
632 * FUNCTION: AcpiHwWritePm1Control
634 * PARAMETERS: Pm1aControl - Value to be written to PM1A control
635 * Pm1bControl - Value to be written to PM1B control
639 * DESCRIPTION: Write the PM1 A/B control registers. These registers are
640 * different than than the PM1 A/B status and enable registers
641 * in that different values can be written to the A/B registers.
642 * Most notably, the SLP_TYP bits can be different, as per the
643 * values returned from the _Sx predefined methods.
645 ******************************************************************************/
648 AcpiHwWritePm1Control (
655 ACPI_FUNCTION_TRACE (HwWritePm1Control);
658 Status = AcpiHwWrite (Pm1aControl, &AcpiGbl_FADT.XPm1aControlBlock);
659 if (ACPI_FAILURE (Status))
661 return_ACPI_STATUS (Status);
664 if (AcpiGbl_FADT.XPm1bControlBlock.Address)
666 Status = AcpiHwWrite (Pm1bControl, &AcpiGbl_FADT.XPm1bControlBlock);
668 return_ACPI_STATUS (Status);
672 /******************************************************************************
674 * FUNCTION: AcpiHwRegisterRead
676 * PARAMETERS: RegisterId - ACPI Register ID
677 * ReturnValue - Where the register value is returned
679 * RETURN: Status and the value read.
681 * DESCRIPTION: Read from the specified ACPI register
683 ******************************************************************************/
694 ACPI_FUNCTION_TRACE (HwRegisterRead);
699 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
701 Status = AcpiHwReadMultiple (&Value,
702 &AcpiGbl_XPm1aStatus,
703 &AcpiGbl_XPm1bStatus);
706 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
708 Status = AcpiHwReadMultiple (&Value,
709 &AcpiGbl_XPm1aEnable,
710 &AcpiGbl_XPm1bEnable);
713 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
715 Status = AcpiHwReadMultiple (&Value,
716 &AcpiGbl_FADT.XPm1aControlBlock,
717 &AcpiGbl_FADT.XPm1bControlBlock);
720 * Zero the write-only bits. From the ACPI specification, "Hardware
721 * Write-Only Bits": "Upon reads to registers with write-only bits,
722 * software masks out all write-only bits."
724 Value &= ~ACPI_PM1_CONTROL_WRITEONLY_BITS;
727 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
729 Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPm2ControlBlock);
732 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
734 Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPmTimerBlock);
737 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
739 Status = AcpiHwReadPort (AcpiGbl_FADT.SmiCommand, &Value, 8);
744 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
746 Status = AE_BAD_PARAMETER;
750 if (ACPI_SUCCESS (Status))
752 *ReturnValue = Value;
755 return_ACPI_STATUS (Status);
759 /******************************************************************************
761 * FUNCTION: AcpiHwRegisterWrite
763 * PARAMETERS: RegisterId - ACPI Register ID
764 * Value - The value to write
768 * DESCRIPTION: Write to the specified ACPI register
770 * NOTE: In accordance with the ACPI specification, this function automatically
771 * preserves the value of the following bits, meaning that these bits cannot be
772 * changed via this interface:
774 * PM1_CONTROL[0] = SCI_EN
779 * 1) Hardware Ignored Bits: When software writes to a register with ignored
780 * bit fields, it preserves the ignored bit fields
781 * 2) SCI_EN: OSPM always preserves this bit position
783 ******************************************************************************/
786 AcpiHwRegisterWrite (
794 ACPI_FUNCTION_TRACE (HwRegisterWrite);
799 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
801 * Handle the "ignored" bit in PM1 Status. According to the ACPI
802 * specification, ignored bits are to be preserved when writing.
803 * Normally, this would mean a read/modify/write sequence. However,
804 * preserving a bit in the status register is different. Writing a
805 * one clears the status, and writing a zero preserves the status.
806 * Therefore, we must always write zero to the ignored bit.
808 * This behavior is clarified in the ACPI 4.0 specification.
810 Value &= ~ACPI_PM1_STATUS_PRESERVED_BITS;
812 Status = AcpiHwWriteMultiple (Value,
813 &AcpiGbl_XPm1aStatus,
814 &AcpiGbl_XPm1bStatus);
817 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
819 Status = AcpiHwWriteMultiple (Value,
820 &AcpiGbl_XPm1aEnable,
821 &AcpiGbl_XPm1bEnable);
824 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
826 * Perform a read first to preserve certain bits (per ACPI spec)
827 * Note: This includes SCI_EN, we never want to change this bit
829 Status = AcpiHwReadMultiple (&ReadValue,
830 &AcpiGbl_FADT.XPm1aControlBlock,
831 &AcpiGbl_FADT.XPm1bControlBlock);
832 if (ACPI_FAILURE (Status))
837 /* Insert the bits to be preserved */
839 ACPI_INSERT_BITS (Value, ACPI_PM1_CONTROL_PRESERVED_BITS, ReadValue);
841 /* Now we can write the data */
843 Status = AcpiHwWriteMultiple (Value,
844 &AcpiGbl_FADT.XPm1aControlBlock,
845 &AcpiGbl_FADT.XPm1bControlBlock);
848 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
850 * For control registers, all reserved bits must be preserved,
851 * as per the ACPI spec.
853 Status = AcpiHwRead (&ReadValue, &AcpiGbl_FADT.XPm2ControlBlock);
854 if (ACPI_FAILURE (Status))
859 /* Insert the bits to be preserved */
861 ACPI_INSERT_BITS (Value, ACPI_PM2_CONTROL_PRESERVED_BITS, ReadValue);
863 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPm2ControlBlock);
866 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
868 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPmTimerBlock);
871 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
873 /* SMI_CMD is currently always in IO space */
875 Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand, Value, 8);
880 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
882 Status = AE_BAD_PARAMETER;
887 return_ACPI_STATUS (Status);
891 /******************************************************************************
893 * FUNCTION: AcpiHwReadMultiple
895 * PARAMETERS: Value - Where the register value is returned
896 * RegisterA - First ACPI register (required)
897 * RegisterB - Second ACPI register (optional)
901 * DESCRIPTION: Read from the specified two-part ACPI register (such as PM1 A/B)
903 ******************************************************************************/
908 ACPI_GENERIC_ADDRESS *RegisterA,
909 ACPI_GENERIC_ADDRESS *RegisterB)
916 /* The first register is always required */
918 Status = AcpiHwRead (&ValueA, RegisterA);
919 if (ACPI_FAILURE (Status))
924 /* Second register is optional */
926 if (RegisterB->Address)
928 Status = AcpiHwRead (&ValueB, RegisterB);
929 if (ACPI_FAILURE (Status))
936 * OR the two return values together. No shifting or masking is necessary,
937 * because of how the PM1 registers are defined in the ACPI specification:
939 * "Although the bits can be split between the two register blocks (each
940 * register block has a unique pointer within the FADT), the bit positions
941 * are maintained. The register block with unimplemented bits (that is,
942 * those implemented in the other register block) always returns zeros,
943 * and writes have no side effects"
945 *Value = (ValueA | ValueB);
950 /******************************************************************************
952 * FUNCTION: AcpiHwWriteMultiple
954 * PARAMETERS: Value - The value to write
955 * RegisterA - First ACPI register (required)
956 * RegisterB - Second ACPI register (optional)
960 * DESCRIPTION: Write to the specified two-part ACPI register (such as PM1 A/B)
962 ******************************************************************************/
965 AcpiHwWriteMultiple (
967 ACPI_GENERIC_ADDRESS *RegisterA,
968 ACPI_GENERIC_ADDRESS *RegisterB)
973 /* The first register is always required */
975 Status = AcpiHwWrite (Value, RegisterA);
976 if (ACPI_FAILURE (Status))
982 * Second register is optional
984 * No bit shifting or clearing is necessary, because of how the PM1
985 * registers are defined in the ACPI specification:
987 * "Although the bits can be split between the two register blocks (each
988 * register block has a unique pointer within the FADT), the bit positions
989 * are maintained. The register block with unimplemented bits (that is,
990 * those implemented in the other register block) always returns zeros,
991 * and writes have no side effects"
993 if (RegisterB->Address)
995 Status = AcpiHwWrite (Value, RegisterB);
1001 #endif /* !ACPI_REDUCED_HARDWARE */