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 *****************************************************************************/
154 #include "accommon.h"
155 #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 Value
= (UINT32
) Value64
;
730 case ACPI_REGISTER_PM_TIMER
: /* 32-bit access */
732 Status
= AcpiHwRead (&Value64
, &AcpiGbl_FADT
.XPmTimerBlock
);
733 Value
= (UINT32
) Value64
;
736 case ACPI_REGISTER_SMI_COMMAND_BLOCK
: /* 8-bit access */
738 Status
= AcpiHwReadPort (AcpiGbl_FADT
.SmiCommand
, &Value
, 8);
743 ACPI_ERROR ((AE_INFO
, "Unknown Register ID: 0x%X",
745 Status
= AE_BAD_PARAMETER
;
749 if (ACPI_SUCCESS (Status
))
751 *ReturnValue
= (UINT32
) Value
;
754 return_ACPI_STATUS (Status
);
758 /******************************************************************************
760 * FUNCTION: AcpiHwRegisterWrite
762 * PARAMETERS: RegisterId - ACPI Register ID
763 * Value - The value to write
767 * DESCRIPTION: Write to the specified ACPI register
769 * NOTE: In accordance with the ACPI specification, this function automatically
770 * preserves the value of the following bits, meaning that these bits cannot be
771 * changed via this interface:
773 * PM1_CONTROL[0] = SCI_EN
778 * 1) Hardware Ignored Bits: When software writes to a register with ignored
779 * bit fields, it preserves the ignored bit fields
780 * 2) SCI_EN: OSPM always preserves this bit position
782 ******************************************************************************/
785 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 (&ReadValue64
, &AcpiGbl_FADT
.XPm2ControlBlock
);
854 if (ACPI_FAILURE (Status
))
858 ReadValue
= (UINT32
) ReadValue64
;
860 /* Insert the bits to be preserved */
862 ACPI_INSERT_BITS (Value
, ACPI_PM2_CONTROL_PRESERVED_BITS
, ReadValue
);
864 Status
= AcpiHwWrite (Value
, &AcpiGbl_FADT
.XPm2ControlBlock
);
867 case ACPI_REGISTER_PM_TIMER
: /* 32-bit access */
869 Status
= AcpiHwWrite (Value
, &AcpiGbl_FADT
.XPmTimerBlock
);
872 case ACPI_REGISTER_SMI_COMMAND_BLOCK
: /* 8-bit access */
874 /* SMI_CMD is currently always in IO space */
876 Status
= AcpiHwWritePort (AcpiGbl_FADT
.SmiCommand
, Value
, 8);
881 ACPI_ERROR ((AE_INFO
, "Unknown Register ID: 0x%X",
883 Status
= AE_BAD_PARAMETER
;
888 return_ACPI_STATUS (Status
);
892 /******************************************************************************
894 * FUNCTION: AcpiHwReadMultiple
896 * PARAMETERS: Value - Where the register value is returned
897 * RegisterA - First ACPI register (required)
898 * RegisterB - Second ACPI register (optional)
902 * DESCRIPTION: Read from the specified two-part ACPI register (such as PM1 A/B)
904 ******************************************************************************/
909 ACPI_GENERIC_ADDRESS
*RegisterA
,
910 ACPI_GENERIC_ADDRESS
*RegisterB
)
918 /* The first register is always required */
920 Status
= AcpiHwRead (&Value64
, RegisterA
);
921 if (ACPI_FAILURE (Status
))
925 ValueA
= (UINT32
) Value64
;
927 /* Second register is optional */
929 if (RegisterB
->Address
)
931 Status
= AcpiHwRead (&Value64
, RegisterB
);
932 if (ACPI_FAILURE (Status
))
936 ValueB
= (UINT32
) Value64
;
940 * OR the two return values together. No shifting or masking is necessary,
941 * because of how the PM1 registers are defined in the ACPI specification:
943 * "Although the bits can be split between the two register blocks (each
944 * register block has a unique pointer within the FADT), the bit positions
945 * are maintained. The register block with unimplemented bits (that is,
946 * those implemented in the other register block) always returns zeros,
947 * and writes have no side effects"
949 *Value
= (ValueA
| ValueB
);
954 /******************************************************************************
956 * FUNCTION: AcpiHwWriteMultiple
958 * PARAMETERS: Value - The value to write
959 * RegisterA - First ACPI register (required)
960 * RegisterB - Second ACPI register (optional)
964 * DESCRIPTION: Write to the specified two-part ACPI register (such as PM1 A/B)
966 ******************************************************************************/
969 AcpiHwWriteMultiple (
971 ACPI_GENERIC_ADDRESS
*RegisterA
,
972 ACPI_GENERIC_ADDRESS
*RegisterB
)
977 /* The first register is always required */
979 Status
= AcpiHwWrite (Value
, RegisterA
);
980 if (ACPI_FAILURE (Status
))
986 * Second register is optional
988 * No bit shifting or clearing is necessary, because of how the PM1
989 * registers are defined in the ACPI specification:
991 * "Although the bits can be split between the two register blocks (each
992 * register block has a unique pointer within the FADT), the bit positions
993 * are maintained. The register block with unimplemented bits (that is,
994 * those implemented in the other register block) always returns zeros,
995 * and writes have no side effects"
997 if (RegisterB
->Address
)
999 Status
= AcpiHwWrite (Value
, RegisterB
);
1005 #endif /* !ACPI_REDUCED_HARDWARE */