/******************************************************************************
*
* Module Name: aeregion - Handler for operation regions
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2018, Intel Corp.
* 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 "aecommon.h"
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("aeregion")
static AE_DEBUG_REGIONS AeRegions;
/******************************************************************************
*
* FUNCTION: AeRegionHandler
*
* PARAMETERS: Standard region handler parameters
*
* RETURN: Status
*
* DESCRIPTION: Test handler - Handles some dummy regions via memory that can
* be manipulated in Ring 3. Simulates actual reads and writes.
*
*****************************************************************************/
ACPI_STATUS
AeRegionHandler (
UINT32 Function,
ACPI_PHYSICAL_ADDRESS Address,
UINT32 BitWidth,
UINT64 *Value,
void *HandlerContext,
void *RegionContext)
{
ACPI_OPERAND_OBJECT *RegionObject = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, RegionContext);
UINT8 *Buffer = ACPI_CAST_PTR (UINT8, Value);
UINT8 *OldBuffer;
UINT8 *NewBuffer;
ACPI_PHYSICAL_ADDRESS BaseAddress;
ACPI_PHYSICAL_ADDRESS BaseAddressEnd;
ACPI_PHYSICAL_ADDRESS RegionAddress;
ACPI_PHYSICAL_ADDRESS RegionAddressEnd;
ACPI_SIZE Length;
BOOLEAN BufferExists;
BOOLEAN BufferResize;
AE_REGION *RegionElement;
void *BufferValue;
ACPI_STATUS Status;
UINT32 ByteWidth;
UINT32 RegionLength;
UINT32 i;
UINT8 SpaceId;
ACPI_CONNECTION_INFO *MyContext;
UINT32 Value1;
UINT32 Value2;
ACPI_RESOURCE *Resource;
ACPI_FUNCTION_NAME (AeRegionHandler);
/*
* If the object is not a region, simply return
*/
if (RegionObject->Region.Type != ACPI_TYPE_REGION)
{
return (AE_OK);
}
/* Check that we actually got back our context parameter */
if (HandlerContext != &AeMyContext)
{
printf ("Region handler received incorrect context %p, should be %p\n",
HandlerContext, &AeMyContext);
}
MyContext = ACPI_CAST_PTR (ACPI_CONNECTION_INFO, HandlerContext);
/*
* Find the region's address space and length before searching
* the linked list.
*/
BaseAddress = RegionObject->Region.Address;
Length = (ACPI_SIZE) RegionObject->Region.Length;
SpaceId = RegionObject->Region.SpaceId;
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Operation Region request on %s at 0x%X\n",
AcpiUtGetRegionName (RegionObject->Region.SpaceId),
(UINT32) Address));
/*
* Region support can be disabled with the -do option.
* We use this to support dynamically loaded tables where we pass a valid
* address to the AML.
*/
if (AcpiGbl_DbOpt_NoRegionSupport)
{
BufferValue = ACPI_TO_POINTER (Address);
ByteWidth = (BitWidth / 8);
if (BitWidth % 8)
{
ByteWidth += 1;
}
goto DoFunction;
}
switch (SpaceId)
{
case ACPI_ADR_SPACE_SYSTEM_IO:
/*
* For I/O space, exercise the port validation
* Note: ReadPort currently always returns all ones, length=BitLength
*/
switch (Function & ACPI_IO_MASK)
{
case ACPI_READ:
if (BitWidth == 64)
{
/* Split the 64-bit request into two 32-bit requests */
Status = AcpiHwReadPort (Address, &Value1, 32);
ACPI_CHECK_OK (AcpiHwReadPort, Status);
Status = AcpiHwReadPort (Address+4, &Value2, 32);
ACPI_CHECK_OK (AcpiHwReadPort, Status);
*Value = Value1 | ((UINT64) Value2 << 32);
}
else
{
Status = AcpiHwReadPort (Address, &Value1, BitWidth);
ACPI_CHECK_OK (AcpiHwReadPort, Status);
*Value = (UINT64) Value1;
}
break;
case ACPI_WRITE:
if (BitWidth == 64)
{
/* Split the 64-bit request into two 32-bit requests */
Status = AcpiHwWritePort (Address, ACPI_LODWORD (*Value), 32);
ACPI_CHECK_OK (AcpiHwWritePort, Status);
Status = AcpiHwWritePort (Address+4, ACPI_HIDWORD (*Value), 32);
ACPI_CHECK_OK (AcpiHwWritePort, Status);
}
else
{
Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth);
ACPI_CHECK_OK (AcpiHwWritePort, Status);
}
break;
default:
Status = AE_BAD_PARAMETER;
break;
}
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Now go ahead and simulate the hardware */
break;
/*
* SMBus and GenericSerialBus support the various bidirectional
* protocols.
*/
case ACPI_ADR_SPACE_SMBUS:
case ACPI_ADR_SPACE_GSBUS: /* ACPI 5.0 */
Length = 0;
switch (Function & ACPI_IO_MASK)
{
case ACPI_READ:
switch (Function >> 16)
{
case AML_FIELD_ATTRIB_QUICK:
Length = 0;
break;
case AML_FIELD_ATTRIB_SEND_RCV:
case AML_FIELD_ATTRIB_BYTE:
Length = 1;
break;
case AML_FIELD_ATTRIB_WORD:
case AML_FIELD_ATTRIB_WORD_CALL:
Length = 2;
break;
case AML_FIELD_ATTRIB_BLOCK:
case AML_FIELD_ATTRIB_BLOCK_CALL:
Length = 32;
break;
case AML_FIELD_ATTRIB_MULTIBYTE:
case AML_FIELD_ATTRIB_RAW_BYTES:
case AML_FIELD_ATTRIB_RAW_PROCESS:
Length = MyContext->AccessLength;
break;
default:
break;
}
break;
case ACPI_WRITE:
switch (Function >> 16)
{
case AML_FIELD_ATTRIB_QUICK:
case AML_FIELD_ATTRIB_SEND_RCV:
case AML_FIELD_ATTRIB_BYTE:
case AML_FIELD_ATTRIB_WORD:
case AML_FIELD_ATTRIB_BLOCK:
Length = 0;
break;
case AML_FIELD_ATTRIB_WORD_CALL:
Length = 2;
break;
case AML_FIELD_ATTRIB_BLOCK_CALL:
Length = 32;
break;
case AML_FIELD_ATTRIB_MULTIBYTE:
case AML_FIELD_ATTRIB_RAW_BYTES:
case AML_FIELD_ATTRIB_RAW_PROCESS:
Length = MyContext->AccessLength;
break;
default:
break;
}
break;
default:
break;
}
if (AcpiGbl_DisplayRegionAccess)
{
AcpiOsPrintf ("AcpiExec: %s "
"%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X",
AcpiUtGetRegionName (SpaceId),
(Function & ACPI_IO_MASK) ? "Write" : "Read ",
(UINT32) (Function >> 16),
(UINT32) Address, (UINT32) BaseAddress,
Length, BitWidth, Buffer[1]);
/* GenericSerialBus has a Connection() parameter */
if (SpaceId == ACPI_ADR_SPACE_GSBUS)
{
Status = AcpiBufferToResource (MyContext->Connection,
MyContext->Length, &Resource);
AcpiOsPrintf (" [AccLen %.2X Conn %p]",
MyContext->AccessLength, MyContext->Connection);
}
AcpiOsPrintf ("\n");
}
/* Setup the return buffer. Note: ASLTS depends on these fill values */
for (i = 0; i < Length; i++)
{
Buffer[i+2] = (UINT8) (0xA0 + i);
}
Buffer[0] = 0x7A;
Buffer[1] = (UINT8) Length;
return (AE_OK);
case ACPI_ADR_SPACE_IPMI: /* ACPI 4.0 */
if (AcpiGbl_DisplayRegionAccess)
{
AcpiOsPrintf ("AcpiExec: IPMI "
"%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X\n",
(Function & ACPI_IO_MASK) ? "Write" : "Read ",
(UINT32) (Function >> 16), (UINT32) Address, (UINT32) BaseAddress,
Length, BitWidth, Buffer[1]);
}
/*
* Regardless of a READ or WRITE, this handler is passed a 66-byte
* buffer in which to return the IPMI status/length/data.
*
* Return some example data to show use of the bidirectional buffer
*/
Buffer[0] = 0; /* Status byte */
Buffer[1] = 64; /* Return buffer data length */
Buffer[2] = 0; /* Completion code */
Buffer[3] = 0; /* Reserved */
/*
* Fill the 66-byte buffer with the return data.
* Note: ASLTS depends on these fill values.
*/
for (i = 4; i < 66; i++)
{
Buffer[i] = (UINT8) (i);
}
return (AE_OK);
/*
* GPIO has some special semantics:
* 1) Address is the pin number index into the Connection() pin list
* 2) BitWidth is the actual number of bits (pins) defined by the field
*/
case ACPI_ADR_SPACE_GPIO: /* ACPI 5.0 */
if (AcpiGbl_DisplayRegionAccess)
{
AcpiOsPrintf ("AcpiExec: GPIO "
"%s: Addr %.4X Width %X Conn %p\n",
(Function & ACPI_IO_MASK) ? "Write" : "Read ",
(UINT32) Address, BitWidth, MyContext->Connection);
}
return (AE_OK);
default:
break;
}
/*
* Search through the linked list for this region's buffer
*/
BufferExists = FALSE;
BufferResize = FALSE;
RegionElement = AeRegions.RegionList;
if (AeRegions.NumberOfRegions)
{
BaseAddressEnd = BaseAddress + Length - 1;
while (!BufferExists && RegionElement)
{
RegionAddress = RegionElement->Address;
RegionAddressEnd = RegionElement->Address + RegionElement->Length - 1;
RegionLength = RegionElement->Length;
/*
* Overlapping Region Support
*
* While searching through the region buffer list, determine if an
* overlap exists between the requested buffer space and the current
* RegionElement space. If there is an overlap then replace the old
* buffer with a new buffer of increased size before continuing to
* do the read or write
*/
if (RegionElement->SpaceId != SpaceId ||
BaseAddressEnd < RegionAddress ||
BaseAddress > RegionAddressEnd)
{
/*
* Requested buffer is outside of the current RegionElement
* bounds
*/
RegionElement = RegionElement->NextRegion;
}
else
{
/*
* Some amount of buffer space sharing exists. There are 4 cases
* to consider:
*
* 1. Right overlap
* 2. Left overlap
* 3. Left and right overlap
* 4. Fully contained - no resizing required
*/
BufferExists = TRUE;
if ((BaseAddress >= RegionAddress) &&
(BaseAddress <= RegionAddressEnd) &&
(BaseAddressEnd > RegionAddressEnd))
{
/* Right overlap */
RegionElement->Length = (UINT32) (BaseAddress -
RegionAddress + Length);
BufferResize = TRUE;
}
else if ((BaseAddressEnd >= RegionAddress) &&
(BaseAddressEnd <= RegionAddressEnd) &&
(BaseAddress < RegionAddress))
{
/* Left overlap */
RegionElement->Address = BaseAddress;
RegionElement->Length = (UINT32) (RegionAddress -
BaseAddress + RegionElement->Length);
BufferResize = TRUE;
}
else if ((BaseAddress < RegionAddress) &&
(BaseAddressEnd > RegionAddressEnd))
{
/* Left and right overlap */
RegionElement->Address = BaseAddress;
RegionElement->Length = Length;
BufferResize = TRUE;
}
/*
* only remaining case is fully contained for which we don't
* need to do anything
*/
if (BufferResize)
{
NewBuffer = AcpiOsAllocate (RegionElement->Length);
if (!NewBuffer)
{
return (AE_NO_MEMORY);
}
OldBuffer = RegionElement->Buffer;
RegionElement->Buffer = NewBuffer;
NewBuffer = NULL;
/* Initialize the region with the default fill value */
memset (RegionElement->Buffer,
AcpiGbl_RegionFillValue, RegionElement->Length);
/*
* Get BufferValue to point (within the new buffer) to the
* base address of the old buffer
*/
BufferValue = (UINT8 *) RegionElement->Buffer +
(UINT64) RegionAddress -
(UINT64) RegionElement->Address;
/*
* Copy the old buffer to its same location within the new
* buffer
*/
memcpy (BufferValue, OldBuffer, RegionLength);
AcpiOsFree (OldBuffer);
}
}
}
}
/*
* If the Region buffer does not exist, create it now
*/
if (!BufferExists)
{
/* Do the memory allocations first */
RegionElement = AcpiOsAllocate (sizeof (AE_REGION));
if (!RegionElement)
{
return (AE_NO_MEMORY);
}
RegionElement->Buffer = AcpiOsAllocate (Length);
if (!RegionElement->Buffer)
{
AcpiOsFree (RegionElement);
return (AE_NO_MEMORY);
}
/* Initialize the region with the default fill value */
memset (RegionElement->Buffer, AcpiGbl_RegionFillValue, Length);
RegionElement->Address = BaseAddress;
RegionElement->Length = Length;
RegionElement->SpaceId = SpaceId;
RegionElement->NextRegion = NULL;
/*
* Increment the number of regions and put this one
* at the head of the list as it will probably get accessed
* more often anyway.
*/
AeRegions.NumberOfRegions += 1;
if (AeRegions.RegionList)
{
RegionElement->NextRegion = AeRegions.RegionList;
}
AeRegions.RegionList = RegionElement;
}
/* Calculate the size of the memory copy */
ByteWidth = (BitWidth / 8);
if (BitWidth % 8)
{
ByteWidth += 1;
}
/*
* The buffer exists and is pointed to by RegionElement.
* We now need to verify the request is valid and perform the operation.
*
* NOTE: RegionElement->Length is in bytes, therefore it we compare against
* ByteWidth (see above)
*/
if ((RegionObject->Region.SpaceId != ACPI_ADR_SPACE_GPIO) &&
((UINT64) Address + ByteWidth) >
((UINT64)(RegionElement->Address) + RegionElement->Length))
{
ACPI_WARNING ((AE_INFO,
"Request on [%4.4s] is beyond region limit "
"Req-0x%X+0x%X, Base=0x%X, Len-0x%X",
(RegionObject->Region.Node)->Name.Ascii, (UINT32) Address,
ByteWidth, (UINT32)(RegionElement->Address),
RegionElement->Length));
return (AE_AML_REGION_LIMIT);
}
/*
* Get BufferValue to point to the "address" in the buffer
*/
BufferValue = ((UINT8 *) RegionElement->Buffer +
((UINT64) Address - (UINT64) RegionElement->Address));
DoFunction:
/*
* Perform a read or write to the buffer space
*/
switch (Function)
{
case ACPI_READ:
/*
* Set the pointer Value to whatever is in the buffer
*/
memcpy (Value, BufferValue, ByteWidth);
break;
case ACPI_WRITE:
/*
* Write the contents of Value to the buffer
*/
memcpy (BufferValue, Value, ByteWidth);
break;
default:
return (AE_BAD_PARAMETER);
}
if (AcpiGbl_DisplayRegionAccess)
{
switch (SpaceId)
{
case ACPI_ADR_SPACE_SYSTEM_MEMORY:
AcpiOsPrintf ("AcpiExec: SystemMemory "
"%s: Val %.8X Addr %.4X Width %X [REGION: BaseAddr %.4X Len %.2X]\n",
(Function & ACPI_IO_MASK) ? "Write" : "Read ",
(UINT32) *Value, (UINT32) Address, BitWidth, (UINT32) BaseAddress, Length);
break;
case ACPI_ADR_SPACE_GPIO: /* ACPI 5.0 */
/* This space is required to always be ByteAcc */
Status = AcpiBufferToResource (MyContext->Connection,
MyContext->Length, &Resource);
AcpiOsPrintf ("AcpiExec: GeneralPurposeIo "
"%s: Val %.8X Addr %.4X BaseAddr %.4X Len %.2X Width %X AccLen %.2X Conn %p\n",
(Function & ACPI_IO_MASK) ? "Write" : "Read ", (UINT32) *Value,
(UINT32) Address, (UINT32) BaseAddress, Length, BitWidth,
MyContext->AccessLength, MyContext->Connection);
break;
default:
break;
}
}
return (AE_OK);
}