2005-04-16 16:20:36 -06:00
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* Module Name: hwregs - Read/write access functions for the various ACPI
|
|
|
|
* control and status registers.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
/*
|
2018-01-04 11:06:38 -07:00
|
|
|
* Copyright (C) 2000 - 2018, Intel Corp.
|
2005-04-16 16:20:36 -06:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions, and the following disclaimer,
|
|
|
|
* without modification.
|
|
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
|
|
* substantially similar to the "NO WARRANTY" disclaimer below
|
|
|
|
* ("Disclaimer") and any redistribution must be conditioned upon
|
|
|
|
* including a substantially similar Disclaimer requirement for further
|
|
|
|
* binary redistribution.
|
|
|
|
* 3. Neither the names of the above-listed copyright holders nor the names
|
|
|
|
* of any contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* Alternatively, this software may be distributed under the terms of the
|
|
|
|
* GNU General Public License ("GPL") version 2 as published by the Free
|
|
|
|
* Software Foundation.
|
|
|
|
*
|
|
|
|
* NO WARRANTY
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
|
|
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
* POSSIBILITY OF SUCH DAMAGES.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <acpi/acpi.h>
|
2009-01-08 22:30:03 -07:00
|
|
|
#include "accommon.h"
|
|
|
|
#include "acevents.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define _COMPONENT ACPI_HARDWARE
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_MODULE_NAME("hwregs")
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-14 03:14:27 -07:00
|
|
|
#if (!ACPI_REDUCED_HARDWARE)
|
2009-02-17 23:20:12 -07:00
|
|
|
/* Local Prototypes */
|
2016-05-04 22:58:39 -06:00
|
|
|
static u8
|
2016-12-28 00:28:36 -07:00
|
|
|
acpi_hw_get_access_bit_width(u64 address,
|
|
|
|
struct acpi_generic_address *reg,
|
2016-05-04 22:58:39 -06:00
|
|
|
u8 max_bit_width);
|
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
static acpi_status
|
|
|
|
acpi_hw_read_multiple(u32 *value,
|
|
|
|
struct acpi_generic_address *register_a,
|
|
|
|
struct acpi_generic_address *register_b);
|
|
|
|
|
|
|
|
static acpi_status
|
|
|
|
acpi_hw_write_multiple(u32 value,
|
|
|
|
struct acpi_generic_address *register_a,
|
|
|
|
struct acpi_generic_address *register_b);
|
|
|
|
|
2012-02-14 03:14:27 -07:00
|
|
|
#endif /* !ACPI_REDUCED_HARDWARE */
|
|
|
|
|
2016-05-04 22:58:39 -06:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_get_access_bit_width
|
|
|
|
*
|
2016-12-28 00:28:36 -07:00
|
|
|
* PARAMETERS: address - GAS register address
|
|
|
|
* reg - GAS register structure
|
2016-05-04 22:58:39 -06:00
|
|
|
* max_bit_width - Max bit_width supported (32 or 64)
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Obtain optimal access bit width
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
static u8
|
2016-12-28 00:28:36 -07:00
|
|
|
acpi_hw_get_access_bit_width(u64 address,
|
|
|
|
struct acpi_generic_address *reg, u8 max_bit_width)
|
2016-05-04 22:58:39 -06:00
|
|
|
{
|
2016-12-28 00:28:36 -07:00
|
|
|
u8 access_bit_width;
|
ACPICA / Hardware: Fix old register check in acpi_hw_get_access_bit_width()
The address check in acpi_hw_get_access_bit_width() should be byte width
based, not bit width based. This patch fixes this mistake.
For those who want to review acpi_hw_access_bit_width(), here is the
concerns and the design details of the function:
It is supposed that the GAS Address field should be aligned to the byte
width indicated by the GAS AccessSize field. Similarly, for the old non
GAS register, it is supposed that its Address should be aligned to its
Length.
For the "AccessSize = 0 (meaning ANY)" case, we try to return the maximum
instruction width (64 for MMIO or 32 for PIO) or the user expected access
bit width (64 for acpi_read()/acpi_write() or 32 for acpi_hw_read()/
acpi_hw_write()) and it is supposed that the GAS Address field should
always be aligned to the maximum expected access bit width (otherwise it
can't be accessed using ANY access bit width).
The problem is in acpi_tb_init_generic_address(), where the non GAS
register's Length is converted into the GAS BitWidth field, its Address is
converted into the GAS Address field, and the GAS AccessSize field is left
0 but most of the registers actually cannot be accessed using "ANY"
accesses.
As a conclusion, when AccessSize = 0 (ANY), the Address should either be
aligned to the BitWidth (wrong conversion) or aligned to 32 for PIO or 64
for MMIO (real GAS). Since currently, max_bit_width is 32, then:
1. BitWidth for the wrong conversion is 8,16,32; and
2. The Address of the real GAS should always be aligned to 8,16,32.
The address alignment check to exclude false matched real GAS is not
necessary. Thus this patch fixes the issue by removing the address
alignment check.
On the other hand, we in fact could use a simpler check of
"reg->bit_width < max_bit_width" to exclude the "BitWidth=64 PIO" case that
may be issued from acpi_read()/acpi_write() in the future.
Fixes: b314a172ee96 (ACPICA: Hardware: Add optimized access bit width support)
Reported-and-tested-by: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Acked-by: Mike Marshall <hubcap@omnibond.com>
Suggested-by: Jan Beulich <jbeulich@suse.com>
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-05-31 21:03:20 -06:00
|
|
|
|
2016-12-28 00:28:36 -07:00
|
|
|
/*
|
|
|
|
* GAS format "register", used by FADT:
|
|
|
|
* 1. Detected if bit_offset is 0 and bit_width is 8/16/32/64;
|
|
|
|
* 2. access_size field is ignored and bit_width field is used for
|
|
|
|
* determining the boundary of the IO accesses.
|
|
|
|
* GAS format "region", used by APEI registers:
|
|
|
|
* 1. Detected if bit_offset is not 0 or bit_width is not 8/16/32/64;
|
|
|
|
* 2. access_size field is used for determining the boundary of the
|
|
|
|
* IO accesses;
|
|
|
|
* 3. bit_offset/bit_width fields are used to describe the "region".
|
|
|
|
*
|
|
|
|
* Note: This algorithm assumes that the "Address" fields should always
|
|
|
|
* contain aligned values.
|
|
|
|
*/
|
|
|
|
if (!reg->bit_offset && reg->bit_width &&
|
|
|
|
ACPI_IS_POWER_OF_TWO(reg->bit_width) &&
|
|
|
|
ACPI_IS_ALIGNED(reg->bit_width, 8)) {
|
|
|
|
access_bit_width = reg->bit_width;
|
|
|
|
} else if (reg->access_width) {
|
2017-08-03 00:26:19 -06:00
|
|
|
access_bit_width = ACPI_ACCESS_BIT_WIDTH(reg->access_width);
|
2016-05-04 22:58:39 -06:00
|
|
|
} else {
|
2016-12-28 00:28:36 -07:00
|
|
|
access_bit_width =
|
|
|
|
ACPI_ROUND_UP_POWER_OF_TWO_8(reg->bit_offset +
|
|
|
|
reg->bit_width);
|
|
|
|
if (access_bit_width <= 8) {
|
|
|
|
access_bit_width = 8;
|
|
|
|
} else {
|
|
|
|
while (!ACPI_IS_ALIGNED(address, access_bit_width >> 3)) {
|
|
|
|
access_bit_width >>= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Maximum IO port access bit width is 32 */
|
|
|
|
|
|
|
|
if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
|
|
|
|
max_bit_width = 32;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return access width according to the requested maximum access bit width,
|
|
|
|
* as the caller should know the format of the register and may enforce
|
|
|
|
* a 32-bit accesses.
|
|
|
|
*/
|
|
|
|
if (access_bit_width < max_bit_width) {
|
|
|
|
return (access_bit_width);
|
2016-05-04 22:58:39 -06:00
|
|
|
}
|
2016-12-28 00:28:36 -07:00
|
|
|
return (max_bit_width);
|
2016-05-04 22:58:39 -06:00
|
|
|
}
|
|
|
|
|
2009-06-23 19:44:06 -06:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_validate_register
|
|
|
|
*
|
2012-07-11 19:40:10 -06:00
|
|
|
* PARAMETERS: reg - GAS register structure
|
2009-06-23 19:44:06 -06:00
|
|
|
* max_bit_width - Max bit_width supported (32 or 64)
|
2012-07-11 19:40:10 -06:00
|
|
|
* address - Pointer to where the gas->address
|
2009-06-23 19:44:06 -06:00
|
|
|
* is returned
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Validate the contents of a GAS register. Checks the GAS
|
|
|
|
* pointer, Address, space_id, bit_width, and bit_offset.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
acpi_status
|
|
|
|
acpi_hw_validate_register(struct acpi_generic_address *reg,
|
|
|
|
u8 max_bit_width, u64 *address)
|
|
|
|
{
|
2016-03-23 19:41:09 -06:00
|
|
|
u8 bit_width;
|
|
|
|
u8 access_width;
|
2009-06-23 19:44:06 -06:00
|
|
|
|
|
|
|
/* Must have a valid pointer to a GAS structure */
|
|
|
|
|
|
|
|
if (!reg) {
|
|
|
|
return (AE_BAD_PARAMETER);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the target address. This handles possible alignment issues.
|
|
|
|
* Address must not be null. A null address also indicates an optional
|
|
|
|
* ACPI register that is not supported, so no error message.
|
|
|
|
*/
|
|
|
|
ACPI_MOVE_64_TO_64(address, ®->address);
|
|
|
|
if (!(*address)) {
|
|
|
|
return (AE_BAD_ADDRESS);
|
|
|
|
}
|
|
|
|
|
2012-07-11 19:40:10 -06:00
|
|
|
/* Validate the space_ID */
|
2009-06-23 19:44:06 -06:00
|
|
|
|
|
|
|
if ((reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
|
|
|
|
(reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
|
|
|
|
ACPI_ERROR((AE_INFO,
|
|
|
|
"Unsupported address space: 0x%X", reg->space_id));
|
|
|
|
return (AE_SUPPORT);
|
|
|
|
}
|
|
|
|
|
2016-03-23 19:41:09 -06:00
|
|
|
/* Validate the access_width */
|
2009-06-23 19:44:06 -06:00
|
|
|
|
2016-03-23 19:41:09 -06:00
|
|
|
if (reg->access_width > 4) {
|
2009-06-23 19:44:06 -06:00
|
|
|
ACPI_ERROR((AE_INFO,
|
2016-03-23 19:41:09 -06:00
|
|
|
"Unsupported register access width: 0x%X",
|
|
|
|
reg->access_width));
|
2009-06-23 19:44:06 -06:00
|
|
|
return (AE_SUPPORT);
|
|
|
|
}
|
|
|
|
|
2016-03-23 19:41:09 -06:00
|
|
|
/* Validate the bit_width, convert access_width into number of bits */
|
2009-06-23 19:44:06 -06:00
|
|
|
|
2016-12-28 00:28:36 -07:00
|
|
|
access_width =
|
|
|
|
acpi_hw_get_access_bit_width(*address, reg, max_bit_width);
|
2016-03-23 19:41:09 -06:00
|
|
|
bit_width =
|
|
|
|
ACPI_ROUND_UP(reg->bit_offset + reg->bit_width, access_width);
|
|
|
|
if (max_bit_width < bit_width) {
|
2009-06-23 19:44:06 -06:00
|
|
|
ACPI_WARNING((AE_INFO,
|
2016-03-23 19:41:09 -06:00
|
|
|
"Requested bit width 0x%X is smaller than register bit width 0x%X",
|
|
|
|
max_bit_width, bit_width));
|
|
|
|
return (AE_SUPPORT);
|
2009-06-23 19:44:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return (AE_OK);
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_read
|
|
|
|
*
|
2012-07-11 19:40:10 -06:00
|
|
|
* PARAMETERS: value - Where the value is returned
|
|
|
|
* reg - GAS register structure
|
2009-06-23 19:44:06 -06:00
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
2017-09-19 20:00:11 -06:00
|
|
|
* DESCRIPTION: Read from either memory or IO space. This is a 64-bit max
|
|
|
|
* version of acpi_read.
|
2009-06-23 19:44:06 -06:00
|
|
|
*
|
|
|
|
* LIMITATIONS: <These limitations also apply to acpi_hw_write>
|
2012-07-11 19:40:10 -06:00
|
|
|
* space_ID must be system_memory or system_IO.
|
2009-06-23 19:44:06 -06:00
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2017-09-19 20:00:11 -06:00
|
|
|
acpi_status acpi_hw_read(u64 *value, struct acpi_generic_address *reg)
|
2009-06-23 19:44:06 -06:00
|
|
|
{
|
|
|
|
u64 address;
|
2016-05-04 22:58:52 -06:00
|
|
|
u8 access_width;
|
|
|
|
u32 bit_width;
|
|
|
|
u8 bit_offset;
|
2012-02-14 03:29:55 -07:00
|
|
|
u64 value64;
|
2016-05-04 22:58:52 -06:00
|
|
|
u32 value32;
|
|
|
|
u8 index;
|
2009-06-23 19:44:06 -06:00
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_NAME(hw_read);
|
|
|
|
|
|
|
|
/* Validate contents of the GAS register */
|
|
|
|
|
2017-09-19 20:00:11 -06:00
|
|
|
status = acpi_hw_validate_register(reg, 64, &address);
|
2009-06-23 19:44:06 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
2016-05-04 22:58:52 -06:00
|
|
|
/*
|
2017-09-19 20:00:11 -06:00
|
|
|
* Initialize entire 64-bit return value to zero, convert access_width
|
2016-05-04 22:58:52 -06:00
|
|
|
* into number of bits based
|
|
|
|
*/
|
2009-06-23 19:44:06 -06:00
|
|
|
*value = 0;
|
2017-09-19 20:00:11 -06:00
|
|
|
access_width = acpi_hw_get_access_bit_width(address, reg, 64);
|
2016-05-04 22:58:52 -06:00
|
|
|
bit_width = reg->bit_offset + reg->bit_width;
|
|
|
|
bit_offset = reg->bit_offset;
|
2009-06-23 19:44:06 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Two address spaces supported: Memory or IO. PCI_Config is
|
|
|
|
* not supported here because the GAS structure is insufficient
|
|
|
|
*/
|
2016-05-04 22:58:52 -06:00
|
|
|
index = 0;
|
|
|
|
while (bit_width) {
|
|
|
|
if (bit_offset >= access_width) {
|
2017-09-19 20:00:11 -06:00
|
|
|
value64 = 0;
|
2016-05-04 22:58:52 -06:00
|
|
|
bit_offset -= access_width;
|
|
|
|
} else {
|
|
|
|
if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
|
|
|
|
status =
|
|
|
|
acpi_os_read_memory((acpi_physical_address)
|
|
|
|
address +
|
|
|
|
index *
|
|
|
|
ACPI_DIV_8
|
|
|
|
(access_width),
|
|
|
|
&value64, access_width);
|
|
|
|
} else { /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
|
|
|
|
|
|
|
|
status = acpi_hw_read_port((acpi_io_address)
|
|
|
|
address +
|
|
|
|
index *
|
|
|
|
ACPI_DIV_8
|
|
|
|
(access_width),
|
|
|
|
&value32,
|
|
|
|
access_width);
|
2017-09-19 20:00:11 -06:00
|
|
|
value64 = (u64)value32;
|
2016-05-04 22:58:52 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use offset style bit writes because "Index * AccessWidth" is
|
2017-09-19 20:00:11 -06:00
|
|
|
* ensured to be less than 64-bits by acpi_hw_validate_register().
|
2016-05-04 22:58:52 -06:00
|
|
|
*/
|
|
|
|
ACPI_SET_BITS(value, index * access_width,
|
2017-09-19 20:00:11 -06:00
|
|
|
ACPI_MASK_BITS_ABOVE_64(access_width), value64);
|
2009-06-23 19:44:06 -06:00
|
|
|
|
2016-05-04 22:58:52 -06:00
|
|
|
bit_width -=
|
|
|
|
bit_width > access_width ? access_width : bit_width;
|
|
|
|
index++;
|
2009-06-23 19:44:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_IO,
|
2017-09-19 20:00:11 -06:00
|
|
|
"Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
|
|
|
|
ACPI_FORMAT_UINT64(*value), access_width,
|
|
|
|
ACPI_FORMAT_UINT64(address),
|
2009-06-23 19:44:06 -06:00
|
|
|
acpi_ut_get_region_name(reg->space_id)));
|
|
|
|
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_write
|
|
|
|
*
|
2012-07-11 19:40:10 -06:00
|
|
|
* PARAMETERS: value - Value to be written
|
|
|
|
* reg - GAS register structure
|
2009-06-23 19:44:06 -06:00
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
2017-09-19 20:00:11 -06:00
|
|
|
* DESCRIPTION: Write to either memory or IO space. This is a 64-bit max
|
|
|
|
* version of acpi_write.
|
2009-06-23 19:44:06 -06:00
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2017-09-19 20:00:11 -06:00
|
|
|
acpi_status acpi_hw_write(u64 value, struct acpi_generic_address *reg)
|
2009-06-23 19:44:06 -06:00
|
|
|
{
|
|
|
|
u64 address;
|
2016-12-28 00:28:23 -07:00
|
|
|
u8 access_width;
|
|
|
|
u32 bit_width;
|
|
|
|
u8 bit_offset;
|
|
|
|
u64 value64;
|
|
|
|
u8 index;
|
2009-06-23 19:44:06 -06:00
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_NAME(hw_write);
|
|
|
|
|
|
|
|
/* Validate contents of the GAS register */
|
|
|
|
|
2017-09-19 20:00:11 -06:00
|
|
|
status = acpi_hw_validate_register(reg, 64, &address);
|
2009-06-23 19:44:06 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
2016-12-28 00:28:23 -07:00
|
|
|
/* Convert access_width into number of bits based */
|
|
|
|
|
2017-09-19 20:00:11 -06:00
|
|
|
access_width = acpi_hw_get_access_bit_width(address, reg, 64);
|
2016-12-28 00:28:23 -07:00
|
|
|
bit_width = reg->bit_offset + reg->bit_width;
|
|
|
|
bit_offset = reg->bit_offset;
|
|
|
|
|
2009-06-23 19:44:06 -06:00
|
|
|
/*
|
|
|
|
* Two address spaces supported: Memory or IO. PCI_Config is
|
|
|
|
* not supported here because the GAS structure is insufficient
|
|
|
|
*/
|
2016-12-28 00:28:23 -07:00
|
|
|
index = 0;
|
|
|
|
while (bit_width) {
|
|
|
|
/*
|
|
|
|
* Use offset style bit reads because "Index * AccessWidth" is
|
2017-09-19 20:00:11 -06:00
|
|
|
* ensured to be less than 64-bits by acpi_hw_validate_register().
|
2016-12-28 00:28:23 -07:00
|
|
|
*/
|
2017-09-19 20:00:11 -06:00
|
|
|
value64 = ACPI_GET_BITS(&value, index * access_width,
|
|
|
|
ACPI_MASK_BITS_ABOVE_64(access_width));
|
2016-12-28 00:28:23 -07:00
|
|
|
|
|
|
|
if (bit_offset >= access_width) {
|
|
|
|
bit_offset -= access_width;
|
|
|
|
} else {
|
|
|
|
if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
|
|
|
|
status =
|
|
|
|
acpi_os_write_memory((acpi_physical_address)
|
|
|
|
address +
|
|
|
|
index *
|
|
|
|
ACPI_DIV_8
|
|
|
|
(access_width),
|
|
|
|
value64, access_width);
|
|
|
|
} else { /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
|
|
|
|
|
|
|
|
status = acpi_hw_write_port((acpi_io_address)
|
|
|
|
address +
|
|
|
|
index *
|
|
|
|
ACPI_DIV_8
|
|
|
|
(access_width),
|
2017-09-19 20:00:11 -06:00
|
|
|
(u32)value64,
|
2016-12-28 00:28:23 -07:00
|
|
|
access_width);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Index * access_width is ensured to be less than 32-bits by
|
|
|
|
* acpi_hw_validate_register().
|
|
|
|
*/
|
|
|
|
bit_width -=
|
|
|
|
bit_width > access_width ? access_width : bit_width;
|
|
|
|
index++;
|
2009-06-23 19:44:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_IO,
|
2017-09-19 20:00:11 -06:00
|
|
|
"Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n",
|
|
|
|
ACPI_FORMAT_UINT64(value), access_width,
|
|
|
|
ACPI_FORMAT_UINT64(address),
|
2009-06-23 19:44:06 -06:00
|
|
|
acpi_ut_get_region_name(reg->space_id)));
|
|
|
|
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
2012-02-14 03:14:27 -07:00
|
|
|
#if (!ACPI_REDUCED_HARDWARE)
|
2005-04-16 16:20:36 -06:00
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_clear_acpi_status
|
|
|
|
*
|
2007-02-02 09:48:21 -07:00
|
|
|
* PARAMETERS: None
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-12-29 20:04:48 -07:00
|
|
|
* RETURN: Status
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION: Clears all fixed and general purpose status bits
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
2009-02-17 23:20:12 -07:00
|
|
|
|
2007-02-02 09:48:21 -07:00
|
|
|
acpi_status acpi_hw_clear_acpi_status(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status;
|
2006-06-08 14:29:00 -06:00
|
|
|
acpi_cpu_flags lock_flags = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ACPI: ACPICA 20060421
Removed a device initialization optimization introduced in
20051216 where the _STA method was not run unless an _INI
was also present for the same device. This optimization
could cause problems because it could allow _INI methods
to be run within a not-present device subtree (If a
not-present device had no _INI, _STA would not be run,
the not-present status would not be discovered, and the
children of the device would be incorrectly traversed.)
Implemented a new _STA optimization where namespace
subtrees that do not contain _INI are identified and
ignored during device initialization. Selectively running
_STA can significantly improve boot time on large machines
(with assistance from Len Brown.)
Implemented support for the device initialization case
where the returned _STA flags indicate a device not-present
but functioning. In this case, _INI is not run, but the
device children are examined for presence, as per the
ACPI specification.
Implemented an additional change to the IndexField support
in order to conform to MS behavior. The value written to
the Index Register is not simply a byte offset, it is a
byte offset in units of the access width of the parent
Index Field. (Fiodor Suietov)
Defined and deployed a new OSL interface,
acpi_os_validate_address(). This interface is called during
the creation of all AML operation regions, and allows
the host OS to exert control over what addresses it will
allow the AML code to access. Operation Regions whose
addresses are disallowed will cause a runtime exception
when they are actually accessed (will not affect or abort
table loading.)
Defined and deployed a new OSL interface,
acpi_os_validate_interface(). This interface allows the host OS
to match the various "optional" interface/behavior strings
for the _OSI predefined control method as appropriate
(with assistance from Bjorn Helgaas.)
Restructured and corrected various problems in the
exception handling code paths within DsCallControlMethod
and DsTerminateControlMethod in dsmethod (with assistance
from Takayoshi Kochi.)
Modified the Linux source converter to ignore quoted string
literals while converting identifiers from mixed to lower
case. This will correct problems with the disassembler
and other areas where such strings must not be modified.
The ACPI_FUNCTION_* macros no longer require quotes around
the function name. This allows the Linux source converter
to convert the names, now that the converter ignores
quoted strings.
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2006-04-21 15:15:00 -06:00
|
|
|
ACPI_FUNCTION_TRACE(hw_clear_acpi_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-21 20:28:22 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n",
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_BITMASK_ALL_FIXED_STATUS,
|
2009-04-21 20:28:22 -06:00
|
|
|
ACPI_FORMAT_UINT64(acpi_gbl_xpm1a_status.address)));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-08 14:29:00 -06:00
|
|
|
lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-02-17 23:24:50 -07:00
|
|
|
/* Clear the fixed events in PM1 A/B */
|
2009-02-17 23:06:12 -07:00
|
|
|
|
2007-09-30 12:39:36 -06:00
|
|
|
status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_BITMASK_ALL_FIXED_STATUS);
|
2011-11-06 08:18:17 -07:00
|
|
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
|
|
|
|
|
2014-07-07 20:08:19 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2011-11-06 08:18:17 -07:00
|
|
|
goto exit;
|
2014-07-07 20:08:19 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Clear the GPE Bits in all GPE registers in all GPE blocks */
|
|
|
|
|
2008-12-29 18:45:17 -07:00
|
|
|
status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-11-06 08:18:17 -07:00
|
|
|
exit:
|
2005-08-04 22:44:28 -06:00
|
|
|
return_ACPI_STATUS(status);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
*
|
2012-02-14 03:14:27 -07:00
|
|
|
* FUNCTION: acpi_hw_get_bit_register_info
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* PARAMETERS: register_id - Index of ACPI Register to access
|
|
|
|
*
|
2005-04-18 20:49:35 -06:00
|
|
|
* RETURN: The bitmask to be used when accessing the register
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-04-18 20:49:35 -06:00
|
|
|
* DESCRIPTION: Map register_id into a register bitmask.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
******************************************************************************/
|
2008-12-29 20:04:48 -07:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-01-13 14:22:00 -07:00
|
|
|
ACPI_FUNCTION_ENTRY();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (register_id > ACPI_BITREG_MAX) {
|
2010-03-05 02:56:40 -07:00
|
|
|
ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: 0x%X",
|
2006-01-27 14:43:00 -07:00
|
|
|
register_id));
|
2005-04-16 16:20:36 -06:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (&acpi_gbl_bit_register_info[register_id]);
|
|
|
|
}
|
|
|
|
|
2009-02-17 23:36:05 -07:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_write_pm1_control
|
|
|
|
*
|
|
|
|
* PARAMETERS: pm1a_control - Value to be written to PM1A control
|
|
|
|
* pm1b_control - Value to be written to PM1B control
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Write the PM1 A/B control registers. These registers are
|
|
|
|
* different than than the PM1 A/B status and enable registers
|
|
|
|
* in that different values can be written to the A/B registers.
|
|
|
|
* Most notably, the SLP_TYP bits can be different, as per the
|
|
|
|
* values returned from the _Sx predefined methods.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
acpi_status acpi_hw_write_pm1_control(u32 pm1a_control, u32 pm1b_control)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(hw_write_pm1_control);
|
|
|
|
|
2009-06-23 19:44:06 -06:00
|
|
|
status =
|
|
|
|
acpi_hw_write(pm1a_control, &acpi_gbl_FADT.xpm1a_control_block);
|
2009-02-17 23:36:05 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (acpi_gbl_FADT.xpm1b_control_block.address) {
|
|
|
|
status =
|
2009-06-23 19:44:06 -06:00
|
|
|
acpi_hw_write(pm1b_control,
|
|
|
|
&acpi_gbl_FADT.xpm1b_control_block);
|
2009-02-17 23:36:05 -07:00
|
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_register_read
|
|
|
|
*
|
2007-09-30 12:39:36 -06:00
|
|
|
* PARAMETERS: register_id - ACPI Register ID
|
2005-04-18 20:49:35 -06:00
|
|
|
* return_value - Where the register value is returned
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* RETURN: Status and the value read.
|
|
|
|
*
|
2006-06-23 15:04:00 -06:00
|
|
|
* DESCRIPTION: Read from the specified ACPI register
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
******************************************************************************/
|
2012-12-18 22:37:15 -07:00
|
|
|
acpi_status acpi_hw_register_read(u32 register_id, u32 *return_value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-02-17 23:20:12 -07:00
|
|
|
u32 value = 0;
|
2017-09-19 20:00:11 -06:00
|
|
|
u64 value64;
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ACPI: ACPICA 20060421
Removed a device initialization optimization introduced in
20051216 where the _STA method was not run unless an _INI
was also present for the same device. This optimization
could cause problems because it could allow _INI methods
to be run within a not-present device subtree (If a
not-present device had no _INI, _STA would not be run,
the not-present status would not be discovered, and the
children of the device would be incorrectly traversed.)
Implemented a new _STA optimization where namespace
subtrees that do not contain _INI are identified and
ignored during device initialization. Selectively running
_STA can significantly improve boot time on large machines
(with assistance from Len Brown.)
Implemented support for the device initialization case
where the returned _STA flags indicate a device not-present
but functioning. In this case, _INI is not run, but the
device children are examined for presence, as per the
ACPI specification.
Implemented an additional change to the IndexField support
in order to conform to MS behavior. The value written to
the Index Register is not simply a byte offset, it is a
byte offset in units of the access width of the parent
Index Field. (Fiodor Suietov)
Defined and deployed a new OSL interface,
acpi_os_validate_address(). This interface is called during
the creation of all AML operation regions, and allows
the host OS to exert control over what addresses it will
allow the AML code to access. Operation Regions whose
addresses are disallowed will cause a runtime exception
when they are actually accessed (will not affect or abort
table loading.)
Defined and deployed a new OSL interface,
acpi_os_validate_interface(). This interface allows the host OS
to match the various "optional" interface/behavior strings
for the _OSI predefined control method as appropriate
(with assistance from Bjorn Helgaas.)
Restructured and corrected various problems in the
exception handling code paths within DsCallControlMethod
and DsTerminateControlMethod in dsmethod (with assistance
from Takayoshi Kochi.)
Modified the Linux source converter to ignore quoted string
literals while converting identifiers from mixed to lower
case. This will correct problems with the disassembler
and other areas where such strings must not be modified.
The ACPI_FUNCTION_* macros no longer require quotes around
the function name. This allows the Linux source converter
to convert the names, now that the converter ignores
quoted strings.
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2006-04-21 15:15:00 -06:00
|
|
|
ACPI_FUNCTION_TRACE(hw_register_read);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (register_id) {
|
2009-02-17 23:20:12 -07:00
|
|
|
case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
status = acpi_hw_read_multiple(&value,
|
|
|
|
&acpi_gbl_xpm1a_status,
|
|
|
|
&acpi_gbl_xpm1b_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
status = acpi_hw_read_multiple(&value,
|
|
|
|
&acpi_gbl_xpm1a_enable,
|
|
|
|
&acpi_gbl_xpm1b_enable);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
status = acpi_hw_read_multiple(&value,
|
|
|
|
&acpi_gbl_FADT.
|
|
|
|
xpm1a_control_block,
|
|
|
|
&acpi_gbl_FADT.
|
|
|
|
xpm1b_control_block);
|
2009-03-18 19:51:01 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Zero the write-only bits. From the ACPI specification, "Hardware
|
|
|
|
* Write-Only Bits": "Upon reads to registers with write-only bits,
|
|
|
|
* software masks out all write-only bits."
|
|
|
|
*/
|
|
|
|
value &= ~ACPI_PM1_CONTROL_WRITEONLY_BITS;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-23 19:44:06 -06:00
|
|
|
status =
|
2017-09-19 20:00:11 -06:00
|
|
|
acpi_hw_read(&value64, &acpi_gbl_FADT.xpm2_control_block);
|
|
|
|
value = (u32)value64;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-09-19 20:00:11 -06:00
|
|
|
status = acpi_hw_read(&value64, &acpi_gbl_FADT.xpm_timer_block);
|
|
|
|
value = (u32)value64;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:18 -07:00
|
|
|
status =
|
2009-03-18 19:37:47 -06:00
|
|
|
acpi_hw_read_port(acpi_gbl_FADT.smi_command, &value, 8);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2013-06-07 18:58:14 -06:00
|
|
|
|
2010-03-05 02:56:40 -07:00
|
|
|
ACPI_ERROR((AE_INFO, "Unknown Register ID: 0x%X", register_id));
|
2005-04-16 16:20:36 -06:00
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
if (ACPI_SUCCESS(status)) {
|
2017-09-19 20:00:11 -06:00
|
|
|
*return_value = (u32)value;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
return_ACPI_STATUS(status);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_register_write
|
|
|
|
*
|
2007-09-30 12:39:36 -06:00
|
|
|
* PARAMETERS: register_id - ACPI Register ID
|
2012-07-11 19:40:10 -06:00
|
|
|
* value - The value to write
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
2006-06-23 15:04:00 -06:00
|
|
|
* DESCRIPTION: Write to the specified ACPI register
|
|
|
|
*
|
|
|
|
* NOTE: In accordance with the ACPI specification, this function automatically
|
|
|
|
* preserves the value of the following bits, meaning that these bits cannot be
|
|
|
|
* changed via this interface:
|
|
|
|
*
|
|
|
|
* PM1_CONTROL[0] = SCI_EN
|
|
|
|
* PM1_CONTROL[9]
|
|
|
|
* PM1_STATUS[11]
|
|
|
|
*
|
|
|
|
* ACPI References:
|
|
|
|
* 1) Hardware Ignored Bits: When software writes to a register with ignored
|
|
|
|
* bit fields, it preserves the ignored bit fields
|
|
|
|
* 2) SCI_EN: OSPM always preserves this bit position
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2007-09-30 12:39:36 -06:00
|
|
|
acpi_status acpi_hw_register_write(u32 register_id, u32 value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status;
|
2006-06-23 15:04:00 -06:00
|
|
|
u32 read_value;
|
2017-09-19 20:00:11 -06:00
|
|
|
u64 read_value64;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ACPI: ACPICA 20060421
Removed a device initialization optimization introduced in
20051216 where the _STA method was not run unless an _INI
was also present for the same device. This optimization
could cause problems because it could allow _INI methods
to be run within a not-present device subtree (If a
not-present device had no _INI, _STA would not be run,
the not-present status would not be discovered, and the
children of the device would be incorrectly traversed.)
Implemented a new _STA optimization where namespace
subtrees that do not contain _INI are identified and
ignored during device initialization. Selectively running
_STA can significantly improve boot time on large machines
(with assistance from Len Brown.)
Implemented support for the device initialization case
where the returned _STA flags indicate a device not-present
but functioning. In this case, _INI is not run, but the
device children are examined for presence, as per the
ACPI specification.
Implemented an additional change to the IndexField support
in order to conform to MS behavior. The value written to
the Index Register is not simply a byte offset, it is a
byte offset in units of the access width of the parent
Index Field. (Fiodor Suietov)
Defined and deployed a new OSL interface,
acpi_os_validate_address(). This interface is called during
the creation of all AML operation regions, and allows
the host OS to exert control over what addresses it will
allow the AML code to access. Operation Regions whose
addresses are disallowed will cause a runtime exception
when they are actually accessed (will not affect or abort
table loading.)
Defined and deployed a new OSL interface,
acpi_os_validate_interface(). This interface allows the host OS
to match the various "optional" interface/behavior strings
for the _OSI predefined control method as appropriate
(with assistance from Bjorn Helgaas.)
Restructured and corrected various problems in the
exception handling code paths within DsCallControlMethod
and DsTerminateControlMethod in dsmethod (with assistance
from Takayoshi Kochi.)
Modified the Linux source converter to ignore quoted string
literals while converting identifiers from mixed to lower
case. This will correct problems with the disassembler
and other areas where such strings must not be modified.
The ACPI_FUNCTION_* macros no longer require quotes around
the function name. This allows the Linux source converter
to convert the names, now that the converter ignores
quoted strings.
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2006-04-21 15:15:00 -06:00
|
|
|
ACPI_FUNCTION_TRACE(hw_register_write);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (register_id) {
|
2009-02-17 23:20:12 -07:00
|
|
|
case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
|
2009-03-09 02:32:20 -06:00
|
|
|
/*
|
|
|
|
* Handle the "ignored" bit in PM1 Status. According to the ACPI
|
|
|
|
* specification, ignored bits are to be preserved when writing.
|
|
|
|
* Normally, this would mean a read/modify/write sequence. However,
|
|
|
|
* preserving a bit in the status register is different. Writing a
|
|
|
|
* one clears the status, and writing a zero preserves the status.
|
|
|
|
* Therefore, we must always write zero to the ignored bit.
|
|
|
|
*
|
|
|
|
* This behavior is clarified in the ACPI 4.0 specification.
|
|
|
|
*/
|
|
|
|
value &= ~ACPI_PM1_STATUS_PRESERVED_BITS;
|
2006-06-23 15:04:00 -06:00
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
status = acpi_hw_write_multiple(value,
|
|
|
|
&acpi_gbl_xpm1a_status,
|
|
|
|
&acpi_gbl_xpm1b_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2012-12-18 22:36:49 -07:00
|
|
|
case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
status = acpi_hw_write_multiple(value,
|
|
|
|
&acpi_gbl_xpm1a_enable,
|
|
|
|
&acpi_gbl_xpm1b_enable);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
|
2006-06-23 15:04:00 -06:00
|
|
|
/*
|
|
|
|
* Perform a read first to preserve certain bits (per ACPI spec)
|
2009-02-17 23:20:12 -07:00
|
|
|
* Note: This includes SCI_EN, we never want to change this bit
|
2006-06-23 15:04:00 -06:00
|
|
|
*/
|
2009-02-17 23:20:12 -07:00
|
|
|
status = acpi_hw_read_multiple(&read_value,
|
|
|
|
&acpi_gbl_FADT.
|
|
|
|
xpm1a_control_block,
|
|
|
|
&acpi_gbl_FADT.
|
|
|
|
xpm1b_control_block);
|
2006-06-23 15:04:00 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2007-09-30 12:39:36 -06:00
|
|
|
goto exit;
|
2006-06-23 15:04:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Insert the bits to be preserved */
|
|
|
|
|
|
|
|
ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS,
|
|
|
|
read_value);
|
|
|
|
|
|
|
|
/* Now we can write the data */
|
|
|
|
|
2009-02-17 23:20:12 -07:00
|
|
|
status = acpi_hw_write_multiple(value,
|
|
|
|
&acpi_gbl_FADT.
|
|
|
|
xpm1a_control_block,
|
|
|
|
&acpi_gbl_FADT.
|
|
|
|
xpm1b_control_block);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
|
2009-03-12 19:10:46 -06:00
|
|
|
/*
|
|
|
|
* For control registers, all reserved bits must be preserved,
|
|
|
|
* as per the ACPI spec.
|
|
|
|
*/
|
|
|
|
status =
|
2017-09-19 20:00:11 -06:00
|
|
|
acpi_hw_read(&read_value64,
|
2009-06-23 19:44:06 -06:00
|
|
|
&acpi_gbl_FADT.xpm2_control_block);
|
2009-03-12 19:10:46 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
goto exit;
|
|
|
|
}
|
2017-09-19 20:00:11 -06:00
|
|
|
read_value = (u32)read_value64;
|
2009-03-12 19:10:46 -06:00
|
|
|
|
|
|
|
/* Insert the bits to be preserved */
|
|
|
|
|
|
|
|
ACPI_INSERT_BITS(value, ACPI_PM2_CONTROL_PRESERVED_BITS,
|
|
|
|
read_value);
|
|
|
|
|
2009-06-23 19:44:06 -06:00
|
|
|
status =
|
|
|
|
acpi_hw_write(value, &acpi_gbl_FADT.xpm2_control_block);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-23 19:44:06 -06:00
|
|
|
status = acpi_hw_write(value, &acpi_gbl_FADT.xpm_timer_block);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* SMI_CMD is currently always in IO space */
|
|
|
|
|
2007-02-02 09:48:18 -07:00
|
|
|
status =
|
2009-03-18 19:37:47 -06:00
|
|
|
acpi_hw_write_port(acpi_gbl_FADT.smi_command, value, 8);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2013-06-07 18:58:14 -06:00
|
|
|
|
2010-03-05 02:56:40 -07:00
|
|
|
ACPI_ERROR((AE_INFO, "Unknown Register ID: 0x%X", register_id));
|
2005-04-16 16:20:36 -06:00
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-10-28 19:30:02 -06:00
|
|
|
exit:
|
2005-08-04 22:44:28 -06:00
|
|
|
return_ACPI_STATUS(status);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-02-17 23:20:12 -07:00
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_read_multiple
|
|
|
|
*
|
2012-07-11 19:40:10 -06:00
|
|
|
* PARAMETERS: value - Where the register value is returned
|
2009-02-17 23:20:12 -07:00
|
|
|
* register_a - First ACPI register (required)
|
|
|
|
* register_b - Second ACPI register (optional)
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Read from the specified two-part ACPI register (such as PM1 A/B)
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
static acpi_status
|
|
|
|
acpi_hw_read_multiple(u32 *value,
|
|
|
|
struct acpi_generic_address *register_a,
|
|
|
|
struct acpi_generic_address *register_b)
|
|
|
|
{
|
|
|
|
u32 value_a = 0;
|
|
|
|
u32 value_b = 0;
|
2017-09-19 20:00:11 -06:00
|
|
|
u64 value64;
|
2009-02-17 23:20:12 -07:00
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
/* The first register is always required */
|
|
|
|
|
2017-09-19 20:00:11 -06:00
|
|
|
status = acpi_hw_read(&value64, register_a);
|
2009-02-17 23:20:12 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
return (status);
|
|
|
|
}
|
2017-09-19 20:00:11 -06:00
|
|
|
value_a = (u32)value64;
|
2009-02-17 23:20:12 -07:00
|
|
|
|
|
|
|
/* Second register is optional */
|
|
|
|
|
|
|
|
if (register_b->address) {
|
2017-09-19 20:00:11 -06:00
|
|
|
status = acpi_hw_read(&value64, register_b);
|
2009-02-17 23:20:12 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
return (status);
|
|
|
|
}
|
2017-09-19 20:00:11 -06:00
|
|
|
value_b = (u32)value64;
|
2009-02-17 23:20:12 -07:00
|
|
|
}
|
|
|
|
|
2009-02-17 23:26:02 -07:00
|
|
|
/*
|
|
|
|
* OR the two return values together. No shifting or masking is necessary,
|
|
|
|
* because of how the PM1 registers are defined in the ACPI specification:
|
|
|
|
*
|
|
|
|
* "Although the bits can be split between the two register blocks (each
|
|
|
|
* register block has a unique pointer within the FADT), the bit positions
|
|
|
|
* are maintained. The register block with unimplemented bits (that is,
|
|
|
|
* those implemented in the other register block) always returns zeros,
|
|
|
|
* and writes have no side effects"
|
|
|
|
*/
|
|
|
|
*value = (value_a | value_b);
|
2009-02-17 23:20:12 -07:00
|
|
|
return (AE_OK);
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_hw_write_multiple
|
|
|
|
*
|
2012-07-11 19:40:10 -06:00
|
|
|
* PARAMETERS: value - The value to write
|
2009-02-17 23:20:12 -07:00
|
|
|
* register_a - First ACPI register (required)
|
|
|
|
* register_b - Second ACPI register (optional)
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Write to the specified two-part ACPI register (such as PM1 A/B)
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
static acpi_status
|
|
|
|
acpi_hw_write_multiple(u32 value,
|
|
|
|
struct acpi_generic_address *register_a,
|
|
|
|
struct acpi_generic_address *register_b)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
/* The first register is always required */
|
|
|
|
|
2009-06-23 19:44:06 -06:00
|
|
|
status = acpi_hw_write(value, register_a);
|
2009-02-17 23:20:12 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
2009-02-17 23:26:02 -07:00
|
|
|
/*
|
|
|
|
* Second register is optional
|
|
|
|
*
|
|
|
|
* No bit shifting or clearing is necessary, because of how the PM1
|
|
|
|
* registers are defined in the ACPI specification:
|
|
|
|
*
|
|
|
|
* "Although the bits can be split between the two register blocks (each
|
|
|
|
* register block has a unique pointer within the FADT), the bit positions
|
|
|
|
* are maintained. The register block with unimplemented bits (that is,
|
|
|
|
* those implemented in the other register block) always returns zeros,
|
|
|
|
* and writes have no side effects"
|
|
|
|
*/
|
2009-02-17 23:20:12 -07:00
|
|
|
if (register_b->address) {
|
2009-06-23 19:44:06 -06:00
|
|
|
status = acpi_hw_write(value, register_b);
|
2009-02-17 23:20:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return (status);
|
|
|
|
}
|
2012-02-14 03:14:27 -07:00
|
|
|
|
|
|
|
#endif /* !ACPI_REDUCED_HARDWARE */
|