static ACPI_STATUS
AcpiDbDisplayNonRootHandlers (
ACPI_HANDLE ObjHandle,
UINT32 NestingLevel,
void *Context,
void **ReturnValue)
{
ACPI_NAMESPACE_NODE *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
char *Pathname;
ObjDesc = AcpiNsGetAttachedObject (Node);
if (!ObjDesc)
{
return (AE_OK);
}
Pathname = AcpiNsGetNormalizedPathname (Node, TRUE);
if (!Pathname)
{
return (AE_OK);
}
/* Display all handlers associated with this device */
HandlerObj = ObjDesc->Device.Handler;
while (HandlerObj)
{
AcpiOsPrintf (ACPI_PREDEFINED_PREFIX,
AcpiUtGetRegionName ((UINT8) HandlerObj->AddressSpace.SpaceId),
HandlerObj->AddressSpace.SpaceId);
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING2,
(HandlerObj->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default" : "User",
HandlerObj->AddressSpace.Handler);
AcpiOsPrintf (" Device Name: %s (%p)\n", Pathname, Node);
HandlerObj = HandlerObj->AddressSpace.Next;
}
ACPI_FREE (Pathname);
return (AE_OK);
}
ACPI_STATUS
AcpiHwWrite (
UINT32 Value,
ACPI_GENERIC_ADDRESS *Reg)
{
UINT64 Address;
ACPI_STATUS Status;
ACPI_FUNCTION_NAME (HwWrite);
/* Validate contents of the GAS register */
Status = AcpiHwValidateRegister (Reg, 32, &Address);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/*
* Two address spaces supported: Memory or IO. PCI_Config is
* not supported here because the GAS structure is insufficient
*/
if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
{
Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
Address, (UINT64) Value, Reg->BitWidth);
}
else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
{
Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
Address, Value, Reg->BitWidth);
}
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
"Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
Value, Reg->BitWidth, ACPI_FORMAT_UINT64 (Address),
AcpiUtGetRegionName (Reg->SpaceId)));
return (Status);
}
static ACPI_STATUS
AcpiDbTestOneObject (
ACPI_HANDLE ObjHandle,
UINT32 NestingLevel,
void *Context,
void **ReturnValue)
{
ACPI_NAMESPACE_NODE *Node;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *RegionObj;
ACPI_OBJECT_TYPE LocalType;
UINT32 BitLength = 0;
UINT32 ByteLength = 0;
ACPI_STATUS Status = AE_OK;
Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
ObjDesc = Node->Object;
/*
* For the supported types, get the actual bit length or
* byte length. Map the type to one of Integer/String/Buffer.
*/
switch (Node->Type)
{
case ACPI_TYPE_INTEGER:
/* Integer width is either 32 or 64 */
LocalType = ACPI_TYPE_INTEGER;
BitLength = AcpiGbl_IntegerBitWidth;
break;
case ACPI_TYPE_STRING:
LocalType = ACPI_TYPE_STRING;
ByteLength = ObjDesc->String.Length;
break;
case ACPI_TYPE_BUFFER:
LocalType = ACPI_TYPE_BUFFER;
ByteLength = ObjDesc->Buffer.Length;
BitLength = ByteLength * 8;
break;
case ACPI_TYPE_FIELD_UNIT:
case ACPI_TYPE_BUFFER_FIELD:
case ACPI_TYPE_LOCAL_REGION_FIELD:
case ACPI_TYPE_LOCAL_INDEX_FIELD:
case ACPI_TYPE_LOCAL_BANK_FIELD:
LocalType = ACPI_TYPE_INTEGER;
if (ObjDesc)
{
/*
* Returned object will be a Buffer if the field length
* is larger than the size of an Integer (32 or 64 bits
* depending on the DSDT version).
*/
BitLength = ObjDesc->CommonField.BitLength;
ByteLength = ACPI_ROUND_BITS_UP_TO_BYTES (BitLength);
if (BitLength > AcpiGbl_IntegerBitWidth)
{
LocalType = ACPI_TYPE_BUFFER;
}
}
break;
default:
/* Ignore all other types */
return (AE_OK);
}
/* Emit the common prefix: Type:Name */
AcpiOsPrintf ("%14s: %4.4s",
AcpiUtGetTypeName (Node->Type), Node->Name.Ascii);
if (!ObjDesc)
{
AcpiOsPrintf (" Ignoring, no attached object\n");
return (AE_OK);
}
/*
* Check for unsupported region types. Note: AcpiExec simulates
* access to SystemMemory, SystemIO, PCI_Config, and EC.
*/
switch (Node->Type)
{
case ACPI_TYPE_LOCAL_REGION_FIELD:
RegionObj = ObjDesc->Field.RegionObj;
switch (RegionObj->Region.SpaceId)
{
case ACPI_ADR_SPACE_SYSTEM_MEMORY:
case ACPI_ADR_SPACE_SYSTEM_IO:
case ACPI_ADR_SPACE_PCI_CONFIG:
case ACPI_ADR_SPACE_EC:
break;
default:
AcpiOsPrintf (" %s space is not supported [%4.4s]\n",
AcpiUtGetRegionName (RegionObj->Region.SpaceId),
RegionObj->Region.Node->Name.Ascii);
return (AE_OK);
}
break;
default:
break;
}
/* At this point, we have resolved the object to one of the major types */
switch (LocalType)
{
case ACPI_TYPE_INTEGER:
Status = AcpiDbTestIntegerType (Node, BitLength);
break;
case ACPI_TYPE_STRING:
Status = AcpiDbTestStringType (Node, ByteLength);
break;
case ACPI_TYPE_BUFFER:
Status = AcpiDbTestBufferType (Node, BitLength);
break;
default:
AcpiOsPrintf (" Ignoring, type not implemented (%2.2X)",
LocalType);
break;
}
switch (Node->Type)
{
case ACPI_TYPE_LOCAL_REGION_FIELD:
RegionObj = ObjDesc->Field.RegionObj;
AcpiOsPrintf (" (%s)",
AcpiUtGetRegionName (RegionObj->Region.SpaceId));
break;
default:
break;
}
AcpiOsPrintf ("\n");
return (Status);
}
ACPI_STATUS
AcpiEvAddressSpaceDispatch (
ACPI_OPERAND_OBJECT *RegionObj,
UINT32 Function,
UINT32 RegionOffset,
UINT32 BitWidth,
UINT64 *Value)
{
ACPI_STATUS Status;
ACPI_ADR_SPACE_HANDLER Handler;
ACPI_ADR_SPACE_SETUP RegionSetup;
ACPI_OPERAND_OBJECT *HandlerDesc;
ACPI_OPERAND_OBJECT *RegionObj2;
void *RegionContext = NULL;
ACPI_FUNCTION_TRACE (EvAddressSpaceDispatch);
RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
if (!RegionObj2)
{
return_ACPI_STATUS (AE_NOT_EXIST);
}
/* Ensure that there is a handler associated with this region */
HandlerDesc = RegionObj->Region.Handler;
if (!HandlerDesc)
{
ACPI_ERROR ((AE_INFO,
"No handler for Region [%4.4s] (%p) [%s]",
AcpiUtGetNodeName (RegionObj->Region.Node),
RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (AE_NOT_EXIST);
}
/*
* It may be the case that the region has never been initialized.
* Some types of regions require special init code
*/
if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
{
/* This region has not been initialized yet, do it */
RegionSetup = HandlerDesc->AddressSpace.Setup;
if (!RegionSetup)
{
/* No initialization routine, exit with error */
ACPI_ERROR ((AE_INFO,
"No init routine for region(%p) [%s]",
RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (AE_NOT_EXIST);
}
/*
* We must exit the interpreter because the region setup will
* potentially execute control methods (for example, the _REG method
* for this region)
*/
AcpiExExitInterpreter ();
Status = RegionSetup (RegionObj, ACPI_REGION_ACTIVATE,
HandlerDesc->AddressSpace.Context, &RegionContext);
/* Re-enter the interpreter */
AcpiExEnterInterpreter ();
/* Check for failure of the Region Setup */
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"During region initialization: [%s]",
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (Status);
}
/* Region initialization may have been completed by RegionSetup */
if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
{
RegionObj->Region.Flags |= AOPOBJ_SETUP_COMPLETE;
if (RegionObj2->Extra.RegionContext)
{
/* The handler for this region was already installed */
ACPI_FREE (RegionContext);
}
else
{
/*
* Save the returned context for use in all accesses to
* this particular region
*/
RegionObj2->Extra.RegionContext = RegionContext;
}
}
}
/* We have everything we need, we can invoke the address space handler */
Handler = HandlerDesc->AddressSpace.Handler;
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Handler %p (@%p) Address %8.8X%8.8X [%s]\n",
&RegionObj->Region.Handler->AddressSpace, Handler,
ACPI_FORMAT_NATIVE_UINT (RegionObj->Region.Address + RegionOffset),
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
if (!(HandlerDesc->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
{
/*
* For handlers other than the default (supplied) handlers, we must
* exit the interpreter because the handler *might* block -- we don't
* know what it will do, so we can't hold the lock on the intepreter.
*/
AcpiExExitInterpreter();
}
/* Call the handler */
Status = Handler (Function,
(RegionObj->Region.Address + RegionOffset), BitWidth, Value,
HandlerDesc->AddressSpace.Context, RegionObj2->Extra.RegionContext);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "Returned by Handler for [%s]",
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
}
if (!(HandlerDesc->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
{
/*
* We just returned from a non-default handler, we must re-enter the
* interpreter
*/
AcpiExEnterInterpreter ();
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiRemoveAddressSpaceHandler (
ACPI_HANDLE Device,
ACPI_ADR_SPACE_TYPE SpaceId,
ACPI_ADR_SPACE_HANDLER Handler)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *RegionObj;
ACPI_OPERAND_OBJECT **LastObjPtr;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (AcpiRemoveAddressSpaceHandler);
/* Parameter validation */
if (!Device)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Convert and validate the device handle */
Node = AcpiNsValidateHandle (Device);
if (!Node ||
((Node->Type != ACPI_TYPE_DEVICE) &&
(Node->Type != ACPI_TYPE_PROCESSOR) &&
(Node->Type != ACPI_TYPE_THERMAL) &&
(Node != AcpiGbl_RootNode)))
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
/* Make sure the internal object exists */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (!ObjDesc)
{
Status = AE_NOT_EXIST;
goto UnlockAndExit;
}
/* Find the address handler the user requested */
HandlerObj = ObjDesc->Device.Handler;
LastObjPtr = &ObjDesc->Device.Handler;
while (HandlerObj)
{
/* We have a handler, see if user requested this one */
if (HandlerObj->AddressSpace.SpaceId == SpaceId)
{
/* Handler must be the same as the installed handler */
if (HandlerObj->AddressSpace.Handler != Handler)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
/* Matched SpaceId, first dereference this in the Regions */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Removing address handler %p(%p) for region %s "
"on Device %p(%p)\n",
HandlerObj, Handler, AcpiUtGetRegionName (SpaceId),
Node, ObjDesc));
RegionObj = HandlerObj->AddressSpace.RegionList;
/* Walk the handler's region list */
while (RegionObj)
{
/*
* First disassociate the handler from the region.
*
* NOTE: this doesn't mean that the region goes away
* The region is just inaccessible as indicated to
* the _REG method
*/
AcpiEvDetachRegion (RegionObj, TRUE);
/*
* Walk the list: Just grab the head because the
* DetachRegion removed the previous head.
*/
RegionObj = HandlerObj->AddressSpace.RegionList;
}
/* Remove this Handler object from the list */
*LastObjPtr = HandlerObj->AddressSpace.Next;
/* Now we can delete the handler object */
AcpiUtRemoveReference (HandlerObj);
goto UnlockAndExit;
}
/* Walk the linked list of handlers */
LastObjPtr = &HandlerObj->AddressSpace.Next;
HandlerObj = HandlerObj->AddressSpace.Next;
}
/* The handler does not exist */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Unable to remove address handler %p for %s(%X), DevNode %p, obj %p\n",
Handler, AcpiUtGetRegionName (SpaceId), SpaceId, Node, ObjDesc));
Status = AE_NOT_EXIST;
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiHwWrite (
UINT64 Value,
ACPI_GENERIC_ADDRESS *Reg)
{
UINT64 Address;
UINT8 AccessWidth;
UINT32 BitWidth;
UINT8 BitOffset;
UINT64 Value64;
UINT8 Index;
ACPI_STATUS Status;
ACPI_FUNCTION_NAME (HwWrite);
/* Validate contents of the GAS register */
Status = AcpiHwValidateRegister (Reg, 64, &Address);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Convert AccessWidth into number of bits based */
AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
BitWidth = Reg->BitOffset + Reg->BitWidth;
BitOffset = Reg->BitOffset;
/*
* Two address spaces supported: Memory or IO. PCI_Config is
* not supported here because the GAS structure is insufficient
*/
Index = 0;
while (BitWidth)
{
/*
* Use offset style bit reads because "Index * AccessWidth" is
* ensured to be less than 64-bits by AcpiHwValidateRegister().
*/
Value64 = ACPI_GET_BITS (&Value, Index * AccessWidth,
ACPI_MASK_BITS_ABOVE_64 (AccessWidth));
if (BitOffset >= AccessWidth)
{
BitOffset -= AccessWidth;
}
else
{
if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
{
Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
Value64, AccessWidth);
}
else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
{
Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
(UINT32) Value64, AccessWidth);
}
}
/*
* Index * AccessWidth is ensured to be less than 32-bits by
* AcpiHwValidateRegister().
*/
BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
Index++;
}
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
"Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n",
ACPI_FORMAT_UINT64 (Value), AccessWidth,
ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
return (Status);
}
ACPI_STATUS
AcpiExAccessRegion (
ACPI_OPERAND_OBJECT *ObjDesc,
UINT32 FieldDatumByteOffset,
UINT64 *Value,
UINT32 Function)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT *RgnDesc;
UINT32 RegionOffset;
ACPI_FUNCTION_TRACE (ExAccessRegion);
/*
* Ensure that the region operands are fully evaluated and verify
* the validity of the request
*/
Status = AcpiExSetupRegion (ObjDesc, FieldDatumByteOffset);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/*
* The physical address of this field datum is:
*
* 1) The base of the region, plus
* 2) The base offset of the field, plus
* 3) The current offset into the field
*/
RgnDesc = ObjDesc->CommonField.RegionObj;
RegionOffset =
ObjDesc->CommonField.BaseByteOffset +
FieldDatumByteOffset;
if ((Function & ACPI_IO_MASK) == ACPI_READ)
{
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "[READ]"));
}
else
{
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "[WRITE]"));
}
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_BFIELD,
" Region [%s:%X], Width %X, ByteBase %X, Offset %X at %8.8X%8.8X\n",
AcpiUtGetRegionName (RgnDesc->Region.SpaceId),
RgnDesc->Region.SpaceId,
ObjDesc->CommonField.AccessByteWidth,
ObjDesc->CommonField.BaseByteOffset,
FieldDatumByteOffset,
ACPI_FORMAT_UINT64 (RgnDesc->Region.Address + RegionOffset)));
/* Invoke the appropriate AddressSpace/OpRegion handler */
Status = AcpiEvAddressSpaceDispatch (RgnDesc, ObjDesc,
Function, RegionOffset,
ACPI_MUL_8 (ObjDesc->CommonField.AccessByteWidth), Value);
if (ACPI_FAILURE (Status))
{
if (Status == AE_NOT_IMPLEMENTED)
{
ACPI_ERROR ((AE_INFO,
"Region %s (ID=%u) not implemented",
AcpiUtGetRegionName (RgnDesc->Region.SpaceId),
RgnDesc->Region.SpaceId));
}
else if (Status == AE_NOT_EXIST)
{
ACPI_ERROR ((AE_INFO,
"Region %s (ID=%u) has no handler",
AcpiUtGetRegionName (RgnDesc->Region.SpaceId),
RgnDesc->Region.SpaceId));
}
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiEvAddressSpaceDispatch (
ACPI_OPERAND_OBJECT *RegionObj,
ACPI_OPERAND_OBJECT *FieldObj,
UINT32 Function,
UINT32 RegionOffset,
UINT32 BitWidth,
UINT64 *Value)
{
ACPI_STATUS Status;
ACPI_ADR_SPACE_HANDLER Handler;
ACPI_ADR_SPACE_SETUP RegionSetup;
ACPI_OPERAND_OBJECT *HandlerDesc;
ACPI_OPERAND_OBJECT *RegionObj2;
void *RegionContext = NULL;
ACPI_CONNECTION_INFO *Context;
ACPI_PHYSICAL_ADDRESS Address;
ACPI_FUNCTION_TRACE (EvAddressSpaceDispatch);
RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
if (!RegionObj2)
{
return_ACPI_STATUS (AE_NOT_EXIST);
}
/* Ensure that there is a handler associated with this region */
HandlerDesc = RegionObj->Region.Handler;
if (!HandlerDesc)
{
ACPI_ERROR ((AE_INFO,
"No handler for Region [%4.4s] (%p) [%s]",
AcpiUtGetNodeName (RegionObj->Region.Node),
RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (AE_NOT_EXIST);
}
Context = HandlerDesc->AddressSpace.Context;
/*
* It may be the case that the region has never been initialized.
* Some types of regions require special init code
*/
if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
{
/* This region has not been initialized yet, do it */
RegionSetup = HandlerDesc->AddressSpace.Setup;
if (!RegionSetup)
{
/* No initialization routine, exit with error */
ACPI_ERROR ((AE_INFO,
"No init routine for region(%p) [%s]",
RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (AE_NOT_EXIST);
}
/*
* We must exit the interpreter because the region setup will
* potentially execute control methods (for example, the _REG method
* for this region)
*/
AcpiExExitInterpreter ();
Status = RegionSetup (RegionObj, ACPI_REGION_ACTIVATE,
Context, &RegionContext);
/* Re-enter the interpreter */
AcpiExEnterInterpreter ();
/* Check for failure of the Region Setup */
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"During region initialization: [%s]",
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (Status);
}
/* Region initialization may have been completed by RegionSetup */
if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
{
RegionObj->Region.Flags |= AOPOBJ_SETUP_COMPLETE;
/*
* Save the returned context for use in all accesses to
* the handler for this particular region
*/
if (!(RegionObj2->Extra.RegionContext))
{
RegionObj2->Extra.RegionContext = RegionContext;
}
}
}
/* We have everything we need, we can invoke the address space handler */
Handler = HandlerDesc->AddressSpace.Handler;
Address = (RegionObj->Region.Address + RegionOffset);
/*
* Special handling for GenericSerialBus and GeneralPurposeIo:
* There are three extra parameters that must be passed to the
* handler via the context:
* 1) Connection buffer, a resource template from Connection() op
* 2) Length of the above buffer
* 3) Actual access length from the AccessAs() op
*
* In addition, for GeneralPurposeIo, the Address and BitWidth fields
* are defined as follows:
* 1) Address is the pin number index of the field (bit offset from
* the previous Connection)
* 2) BitWidth is the actual bit length of the field (number of pins)
*/
if ((RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS) &&
Context &&
FieldObj)
{
/* Get the Connection (ResourceTemplate) buffer */
Context->Connection = FieldObj->Field.ResourceBuffer;
Context->Length = FieldObj->Field.ResourceLength;
Context->AccessLength = FieldObj->Field.AccessLength;
}
if ((RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GPIO) &&
Context &&
FieldObj)
{
/* Get the Connection (ResourceTemplate) buffer */
Context->Connection = FieldObj->Field.ResourceBuffer;
Context->Length = FieldObj->Field.ResourceLength;
Context->AccessLength = FieldObj->Field.AccessLength;
Address = FieldObj->Field.PinNumberIndex;
BitWidth = FieldObj->Field.BitLength;
}
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Handler %p (@%p) Address %8.8X%8.8X [%s]\n",
&RegionObj->Region.Handler->AddressSpace, Handler,
ACPI_FORMAT_UINT64 (Address),
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
if (!(HandlerDesc->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
{
/*
* For handlers other than the default (supplied) handlers, we must
* exit the interpreter because the handler *might* block -- we don't
* know what it will do, so we can't hold the lock on the intepreter.
*/
AcpiExExitInterpreter();
}
/* Call the handler */
Status = Handler (Function, Address, BitWidth, Value, Context,
RegionObj2->Extra.RegionContext);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "Returned by Handler for [%s]",
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
}
if (!(HandlerDesc->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
{
/*
* We just returned from a non-default handler, we must re-enter the
* interpreter
*/
AcpiExEnterInterpreter ();
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiInstallAddressSpaceHandler (
ACPI_HANDLE Device,
ACPI_ADR_SPACE_TYPE SpaceId,
ACPI_ADR_SPACE_HANDLER Handler,
ACPI_ADR_SPACE_SETUP Setup,
void *Context)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_OBJECT_TYPE Type;
UINT16 Flags = 0;
ACPI_FUNCTION_TRACE ("AcpiInstallAddressSpaceHandler");
/* Parameter validation */
if (!Device)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Convert and validate the device handle */
Node = AcpiNsMapHandleToNode (Device);
if (!Node)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
/*
* This registration is valid for only the types below
* and the root. This is where the default handlers
* get placed.
*/
if ((Node->Type != ACPI_TYPE_DEVICE) &&
(Node->Type != ACPI_TYPE_PROCESSOR) &&
(Node->Type != ACPI_TYPE_THERMAL) &&
(Node != AcpiGbl_RootNode))
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
if (Handler == ACPI_DEFAULT_HANDLER)
{
Flags = ACPI_ADDR_HANDLER_DEFAULT_INSTALLED;
switch (SpaceId)
{
case ACPI_ADR_SPACE_SYSTEM_MEMORY:
Handler = AcpiExSystemMemorySpaceHandler;
Setup = AcpiEvSystemMemoryRegionSetup;
break;
case ACPI_ADR_SPACE_SYSTEM_IO:
Handler = AcpiExSystemIoSpaceHandler;
Setup = AcpiEvIoSpaceRegionSetup;
break;
case ACPI_ADR_SPACE_PCI_CONFIG:
Handler = AcpiExPciConfigSpaceHandler;
Setup = AcpiEvPciConfigRegionSetup;
break;
case ACPI_ADR_SPACE_CMOS:
Handler = AcpiExCmosSpaceHandler;
Setup = AcpiEvCmosRegionSetup;
break;
case ACPI_ADR_SPACE_PCI_BAR_TARGET:
Handler = AcpiExPciBarSpaceHandler;
Setup = AcpiEvPciBarRegionSetup;
break;
case ACPI_ADR_SPACE_DATA_TABLE:
Handler = AcpiExDataTableSpaceHandler;
Setup = NULL;
break;
default:
Status = AE_NOT_EXIST;
goto UnlockAndExit;
}
}
/*
* If the caller hasn't specified a setup routine, use the default
*/
if (!Setup)
{
Setup = AcpiEvDefaultRegionSetup;
}
/*
* Check for an existing internal object
*/
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
/*
* The object exists.
* Make sure the handler is not already installed.
*/
/* check the address handler the user requested */
HandlerObj = ObjDesc->Device.AddrHandler;
while (HandlerObj)
{
/*
* We have an Address handler, see if user requested this
* address space.
*/
if(HandlerObj->AddrHandler.SpaceId == SpaceId)
{
Status = AE_ALREADY_EXISTS;
goto UnlockAndExit;
}
/*
* Move through the linked list of handlers
*/
HandlerObj = HandlerObj->AddrHandler.Next;
}
}
else
{
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Creating object on Device %p while installing handler\n", Node));
/* ObjDesc does not exist, create one */
if (Node->Type == ACPI_TYPE_ANY)
{
Type = ACPI_TYPE_DEVICE;
}
else
{
Type = Node->Type;
}
ObjDesc = AcpiUtCreateInternalObject (Type);
if (!ObjDesc)
{
Status = AE_NO_MEMORY;
goto UnlockAndExit;
}
/* Init new descriptor */
ObjDesc->Common.Type = (UINT8) Type;
/* Attach the new object to the Node */
Status = AcpiNsAttachObject (Node, ObjDesc, Type);
if (ACPI_FAILURE (Status))
{
AcpiUtRemoveReference (ObjDesc);
goto UnlockAndExit;
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Installing address handler for region %s(%X) on Device %4.4s %p(%p)\n",
AcpiUtGetRegionName (SpaceId), SpaceId, Node->Name.Ascii, Node, ObjDesc));
/*
* Now we can install the handler
*
* At this point we know that there is no existing handler.
* So, we just allocate the object for the handler and link it
* into the list.
*/
HandlerObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_ADDRESS_HANDLER);
if (!HandlerObj)
{
Status = AE_NO_MEMORY;
goto UnlockAndExit;
}
HandlerObj->AddrHandler.SpaceId = (UINT8) SpaceId;
HandlerObj->AddrHandler.Hflags = Flags;
HandlerObj->AddrHandler.Next = ObjDesc->Device.AddrHandler;
HandlerObj->AddrHandler.RegionList = NULL;
HandlerObj->AddrHandler.Node = Node;
HandlerObj->AddrHandler.Handler = Handler;
HandlerObj->AddrHandler.Context = Context;
HandlerObj->AddrHandler.Setup = Setup;
/*
* Now walk the namespace finding all of the regions this
* handler will manage.
*
* We start at the device and search the branch toward
* the leaf nodes until either the leaf is encountered or
* a device is detected that has an address handler of the
* same type.
*
* In either case we back up and search down the remainder
* of the branch
*/
Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, Device,
ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
AcpiEvAddrHandlerHelper,
HandlerObj, NULL);
/*
* Place this handler 1st on the list
*/
HandlerObj->Common.ReferenceCount =
(UINT16) (HandlerObj->Common.ReferenceCount +
ObjDesc->Common.ReferenceCount - 1);
ObjDesc->Device.AddrHandler = HandlerObj;
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
return_ACPI_STATUS (Status);
}
static ACPI_STATUS
AcpiEvInstallHandler (
ACPI_HANDLE ObjHandle,
UINT32 Level,
void *Context,
void **ReturnValue)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *NextHandlerObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_FUNCTION_NAME (EvInstallHandler);
HandlerObj = (ACPI_OPERAND_OBJECT *) Context;
/* Parameter validation */
if (!HandlerObj)
{
return (AE_OK);
}
/* Convert and validate the device handle */
Node = AcpiNsValidateHandle (ObjHandle);
if (!Node)
{
return (AE_BAD_PARAMETER);
}
/*
* We only care about regions and objects that are allowed to have
* address space handlers
*/
if ((Node->Type != ACPI_TYPE_DEVICE) &&
(Node->Type != ACPI_TYPE_REGION) &&
(Node != AcpiGbl_RootNode))
{
return (AE_OK);
}
/* Check for an existing internal object */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (!ObjDesc)
{
/* No object, just exit */
return (AE_OK);
}
/* Devices are handled different than regions */
if (ObjDesc->Common.Type == ACPI_TYPE_DEVICE)
{
/* Check if this Device already has a handler for this address space */
NextHandlerObj = AcpiEvFindRegionHandler (
HandlerObj->AddressSpace.SpaceId, ObjDesc->CommonNotify.Handler);
if (NextHandlerObj)
{
/* Found a handler, is it for the same address space? */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Found handler for region [%s] in device %p(%p) handler %p\n",
AcpiUtGetRegionName (HandlerObj->AddressSpace.SpaceId),
ObjDesc, NextHandlerObj, HandlerObj));
/*
* Since the object we found it on was a device, then it means
* that someone has already installed a handler for the branch
* of the namespace from this device on. Just bail out telling
* the walk routine to not traverse this branch. This preserves
* the scoping rule for handlers.
*/
return (AE_CTRL_DEPTH);
}
/*
* As long as the device didn't have a handler for this space we
* don't care about it. We just ignore it and proceed.
*/
return (AE_OK);
}
/* Object is a Region */
if (ObjDesc->Region.SpaceId != HandlerObj->AddressSpace.SpaceId)
{
/* This region is for a different address space, just ignore it */
return (AE_OK);
}
/*
* Now we have a region and it is for the handler's address space type.
*
* First disconnect region for any previous handler (if any)
*/
AcpiEvDetachRegion (ObjDesc, FALSE);
/* Connect the region to the new handler */
Status = AcpiEvAttachRegion (HandlerObj, ObjDesc, FALSE);
return (Status);
}
ACPI_STATUS
AcpiHwRead (
UINT32 *Value,
ACPI_GENERIC_ADDRESS *Reg)
{
UINT64 Address;
UINT8 AccessWidth;
UINT32 BitWidth;
UINT8 BitOffset;
UINT64 Value64;
UINT32 Value32;
UINT8 Index;
ACPI_STATUS Status;
ACPI_FUNCTION_NAME (HwRead);
/* Validate contents of the GAS register */
Status = AcpiHwValidateRegister (Reg, 32, &Address);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/*
* Initialize entire 32-bit return value to zero, convert AccessWidth
* into number of bits based
*/
*Value = 0;
AccessWidth = Reg->AccessWidth ? Reg->AccessWidth : 1;
AccessWidth = 1 << (AccessWidth + 2);
BitWidth = ACPI_ROUND_UP (Reg->BitOffset + Reg->BitWidth, AccessWidth);
BitOffset = Reg->BitOffset;
/*
* Two address spaces supported: Memory or IO. PCI_Config is
* not supported here because the GAS structure is insufficient
*/
Index = 0;
while (BitWidth)
{
if (BitOffset > AccessWidth)
{
Value32 = 0;
BitOffset -= AccessWidth;
}
else
{
if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
{
Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
&Value64, AccessWidth);
Value32 = (UINT32) Value64;
}
else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
{
Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
&Value32, AccessWidth);
}
if (BitOffset)
{
Value32 &= ACPI_MASK_BITS_BELOW (BitOffset);
BitOffset = 0;
}
if (BitWidth < AccessWidth)
{
Value32 &= ACPI_MASK_BITS_ABOVE (BitWidth);
}
}
ACPI_SET_BITS (Value, Index * AccessWidth,
((1 << AccessWidth) - 1), Value32);
BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
Index++;
}
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
"Read: %8.8X width %2d from %8.8X%8.8X (%s)\n",
*Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
AcpiUtGetRegionName (Reg->SpaceId)));
return (Status);
}
ACPI_STATUS
AcpiHwWrite (
UINT32 Value,
ACPI_GENERIC_ADDRESS *Reg)
{
UINT64 Address;
UINT8 AccessWidth;
UINT32 BitWidth;
UINT8 BitOffset;
UINT64 Value64;
UINT32 NewValue32, OldValue32;
UINT8 Index;
ACPI_STATUS Status;
ACPI_FUNCTION_NAME (HwWrite);
/* Validate contents of the GAS register */
Status = AcpiHwValidateRegister (Reg, 32, &Address);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Convert AccessWidth into number of bits based */
AccessWidth = Reg->AccessWidth ? Reg->AccessWidth : 1;
AccessWidth = 1 << (AccessWidth + 2);
BitWidth = ACPI_ROUND_UP (Reg->BitOffset + Reg->BitWidth, AccessWidth);
BitOffset = Reg->BitOffset;
/*
* Two address spaces supported: Memory or IO. PCI_Config is
* not supported here because the GAS structure is insufficient
*/
Index = 0;
while (BitWidth)
{
NewValue32 = ACPI_GET_BITS (&Value, (Index * AccessWidth),
((1 << AccessWidth) - 1));
if (BitOffset > AccessWidth)
{
BitOffset -= AccessWidth;
}
else
{
if (BitOffset)
{
NewValue32 &= ACPI_MASK_BITS_BELOW (BitOffset);
}
if (BitWidth < AccessWidth)
{
NewValue32 &= ACPI_MASK_BITS_ABOVE (BitWidth);
}
if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
{
if (BitOffset || BitWidth < AccessWidth)
{
/*
* Read old values in order not to modify the bits that
* are beyond the register BitWidth/BitOffset setting.
*/
Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
&Value64, AccessWidth);
OldValue32 = (UINT32) Value64;
if (BitOffset)
{
OldValue32 &= ACPI_MASK_BITS_ABOVE (BitOffset + 1);
BitOffset = 0;
}
if (BitWidth < AccessWidth)
{
OldValue32 &= ACPI_MASK_BITS_BELOW (BitWidth - 1);
}
NewValue32 |= OldValue32;
}
Value64 = (UINT64) NewValue32;
Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
Value64, AccessWidth);
}
else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
{
if (BitOffset || BitWidth < AccessWidth)
{
/*
* Read old values in order not to modify the bits that
* are beyond the register BitWidth/BitOffset setting.
*/
Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
&OldValue32, AccessWidth);
if (BitOffset)
{
OldValue32 &= ACPI_MASK_BITS_ABOVE (BitOffset + 1);
BitOffset = 0;
}
if (BitWidth < AccessWidth)
{
OldValue32 &= ACPI_MASK_BITS_BELOW (BitWidth - 1);
}
NewValue32 |= OldValue32;
}
Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
Address + Index * ACPI_DIV_8 (AccessWidth),
NewValue32, AccessWidth);
}
}
BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
Index++;
}
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
"Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
AcpiUtGetRegionName (Reg->SpaceId)));
return (Status);
}
ACPI_STATUS
AcpiEvAddrHandlerHelper (
ACPI_HANDLE ObjHandle,
UINT32 Level,
void *Context,
void **ReturnValue)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *TmpObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_FUNCTION_NAME ("EvAddrHandlerHelper");
HandlerObj = (ACPI_OPERAND_OBJECT *) Context;
/* Parameter validation */
if (!HandlerObj)
{
return (AE_OK);
}
/* Convert and validate the device handle */
Node = AcpiNsMapHandleToNode (ObjHandle);
if (!Node)
{
return (AE_BAD_PARAMETER);
}
/*
* We only care about regions.and objects
* that can have address handlers
*/
if ((Node->Type != ACPI_TYPE_DEVICE) &&
(Node->Type != ACPI_TYPE_REGION) &&
(Node != AcpiGbl_RootNode))
{
return (AE_OK);
}
/* Check for an existing internal object */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (!ObjDesc)
{
/*
* The object DNE, we don't care about it
*/
return (AE_OK);
}
/*
* Devices are handled different than regions
*/
if (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_DEVICE)
{
/*
* See if this guy has any handlers
*/
TmpObj = ObjDesc->Device.AddrHandler;
while (TmpObj)
{
/*
* Now let's see if it's for the same address space.
*/
if (TmpObj->AddrHandler.SpaceId == HandlerObj->AddrHandler.SpaceId)
{
/*
* It's for the same address space
*/
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Found handler for region [%s] in device %p(%p) handler %p\n",
AcpiUtGetRegionName (HandlerObj->AddrHandler.SpaceId),
ObjDesc, TmpObj, HandlerObj));
/*
* Since the object we found it on was a device, then it
* means that someone has already installed a handler for
* the branch of the namespace from this device on. Just
* bail out telling the walk routine to not traverse this
* branch. This preserves the scoping rule for handlers.
*/
return (AE_CTRL_DEPTH);
}
/*
* Move through the linked list of handlers
*/
TmpObj = TmpObj->AddrHandler.Next;
}
/*
* As long as the device didn't have a handler for this
* space we don't care about it. We just ignore it and
* proceed.
*/
return (AE_OK);
}
/*
* Only here if it was a region
*/
if (ObjDesc->Region.SpaceId != HandlerObj->AddrHandler.SpaceId)
{
/*
* This region is for a different address space
* ignore it
*/
return (AE_OK);
}
/*
* Now we have a region and it is for the handler's address
* space type.
*
* First disconnect region for any previous handler (if any)
*/
AcpiEvDetachRegion (ObjDesc, FALSE);
/*
* Then connect the region to the new handler
*/
Status = AcpiEvAttachRegion (HandlerObj, ObjDesc, FALSE);
return (Status);
}
void
AcpiEvDetachRegion(
ACPI_OPERAND_OBJECT *RegionObj,
BOOLEAN AcpiNsIsLocked)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT **LastObjPtr;
ACPI_ADR_SPACE_SETUP RegionSetup;
void *RegionContext;
ACPI_OPERAND_OBJECT *RegionObj2;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE ("EvDetachRegion");
RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
if (!RegionObj2)
{
return_VOID;
}
RegionContext = RegionObj2->Extra.RegionContext;
/*
* Get the address handler from the region object
*/
HandlerObj = RegionObj->Region.AddrHandler;
if (!HandlerObj)
{
/*
* This region has no handler, all done
*/
return_VOID;
}
/*
* Find this region in the handler's list
*/
ObjDesc = HandlerObj->AddrHandler.RegionList;
LastObjPtr = &HandlerObj->AddrHandler.RegionList;
while (ObjDesc)
{
/*
* See if this is the one
*/
if (ObjDesc == RegionObj)
{
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Removing Region %p from address handler %p\n",
RegionObj, HandlerObj));
/*
* This is it, remove it from the handler's list
*/
*LastObjPtr = ObjDesc->Region.Next;
ObjDesc->Region.Next = NULL; /* Must clear field */
if (AcpiNsIsLocked)
{
Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_VOID;
}
}
/*
* Now stop region accesses by executing the _REG method
*/
Status = AcpiEvExecuteRegMethod (RegionObj, 0);
if (ACPI_FAILURE (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s from region _REG, [%s]\n",
AcpiFormatException (Status),
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
}
if (AcpiNsIsLocked)
{
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_VOID;
}
}
/*
* Call the setup handler with the deactivate notification
*/
RegionSetup = HandlerObj->AddrHandler.Setup;
Status = RegionSetup (RegionObj, ACPI_REGION_DEACTIVATE,
HandlerObj->AddrHandler.Context, &RegionContext);
/*
* Init routine may fail, Just ignore errors
*/
if (ACPI_FAILURE (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%s from region init, [%s]\n",
AcpiFormatException (Status),
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
}
RegionObj->Region.Flags &= ~(AOPOBJ_SETUP_COMPLETE);
/*
* Remove handler reference in the region
*
* NOTE: this doesn't mean that the region goes away
* The region is just inaccessible as indicated to
* the _REG method
*
* If the region is on the handler's list
* this better be the region's handler
*/
RegionObj->Region.AddrHandler = NULL;
return_VOID;
} /* found the right handler */
/*
* Move through the linked list of handlers
*/
LastObjPtr = &ObjDesc->Region.Next;
ObjDesc = ObjDesc->Region.Next;
}
/*
* If we get here, the region was not in the handler's region list
*/
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Cannot remove region %p from address handler %p\n",
RegionObj, HandlerObj));
return_VOID;
}
ACPI_STATUS
AcpiEvAddressSpaceDispatch (
ACPI_OPERAND_OBJECT *RegionObj,
UINT32 Function,
ACPI_PHYSICAL_ADDRESS Address,
UINT32 BitWidth,
void *Value)
{
ACPI_STATUS Status;
ACPI_STATUS Status2;
ACPI_ADR_SPACE_HANDLER Handler;
ACPI_ADR_SPACE_SETUP RegionSetup;
ACPI_OPERAND_OBJECT *HandlerDesc;
ACPI_OPERAND_OBJECT *RegionObj2;
void *RegionContext = NULL;
ACPI_FUNCTION_TRACE ("EvAddressSpaceDispatch");
RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
if (!RegionObj2)
{
return_ACPI_STATUS (AE_NOT_EXIST);
}
/*
* Ensure that there is a handler associated with this region
*/
HandlerDesc = RegionObj->Region.AddrHandler;
if (!HandlerDesc)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "no handler for region(%p) [%s]\n",
RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (AE_NOT_EXIST);
}
/*
* It may be the case that the region has never been initialized
* Some types of regions require special init code
*/
if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
{
/*
* This region has not been initialized yet, do it
*/
RegionSetup = HandlerDesc->AddrHandler.Setup;
if (!RegionSetup)
{
/*
* Bad news, no init routine and not init'd
*/
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No init routine for region(%p) [%s]\n",
RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (AE_UNKNOWN_STATUS);
}
/*
* We must exit the interpreter because the region setup will potentially
* execute control methods
*/
AcpiExExitInterpreter ();
Status = RegionSetup (RegionObj, ACPI_REGION_ACTIVATE,
HandlerDesc->AddrHandler.Context, &RegionContext);
/* Re-enter the interpreter */
Status2 = AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
/*
* Init routine may fail
*/
if (ACPI_FAILURE (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region Init: %s [%s]\n",
AcpiFormatException (Status),
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
return_ACPI_STATUS (Status);
}
RegionObj->Region.Flags |= AOPOBJ_SETUP_COMPLETE;
/*
* Save the returned context for use in all accesses to
* this particular region.
*/
RegionObj2->Extra.RegionContext = RegionContext;
}
/*
* We have everything we need, begin the process
*/
Handler = HandlerDesc->AddrHandler.Handler;
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Addrhandler %p (%p), Address %8.8X%8.8X\n",
&RegionObj->Region.AddrHandler->AddrHandler, Handler,
ACPI_HIDWORD (Address), ACPI_LODWORD (Address)));
if (!(HandlerDesc->AddrHandler.Flags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
{
/*
* For handlers other than the default (supplied) handlers, we must
* exit the interpreter because the handler *might* block -- we don't
* know what it will do, so we can't hold the lock on the intepreter.
*/
AcpiExExitInterpreter();
}
/*
* Invoke the handler.
*/
Status = Handler (Function, Address, BitWidth, Value,
HandlerDesc->AddrHandler.Context,
RegionObj2->Extra.RegionContext);
if (ACPI_FAILURE (Status))
{
ACPI_REPORT_ERROR (("Handler for [%s] returned %s\n",
AcpiUtGetRegionName (RegionObj->Region.SpaceId),
AcpiFormatException (Status)));
}
if (!(HandlerDesc->AddrHandler.Flags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
{
/*
* We just returned from a non-default handler, we must re-enter the
* interpreter
*/
Status2 = AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiEvInitializeRegion (
ACPI_OPERAND_OBJECT *RegionObj,
BOOLEAN AcpiNsLocked)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_ADR_SPACE_TYPE SpaceId;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *MethodNode;
ACPI_NAME *RegNamePtr = (ACPI_NAME *) METHOD_NAME__REG;
ACPI_OPERAND_OBJECT *RegionObj2;
ACPI_FUNCTION_TRACE_U32 (EvInitializeRegion, AcpiNsLocked);
if (!RegionObj)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
if (RegionObj->Common.Flags & AOPOBJ_OBJECT_INITIALIZED)
{
return_ACPI_STATUS (AE_OK);
}
RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
if (!RegionObj2)
{
return_ACPI_STATUS (AE_NOT_EXIST);
}
Node = AcpiNsGetParentNode (RegionObj->Region.Node);
SpaceId = RegionObj->Region.SpaceId;
/* Setup defaults */
RegionObj->Region.Handler = NULL;
RegionObj2->Extra.Method_REG = NULL;
RegionObj->Common.Flags &= ~(AOPOBJ_SETUP_COMPLETE);
RegionObj->Common.Flags |= AOPOBJ_OBJECT_INITIALIZED;
/* Find any "_REG" method associated with this region definition */
Status = AcpiNsSearchOneScope (
*RegNamePtr, Node, ACPI_TYPE_METHOD, &MethodNode);
if (ACPI_SUCCESS (Status))
{
/*
* The _REG method is optional and there can be only one per region
* definition. This will be executed when the handler is attached
* or removed
*/
RegionObj2->Extra.Method_REG = MethodNode;
}
/*
* The following loop depends upon the root Node having no parent
* ie: AcpiGbl_RootNode->ParentEntry being set to NULL
*/
while (Node)
{
/* Check to see if a handler exists */
HandlerObj = NULL;
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
/* Can only be a handler if the object exists */
switch (Node->Type)
{
case ACPI_TYPE_DEVICE:
HandlerObj = ObjDesc->Device.Handler;
break;
case ACPI_TYPE_PROCESSOR:
HandlerObj = ObjDesc->Processor.Handler;
break;
case ACPI_TYPE_THERMAL:
HandlerObj = ObjDesc->ThermalZone.Handler;
break;
default:
/* Ignore other objects */
break;
}
while (HandlerObj)
{
/* Is this handler of the correct type? */
if (HandlerObj->AddressSpace.SpaceId == SpaceId)
{
/* Found correct handler */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Found handler %p for region %p in obj %p\n",
HandlerObj, RegionObj, ObjDesc));
Status = AcpiEvAttachRegion (HandlerObj, RegionObj,
AcpiNsLocked);
/*
* Tell all users that this region is usable by
* running the _REG method
*/
if (AcpiNsLocked)
{
Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
Status = AcpiEvExecuteRegMethod (RegionObj, 1);
if (AcpiNsLocked)
{
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
return_ACPI_STATUS (AE_OK);
}
/* Try next handler in the list */
HandlerObj = HandlerObj->AddressSpace.Next;
}
}
/* This node does not have the handler we need; Pop up one level */
Node = AcpiNsGetParentNode (Node);
}
/* If we get here, there is no handler for this region */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"No handler for RegionType %s(%X) (RegionObj %p)\n",
AcpiUtGetRegionName (SpaceId), SpaceId, RegionObj));
return_ACPI_STATUS (AE_NOT_EXIST);
}
ACPI_STATUS
AcpiRemoveAddressSpaceHandler (
ACPI_HANDLE Device,
ACPI_ADR_SPACE_TYPE SpaceId,
ACPI_ADR_SPACE_HANDLER Handler)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *RegionObj;
ACPI_OPERAND_OBJECT **LastObjPtr;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE ("AcpiRemoveAddressSpaceHandler");
/* Parameter validation */
if (!Device)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Convert and validate the device handle */
Node = AcpiNsMapHandleToNode (Device);
if (!Node)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
/* Make sure the internal object exists */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (!ObjDesc)
{
Status = AE_NOT_EXIST;
goto UnlockAndExit;
}
/*
* find the address handler the user requested
*/
HandlerObj = ObjDesc->Device.AddrHandler;
LastObjPtr = &ObjDesc->Device.AddrHandler;
while (HandlerObj)
{
/*
* We have a handler, see if user requested this one
*/
if (HandlerObj->AddrHandler.SpaceId == SpaceId)
{
/*
* Got it, first dereference this in the Regions
*/
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Removing address handler %p(%p) for region %s on Device %p(%p)\n",
HandlerObj, Handler, AcpiUtGetRegionName (SpaceId),
Node, ObjDesc));
RegionObj = HandlerObj->AddrHandler.RegionList;
/* Walk the handler's region list */
while (RegionObj)
{
/*
* First disassociate the handler from the region.
*
* NOTE: this doesn't mean that the region goes away
* The region is just inaccessible as indicated to
* the _REG method
*/
AcpiEvDetachRegion (RegionObj, TRUE);
/*
* Walk the list, since we took the first region and it
* was removed from the list by the dissassociate call
* we just get the first item on the list again
*/
RegionObj = HandlerObj->AddrHandler.RegionList;
}
/*
* Remove this Handler object from the list
*/
*LastObjPtr = HandlerObj->AddrHandler.Next;
/*
* Now we can delete the handler object
*/
AcpiUtRemoveReference (HandlerObj);
AcpiUtRemoveReference (HandlerObj);
goto UnlockAndExit;
}
/*
* Move through the linked list of handlers
*/
LastObjPtr = &HandlerObj->AddrHandler.Next;
HandlerObj = HandlerObj->AddrHandler.Next;
}
/*
* The handler does not exist
*/
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Unable to remove address handler %p for %s(%X), DevNode %p, obj %p\n",
Handler, AcpiUtGetRegionName (SpaceId), SpaceId, Node, ObjDesc));
Status = AE_NOT_EXIST;
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiNsDumpOneObject (
ACPI_HANDLE ObjHandle,
UINT32 Level,
void *Context,
void **ReturnValue)
{
ACPI_WALK_INFO *Info = (ACPI_WALK_INFO *) Context;
ACPI_NAMESPACE_NODE *ThisNode;
ACPI_OPERAND_OBJECT *ObjDesc = NULL;
ACPI_OBJECT_TYPE ObjType;
ACPI_OBJECT_TYPE Type;
UINT32 BytesToDump;
UINT32 DbgLevel;
UINT32 i;
ACPI_FUNCTION_NAME (NsDumpOneObject);
/* Is output enabled? */
if (!(AcpiDbgLevel & Info->DebugLevel))
{
return (AE_OK);
}
if (!ObjHandle)
{
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null object handle\n"));
return (AE_OK);
}
ThisNode = AcpiNsValidateHandle (ObjHandle);
if (!ThisNode)
{
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Invalid object handle %p\n",
ObjHandle));
return (AE_OK);
}
Type = ThisNode->Type;
/* Check if the owner matches */
if ((Info->OwnerId != ACPI_OWNER_ID_MAX) &&
(Info->OwnerId != ThisNode->OwnerId))
{
return (AE_OK);
}
if (!(Info->DisplayType & ACPI_DISPLAY_SHORT))
{
/* Indent the object according to the level */
AcpiOsPrintf ("%2d%*s", (UINT32) Level - 1, (int) Level * 2, " ");
/* Check the node type and name */
if (Type > ACPI_TYPE_LOCAL_MAX)
{
ACPI_WARNING ((AE_INFO,
"Invalid ACPI Object Type 0x%08X", Type));
}
AcpiOsPrintf ("%4.4s", AcpiUtGetNodeName (ThisNode));
}
/* Now we can print out the pertinent information */
AcpiOsPrintf (" %-12s %p %2.2X ",
AcpiUtGetTypeName (Type), ThisNode, ThisNode->OwnerId);
DbgLevel = AcpiDbgLevel;
AcpiDbgLevel = 0;
ObjDesc = AcpiNsGetAttachedObject (ThisNode);
AcpiDbgLevel = DbgLevel;
/* Temp nodes are those nodes created by a control method */
if (ThisNode->Flags & ANOBJ_TEMPORARY)
{
AcpiOsPrintf ("(T) ");
}
switch (Info->DisplayType & ACPI_DISPLAY_MASK)
{
case ACPI_DISPLAY_SUMMARY:
if (!ObjDesc)
{
/* No attached object. Some types should always have an object */
switch (Type)
{
case ACPI_TYPE_INTEGER:
case ACPI_TYPE_PACKAGE:
case ACPI_TYPE_BUFFER:
case ACPI_TYPE_STRING:
case ACPI_TYPE_METHOD:
AcpiOsPrintf ("<No attached object>");
break;
default:
break;
}
AcpiOsPrintf ("\n");
return (AE_OK);
}
switch (Type)
{
case ACPI_TYPE_PROCESSOR:
AcpiOsPrintf ("ID %02X Len %02X Addr %8.8X%8.8X\n",
ObjDesc->Processor.ProcId, ObjDesc->Processor.Length,
ACPI_FORMAT_UINT64 (ObjDesc->Processor.Address));
break;
case ACPI_TYPE_DEVICE:
AcpiOsPrintf ("Notify Object: %p\n", ObjDesc);
break;
case ACPI_TYPE_METHOD:
AcpiOsPrintf ("Args %X Len %.4X Aml %p\n",
(UINT32) ObjDesc->Method.ParamCount,
ObjDesc->Method.AmlLength, ObjDesc->Method.AmlStart);
break;
case ACPI_TYPE_INTEGER:
AcpiOsPrintf ("= %8.8X%8.8X\n",
ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
break;
case ACPI_TYPE_PACKAGE:
if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
{
AcpiOsPrintf ("Elements %.2X\n",
ObjDesc->Package.Count);
}
else
{
AcpiOsPrintf ("[Length not yet evaluated]\n");
}
break;
case ACPI_TYPE_BUFFER:
if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
{
AcpiOsPrintf ("Len %.2X",
ObjDesc->Buffer.Length);
/* Dump some of the buffer */
if (ObjDesc->Buffer.Length > 0)
{
AcpiOsPrintf (" =");
for (i = 0; (i < ObjDesc->Buffer.Length && i < 12); i++)
{
AcpiOsPrintf (" %.2hX", ObjDesc->Buffer.Pointer[i]);
}
}
AcpiOsPrintf ("\n");
}
else
{
AcpiOsPrintf ("[Length not yet evaluated]\n");
}
break;
case ACPI_TYPE_STRING:
AcpiOsPrintf ("Len %.2X ", ObjDesc->String.Length);
AcpiUtPrintString (ObjDesc->String.Pointer, 80);
AcpiOsPrintf ("\n");
break;
case ACPI_TYPE_REGION:
AcpiOsPrintf ("[%s]",
AcpiUtGetRegionName (ObjDesc->Region.SpaceId));
if (ObjDesc->Region.Flags & AOPOBJ_DATA_VALID)
{
AcpiOsPrintf (" Addr %8.8X%8.8X Len %.4X\n",
ACPI_FORMAT_UINT64 (ObjDesc->Region.Address),
ObjDesc->Region.Length);
}
else
{
AcpiOsPrintf (" [Address/Length not yet evaluated]\n");
}
break;
case ACPI_TYPE_LOCAL_REFERENCE:
AcpiOsPrintf ("[%s]\n", AcpiUtGetReferenceName (ObjDesc));
break;
case ACPI_TYPE_BUFFER_FIELD:
if (ObjDesc->BufferField.BufferObj &&
ObjDesc->BufferField.BufferObj->Buffer.Node)
{
AcpiOsPrintf ("Buf [%4.4s]",
AcpiUtGetNodeName (
ObjDesc->BufferField.BufferObj->Buffer.Node));
}
break;
case ACPI_TYPE_LOCAL_REGION_FIELD:
AcpiOsPrintf ("Rgn [%4.4s]",
AcpiUtGetNodeName (
ObjDesc->CommonField.RegionObj->Region.Node));
break;
case ACPI_TYPE_LOCAL_BANK_FIELD:
AcpiOsPrintf ("Rgn [%4.4s] Bnk [%4.4s]",
AcpiUtGetNodeName (
ObjDesc->CommonField.RegionObj->Region.Node),
AcpiUtGetNodeName (
ObjDesc->BankField.BankObj->CommonField.Node));
break;
case ACPI_TYPE_LOCAL_INDEX_FIELD:
AcpiOsPrintf ("Idx [%4.4s] Dat [%4.4s]",
AcpiUtGetNodeName (
ObjDesc->IndexField.IndexObj->CommonField.Node),
AcpiUtGetNodeName (
ObjDesc->IndexField.DataObj->CommonField.Node));
break;
case ACPI_TYPE_LOCAL_ALIAS:
case ACPI_TYPE_LOCAL_METHOD_ALIAS:
AcpiOsPrintf ("Target %4.4s (%p)\n",
AcpiUtGetNodeName (ObjDesc), ObjDesc);
break;
default:
AcpiOsPrintf ("Object %p\n", ObjDesc);
break;
}
/* Common field handling */
switch (Type)
{
case ACPI_TYPE_BUFFER_FIELD:
case ACPI_TYPE_LOCAL_REGION_FIELD:
case ACPI_TYPE_LOCAL_BANK_FIELD:
case ACPI_TYPE_LOCAL_INDEX_FIELD:
AcpiOsPrintf (" Off %.3X Len %.2X Acc %.2hd\n",
(ObjDesc->CommonField.BaseByteOffset * 8)
+ ObjDesc->CommonField.StartFieldBitOffset,
ObjDesc->CommonField.BitLength,
ObjDesc->CommonField.AccessByteWidth);
break;
default:
break;
}
break;
case ACPI_DISPLAY_OBJECTS:
AcpiOsPrintf ("O:%p", ObjDesc);
if (!ObjDesc)
{
/* No attached object, we are done */
AcpiOsPrintf ("\n");
return (AE_OK);
}
AcpiOsPrintf ("(R%u)", ObjDesc->Common.ReferenceCount);
switch (Type)
{
case ACPI_TYPE_METHOD:
/* Name is a Method and its AML offset/length are set */
AcpiOsPrintf (" M:%p-%X\n", ObjDesc->Method.AmlStart,
ObjDesc->Method.AmlLength);
break;
case ACPI_TYPE_INTEGER:
AcpiOsPrintf (" I:%8.8X8.8%X\n",
ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
break;
case ACPI_TYPE_STRING:
AcpiOsPrintf (" S:%p-%X\n", ObjDesc->String.Pointer,
ObjDesc->String.Length);
break;
case ACPI_TYPE_BUFFER:
AcpiOsPrintf (" B:%p-%X\n", ObjDesc->Buffer.Pointer,
ObjDesc->Buffer.Length);
break;
default:
AcpiOsPrintf ("\n");
break;
}
break;
default:
AcpiOsPrintf ("\n");
break;
}
/* If debug turned off, done */
if (!(AcpiDbgLevel & ACPI_LV_VALUES))
{
return (AE_OK);
}
/* If there is an attached object, display it */
DbgLevel = AcpiDbgLevel;
AcpiDbgLevel = 0;
ObjDesc = AcpiNsGetAttachedObject (ThisNode);
AcpiDbgLevel = DbgLevel;
/* Dump attached objects */
while (ObjDesc)
{
ObjType = ACPI_TYPE_INVALID;
AcpiOsPrintf ("Attached Object %p: ", ObjDesc);
/* Decode the type of attached object and dump the contents */
switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
{
case ACPI_DESC_TYPE_NAMED:
AcpiOsPrintf ("(Ptr to Node)\n");
BytesToDump = sizeof (ACPI_NAMESPACE_NODE);
ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
break;
case ACPI_DESC_TYPE_OPERAND:
ObjType = ObjDesc->Common.Type;
if (ObjType > ACPI_TYPE_LOCAL_MAX)
{
AcpiOsPrintf (
"(Pointer to ACPI Object type %.2X [UNKNOWN])\n",
ObjType);
BytesToDump = 32;
}
else
{
AcpiOsPrintf (
"(Pointer to ACPI Object type %.2X [%s])\n",
ObjType, AcpiUtGetTypeName (ObjType));
BytesToDump = sizeof (ACPI_OPERAND_OBJECT);
}
ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
break;
default:
break;
}
/* If value is NOT an internal object, we are done */
if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND)
{
goto Cleanup;
}
/* Valid object, get the pointer to next level, if any */
switch (ObjType)
{
case ACPI_TYPE_BUFFER:
case ACPI_TYPE_STRING:
/*
* NOTE: takes advantage of common fields between string/buffer
*/
BytesToDump = ObjDesc->String.Length;
ObjDesc = (void *) ObjDesc->String.Pointer;
AcpiOsPrintf ("(Buffer/String pointer %p length %X)\n",
ObjDesc, BytesToDump);
ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
goto Cleanup;
case ACPI_TYPE_BUFFER_FIELD:
ObjDesc = (ACPI_OPERAND_OBJECT *) ObjDesc->BufferField.BufferObj;
break;
case ACPI_TYPE_PACKAGE:
ObjDesc = (void *) ObjDesc->Package.Elements;
break;
case ACPI_TYPE_METHOD:
ObjDesc = (void *) ObjDesc->Method.AmlStart;
break;
case ACPI_TYPE_LOCAL_REGION_FIELD:
ObjDesc = (void *) ObjDesc->Field.RegionObj;
break;
case ACPI_TYPE_LOCAL_BANK_FIELD:
ObjDesc = (void *) ObjDesc->BankField.RegionObj;
break;
case ACPI_TYPE_LOCAL_INDEX_FIELD:
ObjDesc = (void *) ObjDesc->IndexField.IndexObj;
break;
default:
goto Cleanup;
}
ObjType = ACPI_TYPE_INVALID; /* Terminate loop after next pass */
}
Cleanup:
AcpiOsPrintf ("\n");
return (AE_OK);
}
ACPI_STATUS
AeInstallHandlers (void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_HANDLE Handle;
ACPI_FUNCTION_ENTRY ();
Status = AcpiInstallTableHandler (AeTableHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install table handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallExceptionHandler (AeExceptionHandler);
if (ACPI_FAILURE (Status))
{
printf ("Could not install exception handler, %s\n",
AcpiFormatException (Status));
}
/* Install global notify handler */
Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a global notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_DEVICE_NOTIFY,
AeDeviceNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a global notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiRemoveNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler);
if (ACPI_FAILURE (Status))
{
printf ("Could not remove a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler, NULL);
Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler);
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
Status = AcpiDetachData (Handle, AeAttachedDataHandler);
Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
}
else
{
printf ("No _SB_ found, %s\n", AcpiFormatException (Status));
}
/* Set a handler for all supported operation regions */
for (i = 0; i < AEXEC_NUM_REGIONS; i++)
{
Status = AcpiRemoveAddressSpaceHandler (AcpiGbl_RootNode,
SpaceId[i], AeRegionHandler);
/* Install handler at the root object.
* TBD: all default handlers should be installed here!
*/
Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode,
SpaceId[i], AeRegionHandler, AeRegionInit, NULL);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"Could not install an OpRegion handler for %s space(%u)",
AcpiUtGetRegionName((UINT8) SpaceId[i]), SpaceId[i]));
return (Status);
}
}
/*
* Initialize the global Region Handler space
* MCW 3/23/00
*/
AeRegions.NumberOfRegions = 0;
AeRegions.RegionList = NULL;
return Status;
}
ACPI_STATUS
AcpiEvInstallSpaceHandler (
ACPI_NAMESPACE_NODE *Node,
ACPI_ADR_SPACE_TYPE SpaceId,
ACPI_ADR_SPACE_HANDLER Handler,
ACPI_ADR_SPACE_SETUP Setup,
void *Context)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_STATUS Status = AE_OK;
ACPI_OBJECT_TYPE Type;
UINT8 Flags = 0;
ACPI_FUNCTION_TRACE (EvInstallSpaceHandler);
/*
* This registration is valid for only the types below and the root.
* The root node is where the default handlers get installed.
*/
if ((Node->Type != ACPI_TYPE_DEVICE) &&
(Node->Type != ACPI_TYPE_PROCESSOR) &&
(Node->Type != ACPI_TYPE_THERMAL) &&
(Node != AcpiGbl_RootNode))
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
if (Handler == ACPI_DEFAULT_HANDLER)
{
Flags = ACPI_ADDR_HANDLER_DEFAULT_INSTALLED;
switch (SpaceId)
{
case ACPI_ADR_SPACE_SYSTEM_MEMORY:
Handler = AcpiExSystemMemorySpaceHandler;
Setup = AcpiEvSystemMemoryRegionSetup;
break;
case ACPI_ADR_SPACE_SYSTEM_IO:
Handler = AcpiExSystemIoSpaceHandler;
Setup = AcpiEvIoSpaceRegionSetup;
break;
case ACPI_ADR_SPACE_PCI_CONFIG:
Handler = AcpiExPciConfigSpaceHandler;
Setup = AcpiEvPciConfigRegionSetup;
break;
case ACPI_ADR_SPACE_CMOS:
Handler = AcpiExCmosSpaceHandler;
Setup = AcpiEvCmosRegionSetup;
break;
case ACPI_ADR_SPACE_PCI_BAR_TARGET:
Handler = AcpiExPciBarSpaceHandler;
Setup = AcpiEvPciBarRegionSetup;
break;
case ACPI_ADR_SPACE_DATA_TABLE:
Handler = AcpiExDataTableSpaceHandler;
Setup = NULL;
break;
default:
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
}
/* If the caller hasn't specified a setup routine, use the default */
if (!Setup)
{
Setup = AcpiEvDefaultRegionSetup;
}
/* Check for an existing internal object */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
/*
* The attached device object already exists. Now make sure
* the handler is not already installed.
*/
HandlerObj = AcpiEvFindRegionHandler (SpaceId,
ObjDesc->CommonNotify.Handler);
if (HandlerObj)
{
if (HandlerObj->AddressSpace.Handler == Handler)
{
/*
* It is (relatively) OK to attempt to install the SAME
* handler twice. This can easily happen with the
* PCI_Config space.
*/
Status = AE_SAME_HANDLER;
goto UnlockAndExit;
}
else
{
/* A handler is already installed */
Status = AE_ALREADY_EXISTS;
}
goto UnlockAndExit;
}
}
else
{
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Creating object on Device %p while installing handler\n",
Node));
/* ObjDesc does not exist, create one */
if (Node->Type == ACPI_TYPE_ANY)
{
Type = ACPI_TYPE_DEVICE;
}
else
{
Type = Node->Type;
}
ObjDesc = AcpiUtCreateInternalObject (Type);
if (!ObjDesc)
{
Status = AE_NO_MEMORY;
goto UnlockAndExit;
}
/* Init new descriptor */
ObjDesc->Common.Type = (UINT8) Type;
/* Attach the new object to the Node */
Status = AcpiNsAttachObject (Node, ObjDesc, Type);
/* Remove local reference to the object */
AcpiUtRemoveReference (ObjDesc);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Installing address handler for region %s(%X) "
"on Device %4.4s %p(%p)\n",
AcpiUtGetRegionName (SpaceId), SpaceId,
AcpiUtGetNodeName (Node), Node, ObjDesc));
/*
* Install the handler
*
* At this point there is no existing handler. Just allocate the object
* for the handler and link it into the list.
*/
HandlerObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_ADDRESS_HANDLER);
if (!HandlerObj)
{
Status = AE_NO_MEMORY;
goto UnlockAndExit;
}
/* Init handler obj */
HandlerObj->AddressSpace.SpaceId = (UINT8) SpaceId;
HandlerObj->AddressSpace.HandlerFlags = Flags;
HandlerObj->AddressSpace.RegionList = NULL;
HandlerObj->AddressSpace.Node = Node;
HandlerObj->AddressSpace.Handler = Handler;
HandlerObj->AddressSpace.Context = Context;
HandlerObj->AddressSpace.Setup = Setup;
/* Install at head of Device.AddressSpace list */
HandlerObj->AddressSpace.Next = ObjDesc->CommonNotify.Handler;
/*
* The Device object is the first reference on the HandlerObj.
* Each region that uses the handler adds a reference.
*/
ObjDesc->CommonNotify.Handler = HandlerObj;
/*
* Walk the namespace finding all of the regions this handler will
* manage.
*
* Start at the device and search the branch toward the leaf nodes
* until either the leaf is encountered or a device is detected that
* has an address handler of the same type.
*
* In either case, back up and search down the remainder of the branch
*/
Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, Node,
ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
AcpiEvInstallHandler, NULL, HandlerObj, NULL);
UnlockAndExit:
return_ACPI_STATUS (Status);
}
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);
ACPI_PHYSICAL_ADDRESS BaseAddress;
ACPI_SIZE Length;
BOOLEAN BufferExists;
AE_REGION *RegionElement;
void *BufferValue;
ACPI_STATUS Status;
UINT32 ByteWidth;
UINT32 i;
UINT8 SpaceId;
ACPI_FUNCTION_NAME (AeRegionHandler);
/*
* If the object is not a region, simply return
*/
if (RegionObject->Region.Type != ACPI_TYPE_REGION)
{
return AE_OK;
}
/*
* Region support can be disabled with the -r 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;
}
/*
* 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));
switch (SpaceId)
{
case ACPI_ADR_SPACE_SYSTEM_IO:
/*
* For I/O space, exercise the port validation
*/
switch (Function & ACPI_IO_MASK)
{
case ACPI_READ:
Status = AcpiHwReadPort (Address, (UINT32 *) Value, BitWidth);
break;
case ACPI_WRITE:
Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth);
break;
default:
Status = AE_BAD_PARAMETER;
break;
}
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Now go ahead and simulate the hardware */
break;
case ACPI_ADR_SPACE_SMBUS:
Length = 0;
switch (Function & ACPI_IO_MASK)
{
case ACPI_READ:
switch (Function >> 16)
{
case AML_FIELD_ATTRIB_SMB_QUICK:
case AML_FIELD_ATTRIB_SMB_SEND_RCV:
case AML_FIELD_ATTRIB_SMB_BYTE:
Length = 1;
break;
case AML_FIELD_ATTRIB_SMB_WORD:
case AML_FIELD_ATTRIB_SMB_WORD_CALL:
Length = 2;
break;
case AML_FIELD_ATTRIB_SMB_BLOCK:
case AML_FIELD_ATTRIB_SMB_BLOCK_CALL:
Length = 32;
break;
default:
break;
}
break;
case ACPI_WRITE:
switch (Function >> 16)
{
case AML_FIELD_ATTRIB_SMB_QUICK:
case AML_FIELD_ATTRIB_SMB_SEND_RCV:
case AML_FIELD_ATTRIB_SMB_BYTE:
case AML_FIELD_ATTRIB_SMB_WORD:
case AML_FIELD_ATTRIB_SMB_BLOCK:
Length = 0;
break;
case AML_FIELD_ATTRIB_SMB_WORD_CALL:
Length = 2;
break;
case AML_FIELD_ATTRIB_SMB_BLOCK_CALL:
Length = 32;
break;
default:
break;
}
break;
default:
break;
}
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 */
AcpiOsPrintf ("AcpiExec: Received IPMI request: "
"Address %X BaseAddress %X Length %X Width %X BufferLength %u\n",
(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] = 0x34; /* Power measurement */
Buffer[4] = 0x12; /* Power measurement */
Buffer[65] = 0xEE; /* last buffer byte */
return (AE_OK);
default:
break;
}
/*
* Search through the linked list for this region's buffer
*/
BufferExists = FALSE;
RegionElement = AeRegions.RegionList;
if (AeRegions.NumberOfRegions)
{
while (!BufferExists && RegionElement)
{
if (RegionElement->Address == BaseAddress &&
RegionElement->Length == Length &&
RegionElement->SpaceId == SpaceId)
{
BufferExists = TRUE;
}
else
{
RegionElement = RegionElement->NextRegion;
}
}
}
/*
* 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 */
ACPI_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 (((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
*/
ACPI_MEMCPY (Value, BufferValue, ByteWidth);
break;
case ACPI_WRITE:
/*
* Write the contents of Value to the buffer
*/
ACPI_MEMCPY (BufferValue, Value, ByteWidth);
break;
default:
return AE_BAD_PARAMETER;
}
return AE_OK;
}
ACPI_STATUS
AcpiEvInitializeRegion (
ACPI_OPERAND_OBJECT *RegionObj,
BOOLEAN AcpiNsLocked)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_ADR_SPACE_TYPE SpaceId;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE_U32 (EvInitializeRegion, AcpiNsLocked);
if (!RegionObj)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
if (RegionObj->Common.Flags & AOPOBJ_OBJECT_INITIALIZED)
{
return_ACPI_STATUS (AE_OK);
}
RegionObj->Common.Flags |= AOPOBJ_OBJECT_INITIALIZED;
Node = RegionObj->Region.Node->Parent;
SpaceId = RegionObj->Region.SpaceId;
/*
* The following loop depends upon the root Node having no parent
* ie: AcpiGbl_RootNode->Parent being set to NULL
*/
while (Node)
{
/* Check to see if a handler exists */
HandlerObj = NULL;
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
/* Can only be a handler if the object exists */
switch (Node->Type)
{
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_THERMAL:
HandlerObj = ObjDesc->CommonNotify.Handler;
break;
case ACPI_TYPE_METHOD:
/*
* If we are executing module level code, the original
* Node's object was replaced by this Method object and we
* saved the handler in the method object.
*
* See AcpiNsExecModuleCode
*/
if (ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)
{
HandlerObj = ObjDesc->Method.Dispatch.Handler;
}
break;
default:
/* Ignore other objects */
break;
}
HandlerObj = AcpiEvFindRegionHandler (SpaceId, HandlerObj);
if (HandlerObj)
{
/* Found correct handler */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Found handler %p for region %p in obj %p\n",
HandlerObj, RegionObj, ObjDesc));
Status = AcpiEvAttachRegion (HandlerObj, RegionObj,
AcpiNsLocked);
/*
* Tell all users that this region is usable by
* running the _REG method
*/
if (AcpiNsLocked)
{
Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
Status = AcpiEvExecuteRegMethod (RegionObj, ACPI_REG_CONNECT);
if (AcpiNsLocked)
{
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
return_ACPI_STATUS (AE_OK);
}
}
/* This node does not have the handler we need; Pop up one level */
Node = Node->Parent;
}
/* If we get here, there is no handler for this region */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"No handler for RegionType %s(%X) (RegionObj %p)\n",
AcpiUtGetRegionName (SpaceId), SpaceId, RegionObj));
return_ACPI_STATUS (AE_NOT_EXIST);
}
void
AcpiDbDisplayHandlers (
void)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_ADR_SPACE_TYPE SpaceId;
UINT32 i;
/* Operation region handlers */
AcpiOsPrintf ("\nOperation Region Handlers:\n");
ObjDesc = AcpiNsGetAttachedObject (AcpiGbl_RootNode);
if (ObjDesc)
{
for (i = 0; i < ACPI_ARRAY_LENGTH (AcpiGbl_SpaceIdList); i++)
{
SpaceId = AcpiGbl_SpaceIdList[i];
HandlerObj = ObjDesc->Device.Handler;
AcpiOsPrintf (ACPI_PREDEFINED_PREFIX,
AcpiUtGetRegionName ((UINT8) SpaceId), SpaceId);
while (HandlerObj)
{
if (i == HandlerObj->AddressSpace.SpaceId)
{
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING,
(HandlerObj->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default" : "User",
HandlerObj->AddressSpace.Handler);
goto FoundHandler;
}
HandlerObj = HandlerObj->AddressSpace.Next;
}
/* There is no handler for this SpaceId */
AcpiOsPrintf ("None\n");
FoundHandler:;
}
}
/* Fixed event handlers */
AcpiOsPrintf ("\nFixed Event Handlers:\n");
for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
{
AcpiOsPrintf (ACPI_PREDEFINED_PREFIX, AcpiUtGetEventName (i), i);
if (AcpiGbl_FixedEventHandlers[i].Handler)
{
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING, "User",
AcpiGbl_FixedEventHandlers[i].Handler);
}
else
{
AcpiOsPrintf (ACPI_HANDLER_NOT_PRESENT_STRING, "None");
}
}
/* Miscellaneous global handlers */
AcpiOsPrintf ("\nMiscellaneous Global Handlers:\n");
for (i = 0; i < ACPI_ARRAY_LENGTH (AcpiGbl_HandlerList); i++)
{
AcpiOsPrintf (ACPI_HANDLER_NAME_STRING, AcpiGbl_HandlerList[i].Name);
if (AcpiGbl_HandlerList[i].Handler)
{
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING, "User",
AcpiGbl_HandlerList[i].Handler);
}
else
{
AcpiOsPrintf (ACPI_HANDLER_NOT_PRESENT_STRING, "None");
}
}
}
void
AcpiEvDetachRegion(
ACPI_OPERAND_OBJECT *RegionObj,
BOOLEAN AcpiNsIsLocked)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *StartDesc;
ACPI_OPERAND_OBJECT **LastObjPtr;
ACPI_ADR_SPACE_SETUP RegionSetup;
void **RegionContext;
ACPI_OPERAND_OBJECT *RegionObj2;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (EvDetachRegion);
RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
if (!RegionObj2)
{
return_VOID;
}
RegionContext = &RegionObj2->Extra.RegionContext;
/* Get the address handler from the region object */
HandlerObj = RegionObj->Region.Handler;
if (!HandlerObj)
{
/* This region has no handler, all done */
return_VOID;
}
/* Find this region in the handler's list */
ObjDesc = HandlerObj->AddressSpace.RegionList;
StartDesc = ObjDesc;
LastObjPtr = &HandlerObj->AddressSpace.RegionList;
while (ObjDesc)
{
/* Is this the correct Region? */
if (ObjDesc == RegionObj)
{
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Removing Region %p from address handler %p\n",
RegionObj, HandlerObj));
/* This is it, remove it from the handler's list */
*LastObjPtr = ObjDesc->Region.Next;
ObjDesc->Region.Next = NULL; /* Must clear field */
if (AcpiNsIsLocked)
{
Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_VOID;
}
}
/* Now stop region accesses by executing the _REG method */
Status = AcpiEvExecuteRegMethod (RegionObj, ACPI_REG_DISCONNECT);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "from region _REG, [%s]",
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
}
if (AcpiNsIsLocked)
{
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_VOID;
}
}
/*
* If the region has been activated, call the setup handler with
* the deactivate notification
*/
if (RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE)
{
RegionSetup = HandlerObj->AddressSpace.Setup;
Status = RegionSetup (RegionObj, ACPI_REGION_DEACTIVATE,
HandlerObj->AddressSpace.Context, RegionContext);
/*
* RegionContext should have been released by the deactivate
* operation. We don't need access to it anymore here.
*/
if (RegionContext)
{
*RegionContext = NULL;
}
/* Init routine may fail, Just ignore errors */
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"from region handler - deactivate, [%s]",
AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
}
RegionObj->Region.Flags &= ~(AOPOBJ_SETUP_COMPLETE);
}
/*
* Remove handler reference in the region
*
* NOTE: this doesn't mean that the region goes away, the region
* is just inaccessible as indicated to the _REG method
*
* If the region is on the handler's list, this must be the
* region's handler
*/
RegionObj->Region.Handler = NULL;
AcpiUtRemoveReference (HandlerObj);
return_VOID;
}
/* Walk the linked list of handlers */
LastObjPtr = &ObjDesc->Region.Next;
ObjDesc = ObjDesc->Region.Next;
/* Prevent infinite loop if list is corrupted */
if (ObjDesc == StartDesc)
{
ACPI_ERROR ((AE_INFO,
"Circular handler list in region object %p",
RegionObj));
return_VOID;
}
}
/* If we get here, the region was not in the handler's region list */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Cannot remove region %p from address handler %p\n",
RegionObj, HandlerObj));
return_VOID;
}
UINT32
AcpiUtCheckAddressRange (
ACPI_ADR_SPACE_TYPE SpaceId,
ACPI_PHYSICAL_ADDRESS Address,
UINT32 Length,
BOOLEAN Warn)
{
ACPI_ADDRESS_RANGE *RangeInfo;
ACPI_PHYSICAL_ADDRESS EndAddress;
char *Pathname;
UINT32 OverlapCount = 0;
ACPI_FUNCTION_TRACE (UtCheckAddressRange);
if ((SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
(SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
{
return_UINT32 (0);
}
RangeInfo = AcpiGbl_AddressRangeList[SpaceId];
EndAddress = Address + Length - 1;
/* Check entire list for all possible conflicts */
while (RangeInfo)
{
/*
* Check if the requested address/length overlaps this
* address range. There are four cases to consider:
*
* 1) Input address/length is contained completely in the
* address range
* 2) Input address/length overlaps range at the range start
* 3) Input address/length overlaps range at the range end
* 4) Input address/length completely encompasses the range
*/
if ((Address <= RangeInfo->EndAddress) &&
(EndAddress >= RangeInfo->StartAddress))
{
/* Found an address range overlap */
OverlapCount++;
if (Warn) /* Optional warning message */
{
Pathname = AcpiNsGetNormalizedPathname (RangeInfo->RegionNode, TRUE);
ACPI_WARNING ((AE_INFO,
"%s range 0x%8.8X%8.8X-0x%8.8X%8.8X conflicts with OpRegion 0x%8.8X%8.8X-0x%8.8X%8.8X (%s)",
AcpiUtGetRegionName (SpaceId),
ACPI_FORMAT_UINT64 (Address),
ACPI_FORMAT_UINT64 (EndAddress),
ACPI_FORMAT_UINT64 (RangeInfo->StartAddress),
ACPI_FORMAT_UINT64 (RangeInfo->EndAddress),
Pathname));
ACPI_FREE (Pathname);
}
}
RangeInfo = RangeInfo->Next;
}
return_UINT32 (OverlapCount);
}
void
AcpiDbDisplayHandlers (
void)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_ADR_SPACE_TYPE SpaceId;
UINT32 i;
/* Operation region handlers */
AcpiOsPrintf ("\nOperation Region Handlers at the namespace root:\n");
ObjDesc = AcpiNsGetAttachedObject (AcpiGbl_RootNode);
if (ObjDesc)
{
for (i = 0; i < ACPI_ARRAY_LENGTH (AcpiGbl_SpaceIdList); i++)
{
SpaceId = AcpiGbl_SpaceIdList[i];
HandlerObj = ObjDesc->Device.Handler;
AcpiOsPrintf (ACPI_PREDEFINED_PREFIX,
AcpiUtGetRegionName ((UINT8) SpaceId), SpaceId);
while (HandlerObj)
{
if (AcpiGbl_SpaceIdList[i] ==
HandlerObj->AddressSpace.SpaceId)
{
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING,
(HandlerObj->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ?
"Default" : "User",
HandlerObj->AddressSpace.Handler);
goto FoundHandler;
}
HandlerObj = HandlerObj->AddressSpace.Next;
}
/* There is no handler for this SpaceId */
AcpiOsPrintf ("None\n");
FoundHandler:;
}
/* Find all handlers for user-defined SpaceIDs */
HandlerObj = ObjDesc->Device.Handler;
while (HandlerObj)
{
if (HandlerObj->AddressSpace.SpaceId >= ACPI_USER_REGION_BEGIN)
{
AcpiOsPrintf (ACPI_PREDEFINED_PREFIX,
"User-defined ID", HandlerObj->AddressSpace.SpaceId);
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING,
(HandlerObj->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ?
"Default" : "User",
HandlerObj->AddressSpace.Handler);
}
HandlerObj = HandlerObj->AddressSpace.Next;
}
}
#if (!ACPI_REDUCED_HARDWARE)
/* Fixed event handlers */
AcpiOsPrintf ("\nFixed Event Handlers:\n");
for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
{
AcpiOsPrintf (ACPI_PREDEFINED_PREFIX, AcpiUtGetEventName (i), i);
if (AcpiGbl_FixedEventHandlers[i].Handler)
{
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING, "User",
AcpiGbl_FixedEventHandlers[i].Handler);
}
else
{
AcpiOsPrintf (ACPI_HANDLER_NOT_PRESENT_STRING, "None");
}
}
#endif /* !ACPI_REDUCED_HARDWARE */
/* Miscellaneous global handlers */
AcpiOsPrintf ("\nMiscellaneous Global Handlers:\n");
for (i = 0; i < ACPI_ARRAY_LENGTH (AcpiGbl_HandlerList); i++)
{
AcpiOsPrintf (ACPI_HANDLER_NAME_STRING,
AcpiGbl_HandlerList[i].Name);
if (AcpiGbl_HandlerList[i].Handler)
{
AcpiOsPrintf (ACPI_HANDLER_PRESENT_STRING, "User",
AcpiGbl_HandlerList[i].Handler);
}
else
{
AcpiOsPrintf (ACPI_HANDLER_NOT_PRESENT_STRING, "None");
}
}
/* Other handlers that are installed throughout the namespace */
AcpiOsPrintf ("\nOperation Region Handlers for specific devices:\n");
(void) AcpiWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
ACPI_UINT32_MAX, AcpiDbDisplayNonRootHandlers,
NULL, NULL, NULL);
}
ACPI_STATUS
AcpiEvInitializeRegion (
ACPI_OPERAND_OBJECT *RegionObj)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_ADR_SPACE_TYPE SpaceId;
ACPI_NAMESPACE_NODE *Node;
ACPI_FUNCTION_TRACE (EvInitializeRegion);
if (!RegionObj)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
if (RegionObj->Common.Flags & AOPOBJ_OBJECT_INITIALIZED)
{
return_ACPI_STATUS (AE_OK);
}
RegionObj->Common.Flags |= AOPOBJ_OBJECT_INITIALIZED;
Node = RegionObj->Region.Node->Parent;
SpaceId = RegionObj->Region.SpaceId;
/*
* The following loop depends upon the root Node having no parent
* ie: AcpiGbl_RootNode->Parent being set to NULL
*/
while (Node)
{
/* Check to see if a handler exists */
HandlerObj = NULL;
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
/* Can only be a handler if the object exists */
switch (Node->Type)
{
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_THERMAL:
HandlerObj = ObjDesc->CommonNotify.Handler;
break;
case ACPI_TYPE_METHOD:
/*
* If we are executing module level code, the original
* Node's object was replaced by this Method object and we
* saved the handler in the method object.
*
* Note: Only used for the legacy MLC support. Will
* be removed in the future.
*
* See AcpiNsExecModuleCode
*/
if (!AcpiGbl_ExecuteTablesAsMethods &&
ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)
{
HandlerObj = ObjDesc->Method.Dispatch.Handler;
}
break;
default:
/* Ignore other objects */
break;
}
HandlerObj = AcpiEvFindRegionHandler (SpaceId, HandlerObj);
if (HandlerObj)
{
/* Found correct handler */
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Found handler %p for region %p in obj %p\n",
HandlerObj, RegionObj, ObjDesc));
(void) AcpiEvAttachRegion (HandlerObj, RegionObj, FALSE);
/*
* Tell all users that this region is usable by
* running the _REG method
*/
AcpiExExitInterpreter ();
(void) AcpiEvExecuteRegMethod (RegionObj, ACPI_REG_CONNECT);
AcpiExEnterInterpreter ();
return_ACPI_STATUS (AE_OK);
}
}
/* This node does not have the handler we need; Pop up one level */
Node = Node->Parent;
}
/*
* If we get here, there is no handler for this region. This is not
* fatal because many regions get created before a handler is installed
* for said region.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"No handler for RegionType %s(%X) (RegionObj %p)\n",
AcpiUtGetRegionName (SpaceId), SpaceId, RegionObj));
return_ACPI_STATUS (AE_OK);
}