static void
OpcDoConnection (
ACPI_PARSE_OBJECT *Op)
{
ASL_RESOURCE_NODE *Rnode;
ACPI_PARSE_OBJECT *BufferOp;
ACPI_PARSE_OBJECT *BufferLengthOp;
ACPI_PARSE_OBJECT *BufferDataOp;
ASL_RESOURCE_INFO Info;
UINT8 State;
Op->Asl.AmlOpcodeLength = 1;
if (Op->Asl.Child->Asl.AmlOpcode == AML_INT_NAMEPATH_OP)
{
return;
}
BufferOp = Op->Asl.Child;
BufferLengthOp = BufferOp->Asl.Child;
BufferDataOp = BufferLengthOp->Asl.Next;
Info.DescriptorTypeOp = BufferDataOp->Asl.Next;
Info.CurrentByteOffset = 0;
State = ACPI_RSTATE_NORMAL;
Rnode = RsDoOneResourceDescriptor (&Info, &State);
if (!Rnode)
{
return; /* error */
}
/*
* Transform the nodes into the following
*
* Op -> AML_BUFFER_OP
* First Child -> BufferLength
* Second Child -> Descriptor Buffer (raw byte data)
*/
BufferOp->Asl.ParseOpcode = PARSEOP_BUFFER;
BufferOp->Asl.AmlOpcode = AML_BUFFER_OP;
BufferOp->Asl.CompileFlags = NODE_AML_PACKAGE | NODE_IS_RESOURCE_DESC;
UtSetParseOpName (BufferOp);
BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
BufferLengthOp->Asl.Value.Integer = Rnode->BufferLength;
(void) OpcSetOptimalIntegerSize (BufferLengthOp);
UtSetParseOpName (BufferLengthOp);
BufferDataOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
BufferDataOp->Asl.AmlOpcode = AML_RAW_DATA_CHAIN;
BufferDataOp->Asl.AmlOpcodeLength = 0;
BufferDataOp->Asl.AmlLength = Rnode->BufferLength;
BufferDataOp->Asl.Value.Buffer = (UINT8 *) Rnode;
UtSetParseOpName (BufferDataOp);
}
static void
OpcUpdateIntegerNode (
ACPI_PARSE_OBJECT *Op,
UINT64 Value)
{
Op->Common.Value.Integer = Value;
/*
* The AmlLength is used by the parser to indicate a constant,
* (if non-zero). Length is either (1/2/4/8)
*/
switch (Op->Asl.AmlLength)
{
case 1:
TrUpdateNode (PARSEOP_BYTECONST, Op);
Op->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
break;
case 2:
TrUpdateNode (PARSEOP_WORDCONST, Op);
Op->Asl.AmlOpcode = AML_RAW_DATA_WORD;
break;
case 4:
TrUpdateNode (PARSEOP_DWORDCONST, Op);
Op->Asl.AmlOpcode = AML_RAW_DATA_DWORD;
break;
case 8:
TrUpdateNode (PARSEOP_QWORDCONST, Op);
Op->Asl.AmlOpcode = AML_RAW_DATA_QWORD;
break;
case 0:
default:
OpcSetOptimalIntegerSize (Op);
TrUpdateNode (PARSEOP_INTEGER, Op);
break;
}
Op->Asl.AmlLength = 0;
}
void
RsDoResourceTemplate (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *BufferLengthOp;
ACPI_PARSE_OBJECT *BufferOp;
ACPI_PARSE_OBJECT *DescriptorTypeOp;
ACPI_PARSE_OBJECT *LastOp = NULL;
UINT32 CurrentByteOffset = 0;
ASL_RESOURCE_NODE HeadRnode;
ASL_RESOURCE_NODE *PreviousRnode;
ASL_RESOURCE_NODE *Rnode;
UINT8 State;
/* Mark parent as containing a resource template */
if (Op->Asl.Parent)
{
Op->Asl.Parent->Asl.CompileFlags |= NODE_IS_RESOURCE_DESC;
}
/* ResourceTemplate Opcode is first (Op) */
/* Buffer Length node is first child */
BufferLengthOp = ASL_GET_CHILD_NODE (Op);
/* Buffer Op is first peer */
BufferOp = ASL_GET_PEER_NODE (BufferLengthOp);
/* First Descriptor type is next */
DescriptorTypeOp = ASL_GET_PEER_NODE (BufferOp);
/*
* Process all resource descriptors in the list
* Note: It is assumed that the EndTag node has been automatically
* inserted at the end of the template by the parser.
*/
State = ACPI_RSTATE_NORMAL;
PreviousRnode = &HeadRnode;
while (DescriptorTypeOp)
{
DescriptorTypeOp->Asl.CompileFlags |= NODE_IS_RESOURCE_DESC;
Rnode = RsDoOneResourceDescriptor (DescriptorTypeOp, CurrentByteOffset,
&State);
/*
* Update current byte offset to indicate the number of bytes from the
* start of the buffer. Buffer can include multiple descriptors, we
* must keep track of the offset of not only each descriptor, but each
* element (field) within each descriptor as well.
*/
CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, Rnode);
/* Get the next descriptor in the list */
LastOp = DescriptorTypeOp;
DescriptorTypeOp = ASL_GET_PEER_NODE (DescriptorTypeOp);
}
if (State == ACPI_RSTATE_DEPENDENT_LIST)
{
if (LastOp)
{
LastOp = LastOp->Asl.Parent;
}
AslError (ASL_ERROR, ASL_MSG_MISSING_ENDDEPENDENT, LastOp, NULL);
}
/*
* Transform the nodes into the following
*
* Op -> AML_BUFFER_OP
* First Child -> BufferLength
* Second Child -> Descriptor Buffer (raw byte data)
*/
Op->Asl.ParseOpcode = PARSEOP_BUFFER;
Op->Asl.AmlOpcode = AML_BUFFER_OP;
Op->Asl.CompileFlags = NODE_AML_PACKAGE | NODE_IS_RESOURCE_DESC;
BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
BufferLengthOp->Asl.Value.Integer = CurrentByteOffset;
(void) OpcSetOptimalIntegerSize (BufferLengthOp);
BufferOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
BufferOp->Asl.AmlOpcode = AML_RAW_DATA_CHAIN;
BufferOp->Asl.AmlOpcodeLength = 0;
BufferOp->Asl.AmlLength = CurrentByteOffset;
BufferOp->Asl.Value.Buffer = (UINT8 *) HeadRnode.Next;
BufferOp->Asl.CompileFlags |= NODE_IS_RESOURCE_DATA;
return;
}
void
OpnDoPackage (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *InitializerOp;
ACPI_PARSE_OBJECT *PackageLengthOp;
UINT32 PackageLength = 0;
/* Opcode and package length first, followed by the initializer list */
PackageLengthOp = Op->Asl.Child;
InitializerOp = PackageLengthOp->Asl.Next;
/* Count the number of items in the initializer list */
if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
{
/* The peer list contains the byte list (if any...) */
while (InitializerOp)
{
PackageLength++;
InitializerOp = InitializerOp->Asl.Next;
}
}
/* If package length is a constant, compare to the initializer list */
if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) ||
(PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST))
{
if (PackageLengthOp->Asl.Value.Integer > PackageLength)
{
/*
* Allow package length to be longer than the initializer
* list -- but if the length of initializer list is nonzero,
* issue a message since this is probably a coding error,
* even though technically legal.
*/
if (PackageLength > 0)
{
AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT,
PackageLengthOp, NULL);
}
PackageLength = (UINT32) PackageLengthOp->Asl.Value.Integer;
}
else if (PackageLengthOp->Asl.Value.Integer < PackageLength)
{
/*
* The package length is smaller than the length of the
* initializer list. This is an error as per the ACPI spec.
*/
AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG,
PackageLengthOp, NULL);
}
}
if (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
{
/*
* This is the case if the PackageLength was left empty - Package()
* The package length becomes the length of the initializer list
*/
Op->Asl.Child->Asl.ParseOpcode = PARSEOP_INTEGER;
Op->Asl.Child->Asl.Value.Integer = PackageLength;
/* Set the AML opcode */
(void) OpcSetOptimalIntegerSize (Op->Asl.Child);
}
/* If not a variable-length package, check for a zero package length */
if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) ||
(PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST) ||
(PackageLengthOp->Asl.ParseOpcode == PARSEOP_ZERO) ||
(PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG))
{
if (!PackageLength)
{
/* No length AND no initializer list -- issue a remark */
AslError (ASL_REMARK, ASL_MSG_PACKAGE_LENGTH,
PackageLengthOp, NULL);
/* But go ahead and put the buffer length of zero into the AML */
}
}
/*
* If the PackageLength is a constant <= 255, we can change the
* AML opcode from VarPackage to a simple (ACPI 1.0) Package opcode.
*/
if (((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
(Op->Asl.Child->Asl.Value.Integer <= 255)) ||
(Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONE) ||
(Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONES)||
(Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ZERO))
{
Op->Asl.AmlOpcode = AML_PACKAGE_OP;
Op->Asl.ParseOpcode = PARSEOP_PACKAGE;
/*
* Just set the package size node to be the package length, regardless
* of whether it was previously an integer or a default_arg placeholder
*/
PackageLengthOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
PackageLengthOp->Asl.AmlLength = 1;
PackageLengthOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
PackageLengthOp->Asl.Value.Integer = PackageLength;
}
/* Remaining nodes are handled via the tree walk */
}
static void
OpnDoBuffer (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *InitializerOp;
ACPI_PARSE_OBJECT *BufferLengthOp;
/* Optional arguments for this opcode with defaults */
UINT32 BufferLength = 0;
/* Opcode and package length first */
/* Buffer Length is next, followed by the initializer list */
BufferLengthOp = Op->Asl.Child;
InitializerOp = BufferLengthOp->Asl.Next;
/*
* If the BufferLength is not an INTEGER or was not specified in the ASL
* (DEFAULT_ARG), it is a TermArg that is
* evaluated at run-time, and we are therefore finished.
*/
if ((BufferLengthOp->Asl.ParseOpcode != PARSEOP_INTEGER) &&
(BufferLengthOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
{
return;
}
/*
* We want to count the number of items in the initializer list, because if
* it is larger than the buffer length, we will define the buffer size
* to be the size of the initializer list (as per the ACPI Specification)
*/
switch (InitializerOp->Asl.ParseOpcode)
{
case PARSEOP_INTEGER:
case PARSEOP_BYTECONST:
case PARSEOP_WORDCONST:
case PARSEOP_DWORDCONST:
/* The peer list contains the byte list (if any...) */
while (InitializerOp)
{
/* For buffers, this is a list of raw bytes */
InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
InitializerOp->Asl.AmlLength = 1;
InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
BufferLength++;
InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
}
break;
case PARSEOP_STRING_LITERAL:
/*
* Only one initializer, the string. Buffer must be big enough to hold
* the string plus the null termination byte
*/
BufferLength = strlen (InitializerOp->Asl.Value.String) + 1;
InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
InitializerOp->Asl.AmlLength = BufferLength;
InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
break;
case PARSEOP_RAW_DATA:
/* Buffer nodes are already initialized (e.g. Unicode operator) */
return;
case PARSEOP_DEFAULT_ARG:
break;
default:
AslError (ASL_ERROR, ASL_MSG_INVALID_OPERAND, InitializerOp,
"Unknown buffer initializer opcode");
printf ("Unknown buffer initializer opcode [%s]\n",
UtGetOpName (InitializerOp->Asl.ParseOpcode));
return;
}
/* Check if initializer list is longer than the buffer length */
if (BufferLengthOp->Asl.Value.Integer > BufferLength)
{
BufferLength = (UINT32) BufferLengthOp->Asl.Value.Integer;
}
if (!BufferLength)
{
/* No length AND no items -- issue notice */
AslError (ASL_REMARK, ASL_MSG_BUFFER_LENGTH, BufferLengthOp, NULL);
/* But go ahead and put the buffer length of zero into the AML */
}
/*
* Just set the buffer size node to be the buffer length, regardless
* of whether it was previously an integer or a default_arg placeholder
*/
BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
BufferLengthOp->Asl.AmlOpcode = AML_DWORD_OP;
BufferLengthOp->Asl.Value.Integer = BufferLength;
(void) OpcSetOptimalIntegerSize (BufferLengthOp);
/* Remaining nodes are handled via the tree walk */
}
ACPI_STATUS
OpcAmlConstantWalk (
ACPI_PARSE_OBJECT *Op,
UINT32 Level,
void *Context)
{
ACPI_WALK_STATE *WalkState;
ACPI_STATUS Status = AE_OK;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_PARSE_OBJECT *RootOp;
ACPI_PARSE_OBJECT *OriginalParentOp;
UINT8 WalkType;
/*
* Only interested in subtrees that could possibly contain
* expressions that can be evaluated at this time
*/
if ((!(Op->Asl.CompileFlags & NODE_COMPILE_TIME_CONST)) ||
(Op->Asl.CompileFlags & NODE_IS_TARGET))
{
return (AE_OK);
}
/* Set the walk type based on the reduction used for this op */
if (Op->Asl.CompileFlags & NODE_IS_TERM_ARG)
{
/* Op is a TermArg, constant folding is merely optional */
if (!Gbl_FoldConstants)
{
return (AE_CTRL_DEPTH);
}
WalkType = ACPI_WALK_CONST_OPTIONAL;
}
else
{
/* Op is a DataObject, the expression MUST reduced to a constant */
WalkType = ACPI_WALK_CONST_REQUIRED;
}
/* Create a new walk state */
WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
if (!WalkState)
{
return AE_NO_MEMORY;
}
WalkState->NextOp = NULL;
WalkState->Params = NULL;
WalkState->WalkType = WalkType;
WalkState->CallerReturnDesc = &ObjDesc;
/*
* Examine the entire subtree -- all nodes must be constants
* or type 3/4/5 opcodes
*/
Status = TrWalkParseTree (Op, ASL_WALK_VISIT_DOWNWARD,
OpcAmlCheckForConstant, NULL, WalkState);
/*
* Did we find an entire subtree that contains all constants and type 3/4/5
* opcodes? (Only AE_OK or AE_TYPE returned from above)
*/
if (Status == AE_TYPE)
{
/* Subtree cannot be reduced to a constant */
if (WalkState->WalkType == ACPI_WALK_CONST_OPTIONAL)
{
AcpiDsDeleteWalkState (WalkState);
return (AE_OK);
}
/* Don't descend any further, and use a default "constant" value */
Status = AE_CTRL_DEPTH;
}
else
{
/* Subtree can be reduced */
/* Allocate a new temporary root for this subtree */
RootOp = TrAllocateNode (PARSEOP_INTEGER);
if (!RootOp)
{
return (AE_NO_MEMORY);
}
RootOp->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
OriginalParentOp = Op->Common.Parent;
Op->Common.Parent = RootOp;
/* Hand off the subtree to the AML interpreter */
Status = TrWalkParseTree (Op, ASL_WALK_VISIT_TWICE,
OpcAmlEvaluationWalk1, OpcAmlEvaluationWalk2, WalkState);
Op->Common.Parent = OriginalParentOp;
/* TBD: we really *should* release the RootOp node */
if (ACPI_SUCCESS (Status))
{
TotalFolds++;
/* Get the final result */
Status = AcpiDsResultPop (&ObjDesc, WalkState);
}
/* Check for error from the ACPICA core */
if (ACPI_FAILURE (Status))
{
AslCoreSubsystemError (Op, Status,
"Failure during constant evaluation", FALSE);
}
}
if (ACPI_FAILURE (Status))
{
/* We could not resolve the subtree for some reason */
AslError (ASL_ERROR, ASL_MSG_CONSTANT_EVALUATION, Op,
Op->Asl.ParseOpName);
/* Set the subtree value to ZERO anyway. Eliminates further errors */
OpcUpdateIntegerNode (Op, 0);
}
else
{
AslError (ASL_OPTIMIZATION, ASL_MSG_CONSTANT_FOLDED, Op,
Op->Asl.ParseOpName);
/*
* Because we know we executed type 3/4/5 opcodes above, we know that
* the result must be either an Integer, String, or Buffer.
*/
switch (ObjDesc->Common.Type)
{
case ACPI_TYPE_INTEGER:
OpcUpdateIntegerNode (Op, ObjDesc->Integer.Value);
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (%s) %8.8X%8.8X\n",
Op->Asl.ParseOpName,
ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
break;
case ACPI_TYPE_STRING:
Op->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
Op->Common.AmlOpcode = AML_STRING_OP;
Op->Asl.AmlLength = ACPI_STRLEN (ObjDesc->String.Pointer) + 1;
Op->Common.Value.String = ObjDesc->String.Pointer;
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (STRING) %s\n",
Op->Common.Value.String);
break;
case ACPI_TYPE_BUFFER:
Op->Asl.ParseOpcode = PARSEOP_BUFFER;
Op->Common.AmlOpcode = AML_BUFFER_OP;
Op->Asl.CompileFlags = NODE_AML_PACKAGE;
UtSetParseOpName (Op);
/* Child node is the buffer length */
RootOp = TrAllocateNode (PARSEOP_INTEGER);
RootOp->Asl.AmlOpcode = AML_DWORD_OP;
RootOp->Asl.Value.Integer = ObjDesc->Buffer.Length;
RootOp->Asl.Parent = Op;
(void) OpcSetOptimalIntegerSize (RootOp);
Op->Asl.Child = RootOp;
Op = RootOp;
UtSetParseOpName (Op);
/* Peer to the child is the raw buffer data */
RootOp = TrAllocateNode (PARSEOP_RAW_DATA);
RootOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
RootOp->Asl.AmlLength = ObjDesc->Buffer.Length;
RootOp->Asl.Value.String = (char *) ObjDesc->Buffer.Pointer;
RootOp->Asl.Parent = Op->Asl.Parent;
Op->Asl.Next = RootOp;
Op = RootOp;
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (BUFFER) length %X\n",
ObjDesc->Buffer.Length);
break;
default:
printf ("Unsupported return type: %s\n",
AcpiUtGetObjectTypeName (ObjDesc));
break;
}
}
UtSetParseOpName (Op);
Op->Asl.Child = NULL;
AcpiDsDeleteWalkState (WalkState);
return (AE_CTRL_DEPTH);
}
void
OpcGenerateAmlOpcode (
ACPI_PARSE_OBJECT *Op)
{
UINT16 Index;
Index = (UINT16) (Op->Asl.ParseOpcode - ASL_PARSE_OPCODE_BASE);
Op->Asl.AmlOpcode = AslKeywordMapping[Index].AmlOpcode;
Op->Asl.AcpiBtype = AslKeywordMapping[Index].AcpiBtype;
Op->Asl.CompileFlags |= AslKeywordMapping[Index].Flags;
if (!Op->Asl.Value.Integer)
{
Op->Asl.Value.Integer = AslKeywordMapping[Index].Value;
}
/* Special handling for some opcodes */
switch (Op->Asl.ParseOpcode)
{
case PARSEOP_INTEGER:
/*
* Set the opcode based on the size of the integer
*/
(void) OpcSetOptimalIntegerSize (Op);
break;
case PARSEOP_OFFSET:
Op->Asl.AmlOpcodeLength = 1;
break;
case PARSEOP_ACCESSAS:
OpcDoAccessAs (Op);
break;
case PARSEOP_CONNECTION:
OpcDoConnection (Op);
break;
case PARSEOP_EISAID:
OpcDoEisaId (Op);
break;
case PARSEOP_TOUUID:
OpcDoUuId (Op);
break;
case PARSEOP_UNICODE:
OpcDoUnicode (Op);
break;
case PARSEOP_INCLUDE:
Op->Asl.Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
Gbl_HasIncludeFiles = TRUE;
break;
case PARSEOP_EXTERNAL:
Op->Asl.Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
Op->Asl.Child->Asl.Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
break;
case PARSEOP_TIMER:
if (AcpiGbl_IntegerBitWidth == 32)
{
AslError (ASL_REMARK, ASL_MSG_TRUNCATION, Op, NULL);
}
break;
default:
/* Nothing to do for other opcodes */
break;
}
return;
}
static void
OpcDoEisaId (
ACPI_PARSE_OBJECT *Op)
{
UINT32 EisaId = 0;
UINT32 BigEndianId;
char *InString;
ACPI_STATUS Status = AE_OK;
UINT32 i;
InString = (char *) Op->Asl.Value.String;
/*
* The EISAID string must be exactly 7 characters and of the form
* "UUUXXXX" -- 3 uppercase letters and 4 hex digits (e.g., "PNP0001")
*/
if (ACPI_STRLEN (InString) != 7)
{
Status = AE_BAD_PARAMETER;
}
else
{
/* Check all 7 characters for correct format */
for (i = 0; i < 7; i++)
{
/* First 3 characters must be uppercase letters */
if (i < 3)
{
if (!isupper ((int) InString[i]))
{
Status = AE_BAD_PARAMETER;
}
}
/* Last 4 characters must be hex digits */
else if (!isxdigit ((int) InString[i]))
{
Status = AE_BAD_PARAMETER;
}
}
}
if (ACPI_FAILURE (Status))
{
AslError (ASL_ERROR, ASL_MSG_INVALID_EISAID, Op, Op->Asl.Value.String);
}
else
{
/* Create ID big-endian first (bits are contiguous) */
BigEndianId =
(UINT32) ((UINT8) (InString[0] - 0x40)) << 26 |
(UINT32) ((UINT8) (InString[1] - 0x40)) << 21 |
(UINT32) ((UINT8) (InString[2] - 0x40)) << 16 |
(AcpiUtAsciiCharToHex (InString[3])) << 12 |
(AcpiUtAsciiCharToHex (InString[4])) << 8 |
(AcpiUtAsciiCharToHex (InString[5])) << 4 |
AcpiUtAsciiCharToHex (InString[6]);
/* Swap to little-endian to get final ID (see function header) */
EisaId = AcpiUtDwordByteSwap (BigEndianId);
}
/*
* Morph the Op into an integer, regardless of whether there
* was an error in the EISAID string
*/
Op->Asl.Value.Integer = EisaId;
Op->Asl.CompileFlags &= ~NODE_COMPILE_TIME_CONST;
Op->Asl.ParseOpcode = PARSEOP_INTEGER;
(void) OpcSetOptimalIntegerSize (Op);
/* Op is now an integer */
UtSetParseOpName (Op);
}
void
RsDoResourceTemplate (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *BufferLengthOp;
ACPI_PARSE_OBJECT *BufferOp;
ACPI_PARSE_OBJECT *DescriptorTypeOp;
ACPI_PARSE_OBJECT *LastOp = NULL;
ASL_RESOURCE_DESC *Descriptor;
UINT32 CurrentByteOffset = 0;
ASL_RESOURCE_NODE HeadRnode;
ASL_RESOURCE_NODE *PreviousRnode;
ASL_RESOURCE_NODE *Rnode;
UINT8 State;
/* ResourceTemplate Opcode is first (Op) */
/* Buffer Length node is first child */
BufferLengthOp = ASL_GET_CHILD_NODE (Op);
/* Buffer Op is first peer */
BufferOp = ASL_GET_PEER_NODE (BufferLengthOp);
/* First Descriptor type is next */
DescriptorTypeOp = ASL_GET_PEER_NODE (BufferOp);
/* Process all resource descriptors in the list */
State = ACPI_RSTATE_NORMAL;
PreviousRnode = &HeadRnode;
while (DescriptorTypeOp)
{
Rnode = RsDoOneResourceDescriptor (DescriptorTypeOp, CurrentByteOffset, &State);
/*
* Update current byte offset to indicate the number of bytes from the
* start of the buffer. Buffer can include multiple descriptors, we
* must keep track of the offset of not only each descriptor, but each
* element (field) within each descriptor as well.
*/
CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, Rnode);
/* Get the next descriptor in the list */
LastOp = DescriptorTypeOp;
DescriptorTypeOp = ASL_GET_PEER_NODE (DescriptorTypeOp);
}
if (State == ACPI_RSTATE_DEPENDENT_LIST)
{
if (LastOp)
{
LastOp = LastOp->Asl.Parent;
}
AslError (ASL_ERROR, ASL_MSG_MISSING_ENDDEPENDENT, LastOp, NULL);
}
/*
* Insert the EndTag descriptor after all other descriptors have been processed
*/
Rnode = RsAllocateResourceNode (sizeof (ASL_END_TAG_DESC));
Descriptor = Rnode->Buffer;
Descriptor->Et.DescriptorType = ACPI_RDESC_TYPE_END_TAG |
ASL_RDESC_END_TAG_SIZE;
Descriptor->Et.Checksum = 0;
CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, Rnode);
/*
* Transform the nodes into the following
*
* Op -> AML_BUFFER_OP
* First Child -> BufferLength
* Second Child -> Descriptor Buffer (raw byte data)
*/
Op->Asl.ParseOpcode = PARSEOP_BUFFER;
Op->Asl.AmlOpcode = AML_BUFFER_OP;
Op->Asl.CompileFlags = NODE_AML_PACKAGE;
BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
BufferLengthOp->Asl.Value.Integer = CurrentByteOffset;
(void) OpcSetOptimalIntegerSize (BufferLengthOp);
BufferOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
BufferOp->Asl.AmlOpcode = AML_RAW_DATA_CHAIN;
BufferOp->Asl.AmlOpcodeLength = 0;
BufferOp->Asl.AmlLength = CurrentByteOffset;
BufferOp->Asl.Value.Buffer = (UINT8 *) HeadRnode.Next;
return;
}
static void
TrInstallReducedConstant (
ACPI_PARSE_OBJECT *Op,
ACPI_OPERAND_OBJECT *ObjDesc)
{
ACPI_PARSE_OBJECT *LengthOp;
ACPI_PARSE_OBJECT *DataOp;
TotalFolds++;
AslError (ASL_OPTIMIZATION, ASL_MSG_CONSTANT_FOLDED, Op,
Op->Asl.ParseOpName);
/*
* Because we know we executed type 3/4/5 opcodes above, we know that
* the result must be either an Integer, String, or Buffer.
*/
switch (ObjDesc->Common.Type)
{
case ACPI_TYPE_INTEGER:
OpcUpdateIntegerNode (Op, ObjDesc->Integer.Value);
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (%s) %8.8X%8.8X\n\n",
Op->Asl.ParseOpName,
ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
break;
case ACPI_TYPE_STRING:
Op->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
Op->Common.AmlOpcode = AML_STRING_OP;
Op->Asl.AmlLength = strlen (ObjDesc->String.Pointer) + 1;
Op->Common.Value.String = ObjDesc->String.Pointer;
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (STRING) %s\n\n",
Op->Common.Value.String);
break;
case ACPI_TYPE_BUFFER:
/*
* Create a new parse subtree of the form:
*
* BUFFER (Buffer AML opcode)
* INTEGER (Buffer length in bytes)
* RAW_DATA (Buffer byte data)
*/
Op->Asl.ParseOpcode = PARSEOP_BUFFER;
Op->Common.AmlOpcode = AML_BUFFER_OP;
Op->Asl.CompileFlags = NODE_AML_PACKAGE;
UtSetParseOpName (Op);
/* Child node is the buffer length */
LengthOp = TrAllocateNode (PARSEOP_INTEGER);
LengthOp->Asl.AmlOpcode = AML_DWORD_OP;
LengthOp->Asl.Value.Integer = ObjDesc->Buffer.Length;
LengthOp->Asl.Parent = Op;
(void) OpcSetOptimalIntegerSize (LengthOp);
Op->Asl.Child = LengthOp;
/* Next child is the raw buffer data */
DataOp = TrAllocateNode (PARSEOP_RAW_DATA);
DataOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
DataOp->Asl.AmlLength = ObjDesc->Buffer.Length;
DataOp->Asl.Value.String = (char *) ObjDesc->Buffer.Pointer;
DataOp->Asl.Parent = Op;
LengthOp->Asl.Next = DataOp;
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (BUFFER) length %X\n\n",
ObjDesc->Buffer.Length);
break;
default:
break;
}
}
UINT32
OpcSetOptimalIntegerSize (
ACPI_PARSE_OBJECT *Op)
{
#if 0
/*
* TBD: - we don't want to optimize integers in the block header, but the
* code below does not work correctly.
*/
if (Op->Asl.Parent &&
Op->Asl.Parent->Asl.Parent &&
(Op->Asl.Parent->Asl.Parent->Asl.ParseOpcode == PARSEOP_DEFINITION_BLOCK))
{
return (0);
}
#endif
/*
* Check for the special AML integers first - Zero, One, Ones.
* These are single-byte opcodes that are the smallest possible
* representation of an integer.
*
* This optimization is optional.
*/
if (Gbl_IntegerOptimizationFlag)
{
switch (Op->Asl.Value.Integer)
{
case 0:
Op->Asl.AmlOpcode = AML_ZERO_OP;
AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
Op, "Zero");
return (1);
case 1:
Op->Asl.AmlOpcode = AML_ONE_OP;
AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
Op, "One");
return (1);
case ACPI_UINT32_MAX:
/* Check for table integer width (32 or 64) */
if (AcpiGbl_IntegerByteWidth == 4)
{
Op->Asl.AmlOpcode = AML_ONES_OP;
AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
Op, "Ones");
return (1);
}
break;
case ACPI_UINT64_MAX:
/* Check for table integer width (32 or 64) */
if (AcpiGbl_IntegerByteWidth == 8)
{
Op->Asl.AmlOpcode = AML_ONES_OP;
AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
Op, "Ones");
return (1);
}
break;
default:
break;
}
}
/* Find the best fit using the various AML integer prefixes */
if (Op->Asl.Value.Integer <= ACPI_UINT8_MAX)
{
Op->Asl.AmlOpcode = AML_BYTE_OP;
return (1);
}
if (Op->Asl.Value.Integer <= ACPI_UINT16_MAX)
{
Op->Asl.AmlOpcode = AML_WORD_OP;
return (2);
}
if (Op->Asl.Value.Integer <= ACPI_UINT32_MAX)
{
Op->Asl.AmlOpcode = AML_DWORD_OP;
return (4);
}
else /* 64-bit integer */
{
if (AcpiGbl_IntegerByteWidth == 4)
{
AslError (ASL_WARNING, ASL_MSG_INTEGER_LENGTH,
Op, NULL);
if (!Gbl_IgnoreErrors)
{
/* Truncate the integer to 32-bit */
Op->Asl.Value.Integer &= ACPI_UINT32_MAX;
/* Now set the optimal integer size */
return (OpcSetOptimalIntegerSize (Op));
}
}
Op->Asl.AmlOpcode = AML_QWORD_OP;
return (8);
}
}
void
OpcGenerateAmlOpcode (
ACPI_PARSE_OBJECT *Op)
{
UINT16 Index;
Index = (UINT16) (Op->Asl.ParseOpcode - ASL_PARSE_OPCODE_BASE);
Op->Asl.AmlOpcode = AslKeywordMapping[Index].AmlOpcode;
Op->Asl.AcpiBtype = AslKeywordMapping[Index].AcpiBtype;
Op->Asl.CompileFlags |= AslKeywordMapping[Index].Flags;
if (!Op->Asl.Value.Integer)
{
Op->Asl.Value.Integer = AslKeywordMapping[Index].Value;
}
/* Special handling for some opcodes */
switch (Op->Asl.ParseOpcode)
{
case PARSEOP_INTEGER:
/*
* Set the opcode based on the size of the integer
*/
(void) OpcSetOptimalIntegerSize (Op);
break;
case PARSEOP_OFFSET:
Op->Asl.AmlOpcodeLength = 1;
break;
case PARSEOP_ACCESSAS:
OpcDoAccessAs (Op);
break;
case PARSEOP_EISAID:
OpcDoEisaId (Op);
break;
case PARSEOP_UNICODE:
OpcDoUnicode (Op);
break;
case PARSEOP_INCLUDE:
Op->Asl.Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
Gbl_HasIncludeFiles = TRUE;
break;
case PARSEOP_EXTERNAL:
Op->Asl.Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
Op->Asl.Child->Asl.Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
break;
case PARSEOP_PACKAGE:
/*
* The variable-length package has a different opcode
*/
if ((Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
(Op->Asl.Child->Asl.ParseOpcode != PARSEOP_INTEGER) &&
(Op->Asl.Child->Asl.ParseOpcode != PARSEOP_BYTECONST))
{
Op->Asl.AmlOpcode = AML_VAR_PACKAGE_OP;
}
break;
default:
/* Nothing to do for other opcodes */
break;
}
return;
}