summaryrefslogtreecommitdiffstats
path: root/sys/contrib/dev/acpica/compiler
diff options
context:
space:
mode:
authorjkim <jkim@FreeBSD.org>2011-11-28 23:36:48 +0000
committerjkim <jkim@FreeBSD.org>2011-11-28 23:36:48 +0000
commit1bdf3ee8a88f36389b6ebd626dc91b14c9674b9d (patch)
tree9ddf54564f2132efa4b2bc210ee8f94df85b4d86 /sys/contrib/dev/acpica/compiler
parent7cc588c10b92dcba82aa8dd93162b1a9d4e5f342 (diff)
parent371a323d3dee8126616c1fdb31a8319c8718310f (diff)
downloadFreeBSD-src-1bdf3ee8a88f36389b6ebd626dc91b14c9674b9d.zip
FreeBSD-src-1bdf3ee8a88f36389b6ebd626dc91b14c9674b9d.tar.gz
Merge ACPICA 20111123.
Diffstat (limited to 'sys/contrib/dev/acpica/compiler')
-rw-r--r--sys/contrib/dev/acpica/compiler/aslanalyze.c57
-rw-r--r--sys/contrib/dev/acpica/compiler/aslcodegen.c9
-rw-r--r--sys/contrib/dev/acpica/compiler/aslcompile.c2
-rw-r--r--sys/contrib/dev/acpica/compiler/aslcompiler.h47
-rw-r--r--sys/contrib/dev/acpica/compiler/aslcompiler.l459
-rw-r--r--sys/contrib/dev/acpica/compiler/aslcompiler.y911
-rw-r--r--sys/contrib/dev/acpica/compiler/asldefine.h22
-rw-r--r--sys/contrib/dev/acpica/compiler/aslerror.c21
-rw-r--r--sys/contrib/dev/acpica/compiler/aslfiles.c6
-rw-r--r--sys/contrib/dev/acpica/compiler/aslglobal.h1
-rw-r--r--sys/contrib/dev/acpica/compiler/asllisting.c10
-rw-r--r--sys/contrib/dev/acpica/compiler/aslload.c20
-rw-r--r--sys/contrib/dev/acpica/compiler/asllookup.c111
-rw-r--r--sys/contrib/dev/acpica/compiler/aslmain.c121
-rw-r--r--sys/contrib/dev/acpica/compiler/aslmap.c77
-rw-r--r--sys/contrib/dev/acpica/compiler/aslmessages.h163
-rw-r--r--sys/contrib/dev/acpica/compiler/aslopcodes.c131
-rw-r--r--sys/contrib/dev/acpica/compiler/asloperands.c8
-rw-r--r--sys/contrib/dev/acpica/compiler/aslpredef.c21
-rw-r--r--sys/contrib/dev/acpica/compiler/aslresource.c101
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype1.c20
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype1i.c94
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype2.c5
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype2d.c42
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype2e.c48
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype2q.c40
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype2s.c1187
-rw-r--r--sys/contrib/dev/acpica/compiler/aslrestype2w.c34
-rw-r--r--sys/contrib/dev/acpica/compiler/aslstubs.c17
-rw-r--r--sys/contrib/dev/acpica/compiler/asltransform.c17
-rw-r--r--sys/contrib/dev/acpica/compiler/asltree.c20
-rw-r--r--sys/contrib/dev/acpica/compiler/asltypes.h8
-rw-r--r--sys/contrib/dev/acpica/compiler/aslutils.c63
-rw-r--r--sys/contrib/dev/acpica/compiler/aslwalks.c73
-rw-r--r--sys/contrib/dev/acpica/compiler/dtcompile.c28
-rw-r--r--sys/contrib/dev/acpica/compiler/dtcompiler.h22
-rw-r--r--sys/contrib/dev/acpica/compiler/dtfield.c13
-rw-r--r--sys/contrib/dev/acpica/compiler/dtsubtable.c5
-rw-r--r--sys/contrib/dev/acpica/compiler/dttable.c447
-rw-r--r--sys/contrib/dev/acpica/compiler/dttemplate.h116
-rw-r--r--sys/contrib/dev/acpica/compiler/dtutils.c11
41 files changed, 3828 insertions, 780 deletions
diff --git a/sys/contrib/dev/acpica/compiler/aslanalyze.c b/sys/contrib/dev/acpica/compiler/aslanalyze.c
index 07f84c8..d7224e6 100644
--- a/sys/contrib/dev/acpica/compiler/aslanalyze.c
+++ b/sys/contrib/dev/acpica/compiler/aslanalyze.c
@@ -126,7 +126,6 @@ AnCheckId (
{
UINT32 i;
ACPI_SIZE Length;
- UINT32 AlphaPrefixLength;
/* Only care about string versions of _HID/_CID (integers are legal) */
@@ -174,12 +173,18 @@ AnCheckId (
{
AslError (ASL_ERROR, ASL_MSG_ALPHANUMERIC_STRING,
Op, Op->Asl.Value.String);
- break;
+ return;
}
}
- /* _HID String must be of the form "XXX####" or "ACPI####" */
-
+ /*
+ * _HID String must be one of these forms:
+ *
+ * "AAA####" A is an uppercase letter and # is a hex digit
+ * "ACPI####" # is a hex digit
+ * "NNNN####" N is an uppercase letter or decimal digit (0-9)
+ * # is a hex digit (ACPI 5.0)
+ */
if ((Length < 7) || (Length > 8))
{
AslError (ASL_ERROR, ASL_MSG_HID_LENGTH,
@@ -187,22 +192,48 @@ AnCheckId (
return;
}
- /* _HID Length is valid, now check for uppercase (first 3 or 4 chars) */
+ /* _HID Length is valid (7 or 8), now check the prefix (first 3 or 4 chars) */
- AlphaPrefixLength = 3;
- if (Length >= 8)
+ if (Length == 7)
{
- AlphaPrefixLength = 4;
+ /* AAA####: Ensure the alphabetic prefix is all uppercase */
+
+ for (i = 0; i < 3; i++)
+ {
+ if (!isupper ((int) Op->Asl.Value.String[i]))
+ {
+ AslError (ASL_ERROR, ASL_MSG_UPPER_CASE,
+ Op, &Op->Asl.Value.String[i]);
+ return;
+ }
+ }
+ }
+ else /* Length == 8 */
+ {
+ /*
+ * ACPI#### or NNNN####:
+ * Ensure the prefix contains only uppercase alpha or decimal digits
+ */
+ for (i = 0; i < 4; i++)
+ {
+ if (!isupper ((int) Op->Asl.Value.String[i]) &&
+ !isdigit ((int) Op->Asl.Value.String[i]))
+ {
+ AslError (ASL_ERROR, ASL_MSG_HID_PREFIX,
+ Op, &Op->Asl.Value.String[i]);
+ return;
+ }
+ }
}
- /* Ensure the alphabetic prefix is all uppercase */
+ /* Remaining characters (suffix) must be hex digits */
- for (i = 0; (i < AlphaPrefixLength) && Op->Asl.Value.String[i]; i++)
+ for (; i < Length; i++)
{
- if (!isupper ((int) Op->Asl.Value.String[i]))
+ if (!isxdigit ((int) Op->Asl.Value.String[i]))
{
- AslError (ASL_ERROR, ASL_MSG_UPPER_CASE,
- Op, &Op->Asl.Value.String[i]);
+ AslError (ASL_ERROR, ASL_MSG_HID_SUFFIX,
+ Op, &Op->Asl.Value.String[i]);
break;
}
}
diff --git a/sys/contrib/dev/acpica/compiler/aslcodegen.c b/sys/contrib/dev/acpica/compiler/aslcodegen.c
index 35d2082..915c356 100644
--- a/sys/contrib/dev/acpica/compiler/aslcodegen.c
+++ b/sys/contrib/dev/acpica/compiler/aslcodegen.c
@@ -271,12 +271,17 @@ CgWriteAmlOpcode (
/* Special opcodes for within a field definition */
- Aml.Opcode = 0x00;
+ Aml.Opcode = AML_FIELD_OFFSET_OP;
break;
case AML_INT_ACCESSFIELD_OP:
- Aml.Opcode = 0x01;
+ Aml.Opcode = AML_FIELD_ACCESS_OP;
+ break;
+
+ case AML_INT_CONNECTION_OP:
+
+ Aml.Opcode = AML_FIELD_CONNECTION_OP;
break;
default:
diff --git a/sys/contrib/dev/acpica/compiler/aslcompile.c b/sys/contrib/dev/acpica/compiler/aslcompile.c
index 0981cd6..31e764c 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompile.c
+++ b/sys/contrib/dev/acpica/compiler/aslcompile.c
@@ -472,6 +472,8 @@ CmDoCompile (
if (!RootNode)
{
+ AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
+ NULL, "- Could not resolve parse tree root node");
CmCleanupAndExit ();
return -1;
}
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.h b/sys/contrib/dev/acpica/compiler/aslcompiler.h
index 0588c96..d0fb0af 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.h
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.h
@@ -289,7 +289,7 @@ AslCoreSubsystemError (
int
AslCompilererror(
- char *s);
+ const char *s);
void
AslCommonError (
@@ -829,21 +829,23 @@ RsAllocateResourceNode (
UINT32 Size);
void
-RsCreateBitField (
+RsCreateResourceField (
ACPI_PARSE_OBJECT *Op,
char *Name,
UINT32 ByteOffset,
- UINT32 BitOffset);
+ UINT32 BitOffset,
+ UINT32 BitLength);
void
-RsCreateByteField (
+RsSetFlagBits (
+ UINT8 *Flags,
ACPI_PARSE_OBJECT *Op,
- char *Name,
- UINT32 ByteOffset);
+ UINT8 Position,
+ UINT8 DefaultBit);
void
-RsSetFlagBits (
- UINT8 *Flags,
+RsSetFlagBits16 (
+ UINT16 *Flags,
ACPI_PARSE_OBJECT *Op,
UINT8 Position,
UINT8 DefaultBit);
@@ -931,6 +933,11 @@ RsDoDmaDescriptor (
UINT32 CurrentByteOffset);
ASL_RESOURCE_NODE *
+RsDoFixedDmaDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset);
+
+ASL_RESOURCE_NODE *
RsDoFixedIoDescriptor (
ACPI_PARSE_OBJECT *Op,
UINT32 CurrentByteOffset);
@@ -969,6 +976,30 @@ RsDoGeneralRegisterDescriptor (
ACPI_PARSE_OBJECT *Op,
UINT32 CurrentByteOffset);
+ASL_RESOURCE_NODE *
+RsDoGpioIntDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset);
+
+ASL_RESOURCE_NODE *
+RsDoGpioIoDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset);
+
+ASL_RESOURCE_NODE *
+RsDoI2cSerialBusDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset);
+
+ASL_RESOURCE_NODE *
+RsDoSpiSerialBusDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset);
+
+ASL_RESOURCE_NODE *
+RsDoUartSerialBusDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset);
/*
* aslrestype2d - DWord address descriptors
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.l b/sys/contrib/dev/acpica/compiler/aslcompiler.l
index bb41537..390826d 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.l
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.l
@@ -1,8 +1,7 @@
-
%{
/******************************************************************************
*
- * Module Name: aslcompiler.l - Flex input file
+ * Module Name: aslcompiler.l - Flex/lex input file
*
*****************************************************************************/
@@ -60,6 +59,9 @@ YYSTYPE AslCompilerlval;
#define _COMPONENT ACPI_COMPILER
ACPI_MODULE_NAME ("aslscan")
+
+/* Local prototypes */
+
char
comment (void);
char
@@ -74,7 +76,7 @@ copy (void);
/*! [Begin] no source code translation */
%}
-
+ /* Definitions */
LeadNameChar [A-Za-z_]
DigitChar [0-9]
@@ -94,6 +96,7 @@ NonEmptyNamePath {NameSeg}{NamePathTail}*
NamePathTail [.]{NameSeg}
%%
+ /* Rules */
[ ] { count (0); }
[\n] { count (0); } /* Handle files with both LF and CR/LF */
@@ -105,6 +108,7 @@ NamePathTail [.]{NameSeg}
"//" { if (!comment2 ()) yyterminate (); }
"\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
+";" { count (0); return(';'); }
0[xX]{HexDigitChar}+ |
@@ -116,73 +120,56 @@ NamePathTail [.]{NameSeg}
"#line" { count (1); return (PARSEOP_LINE_CSTYLE); }
"External" { count (1); return (PARSEOP_EXTERNAL); }
+ /****************************************************************************
+ *
+ * Main ASL operators
+ *
+ ****************************************************************************/
-"Ones" { count (1); return (PARSEOP_ONES); }
-"One" { count (1); return (PARSEOP_ONE); }
-"Zero" { count (1); return (PARSEOP_ZERO); }
-"Revision" { count (1); return (PARSEOP_REVISION); }
-
-"Offset" { count (1); return (PARSEOP_OFFSET); }
"AccessAs" { count (1); return (PARSEOP_ACCESSAS); }
-"BankField" { count (2); return (PARSEOP_BANKFIELD); }
-"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); }
-"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); }
-"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); }
-"CreateField" { count (2); return (PARSEOP_CREATEFIELD); }
-"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); }
-"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); }
-"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); }
-"Device" { count (2); return (PARSEOP_DEVICE); }
-"Event" { count (2); return (PARSEOP_EVENT); }
-"Field" { count (2); return (PARSEOP_FIELD); }
-"Function" { count (2); return (PARSEOP_FUNCTION); }
-"IndexField" { count (2); return (PARSEOP_INDEXFIELD); }
-"Method" { count (2); return (PARSEOP_METHOD); }
-"Mutex" { count (2); return (PARSEOP_MUTEX); }
-"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); }
-"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); }
-"Processor" { count (2); return (PARSEOP_PROCESSOR); }
-"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); }
+"Acquire" { count (3); return (PARSEOP_ACQUIRE); }
+"Add" { count (3); return (PARSEOP_ADD); }
"Alias" { count (2); return (PARSEOP_ALIAS); }
-"Name" { count (2); return (PARSEOP_NAME); }
-"Scope" { count (2); return (PARSEOP_SCOPE); }
+"And" { count (3); return (PARSEOP_AND); }
+"BankField" { count (2); return (PARSEOP_BANKFIELD); }
"Break" { count (3); return (PARSEOP_BREAK); }
"BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); }
-"Continue" { count (3); return (PARSEOP_CONTINUE); }
-"Fatal" { count (3); return (PARSEOP_FATAL); }
-"If" { count (3); return (PARSEOP_IF); }
-"Else" { count (3); return (PARSEOP_ELSE); }
-"ElseIf" { count (3); return (PARSEOP_ELSEIF); }
-"Load" { count (3); return (PARSEOP_LOAD); }
-"Noop" { count (3); return (PARSEOP_NOOP); }
-"Notify" { count (3); return (PARSEOP_NOTIFY); }
-"Release" { count (3); return (PARSEOP_RELEASE); }
-"Reset" { count (3); return (PARSEOP_RESET); }
-"Return" { count (3); return (PARSEOP_RETURN); }
-"Signal" { count (3); return (PARSEOP_SIGNAL); }
-"Sleep" { count (3); return (PARSEOP_SLEEP); }
-"Stall" { count (3); return (PARSEOP_STALL); }
-"Switch" { count (3); return (PARSEOP_SWITCH); }
+"Buffer" { count (1); return (PARSEOP_BUFFER); }
"Case" { count (3); return (PARSEOP_CASE); }
-"Default" { count (3); return (PARSEOP_DEFAULT); }
-"Unload" { count (3); return (PARSEOP_UNLOAD); }
-"While" { count (3); return (PARSEOP_WHILE); }
-
-"Acquire" { count (3); return (PARSEOP_ACQUIRE); }
-"Add" { count (3); return (PARSEOP_ADD); }
-"And" { count (3); return (PARSEOP_AND); }
"Concatenate" { count (3); return (PARSEOP_CONCATENATE); }
"ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); }
"CondRefOf" { count (3); return (PARSEOP_CONDREFOF); }
+"Connection" { count (2); return (PARSEOP_CONNECTION); }
+"Continue" { count (3); return (PARSEOP_CONTINUE); }
"CopyObject" { count (3); return (PARSEOP_COPYOBJECT); }
+"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); }
+"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); }
+"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); }
+"CreateField" { count (2); return (PARSEOP_CREATEFIELD); }
+"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); }
+"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); }
+"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); }
+"Debug" { count (1); return (PARSEOP_DEBUG); }
"Decrement" { count (3); return (PARSEOP_DECREMENT); }
+"Default" { count (3); return (PARSEOP_DEFAULT); }
+"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); }
"DeRefOf" { count (3); return (PARSEOP_DEREFOF); }
+"Device" { count (2); return (PARSEOP_DEVICE); }
"Divide" { count (3); return (PARSEOP_DIVIDE); }
+"Eisaid" { count (1); return (PARSEOP_EISAID); }
+"Else" { count (3); return (PARSEOP_ELSE); }
+"ElseIf" { count (3); return (PARSEOP_ELSEIF); }
+"Event" { count (2); return (PARSEOP_EVENT); }
+"Fatal" { count (3); return (PARSEOP_FATAL); }
+"Field" { count (2); return (PARSEOP_FIELD); }
"FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); }
"FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); }
-"FromBCD" { count (3); return (PARSEOP_FROMBCD); }
+"FromBcd" { count (3); return (PARSEOP_FROMBCD); }
+"Function" { count (2); return (PARSEOP_FUNCTION); }
+"If" { count (3); return (PARSEOP_IF); }
"Increment" { count (3); return (PARSEOP_INCREMENT); }
"Index" { count (3); return (PARSEOP_INDEX); }
+"IndexField" { count (2); return (PARSEOP_INDEXFIELD); }
"LAnd" { count (3); return (PARSEOP_LAND); }
"LEqual" { count (3); return (PARSEOP_LEQUAL); }
"LGreater" { count (3); return (PARSEOP_LGREATER); }
@@ -191,32 +178,62 @@ NamePathTail [.]{NameSeg}
"LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); }
"LNot" { count (3); return (PARSEOP_LNOT); }
"LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); }
+"Load" { count (3); return (PARSEOP_LOAD); }
"LoadTable" { count (3); return (PARSEOP_LOADTABLE); }
"LOr" { count (3); return (PARSEOP_LOR); }
"Match" { count (3); return (PARSEOP_MATCH); }
+"Method" { count (2); return (PARSEOP_METHOD); }
"Mid" { count (3); return (PARSEOP_MID); }
"Mod" { count (3); return (PARSEOP_MOD); }
"Multiply" { count (3); return (PARSEOP_MULTIPLY); }
+"Mutex" { count (2); return (PARSEOP_MUTEX); }
+"Name" { count (2); return (PARSEOP_NAME); }
"NAnd" { count (3); return (PARSEOP_NAND); }
+"Noop" { count (3); return (PARSEOP_NOOP); }
"NOr" { count (3); return (PARSEOP_NOR); }
"Not" { count (3); return (PARSEOP_NOT); }
+"Notify" { count (3); return (PARSEOP_NOTIFY); }
"ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); }
+"Offset" { count (1); return (PARSEOP_OFFSET); }
+"One" { count (1); return (PARSEOP_ONE); }
+"Ones" { count (1); return (PARSEOP_ONES); }
+"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); }
"Or" { count (3); return (PARSEOP_OR); }
+"Package" { count (1); return (PARSEOP_PACKAGE); }
+"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); }
+"Processor" { count (2); return (PARSEOP_PROCESSOR); }
"RefOf" { count (3); return (PARSEOP_REFOF); }
+"Release" { count (3); return (PARSEOP_RELEASE); }
+"Reset" { count (3); return (PARSEOP_RESET); }
+"Return" { count (3); return (PARSEOP_RETURN); }
+"Revision" { count (1); return (PARSEOP_REVISION); }
+"Scope" { count (2); return (PARSEOP_SCOPE); }
"ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); }
"ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); }
+"Signal" { count (3); return (PARSEOP_SIGNAL); }
"SizeOf" { count (3); return (PARSEOP_SIZEOF); }
+"Sleep" { count (3); return (PARSEOP_SLEEP); }
+"Stall" { count (3); return (PARSEOP_STALL); }
"Store" { count (3); return (PARSEOP_STORE); }
"Subtract" { count (3); return (PARSEOP_SUBTRACT); }
+"Switch" { count (3); return (PARSEOP_SWITCH); }
+"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); }
"Timer" { count (3); return (PARSEOP_TIMER); }
-"ToBCD" { count (3); return (PARSEOP_TOBCD); }
+"ToBcd" { count (3); return (PARSEOP_TOBCD); }
"ToBuffer" { count (3); return (PARSEOP_TOBUFFER); }
"ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); }
"ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); }
"ToInteger" { count (3); return (PARSEOP_TOINTEGER); }
"ToString" { count (3); return (PARSEOP_TOSTRING); }
+"ToUuid" { count (1); return (PARSEOP_TOUUID); }
+"Unicode" { count (1); return (PARSEOP_UNICODE); }
+"Unload" { count (3); return (PARSEOP_UNLOAD); }
"Wait" { count (3); return (PARSEOP_WAIT); }
+"While" { count (3); return (PARSEOP_WHILE); }
"XOr" { count (3); return (PARSEOP_XOR); }
+"Zero" { count (1); return (PARSEOP_ZERO); }
+
+ /* Control method arguments and locals */
"Arg0" { count (1); return (PARSEOP_ARG0); }
"Arg1" { count (1); return (PARSEOP_ARG1); }
@@ -225,7 +242,6 @@ NamePathTail [.]{NameSeg}
"Arg4" { count (1); return (PARSEOP_ARG4); }
"Arg5" { count (1); return (PARSEOP_ARG5); }
"Arg6" { count (1); return (PARSEOP_ARG6); }
-
"Local0" { count (1); return (PARSEOP_LOCAL0); }
"Local1" { count (1); return (PARSEOP_LOCAL1); }
"Local2" { count (1); return (PARSEOP_LOCAL2); }
@@ -235,16 +251,16 @@ NamePathTail [.]{NameSeg}
"Local6" { count (1); return (PARSEOP_LOCAL6); }
"Local7" { count (1); return (PARSEOP_LOCAL7); }
-"Debug" { count (1); return (PARSEOP_DEBUG); }
-"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); }
-"Buffer" { count (1); return (PARSEOP_BUFFER); }
-"Package" { count (1); return (PARSEOP_PACKAGE); }
+ /****************************************************************************
+ *
+ * Resource Descriptor macros
+ *
+ ****************************************************************************/
-"EISAID" { count (1); return (PARSEOP_EISAID); }
"ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); }
-"ToUUID" { count (1); return (PARSEOP_TOUUID); }
-"Unicode" { count (1); return (PARSEOP_UNICODE); }
+"RawDataBuffer" { count (1); return (PARSEOP_DATABUFFER); }
+
"DMA" { count (1); return (PARSEOP_DMA); }
"DWordIO" { count (1); return (PARSEOP_DWORDIO); }
"DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); }
@@ -253,26 +269,188 @@ NamePathTail [.]{NameSeg}
"ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); }
"ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); }
"ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); }
+"FixedDma" { count (1); return (PARSEOP_FIXEDDMA); }
"FixedIO" { count (1); return (PARSEOP_FIXEDIO); }
+"GpioInt" { count (1); return (PARSEOP_GPIO_INT); }
+"GpioIo" { count (1); return (PARSEOP_GPIO_IO); }
+"I2cSerialBus" { count (1); return (PARSEOP_I2C_SERIALBUS); }
"Interrupt" { count (1); return (PARSEOP_INTERRUPT); }
"IO" { count (1); return (PARSEOP_IO); }
-"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); }
"IRQ" { count (1); return (PARSEOP_IRQ); }
+"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); }
"Memory24" { count (1); return (PARSEOP_MEMORY24); }
-"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); }
"Memory32" { count (1); return (PARSEOP_MEMORY32); }
+"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); }
"QWordIO" { count (1); return (PARSEOP_QWORDIO); }
"QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); }
"QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); }
"Register" { count (1); return (PARSEOP_REGISTER); }
+"SpiSerialBus" { count (1); return (PARSEOP_SPI_SERIALBUS); }
"StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); }
"StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); }
+"UartSerialBus" { count (1); return (PARSEOP_UART_SERIALBUS); }
"VendorLong" { count (1); return (PARSEOP_VENDORLONG); }
"VendorShort" { count (1); return (PARSEOP_VENDORSHORT); }
"WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); }
"WordIO" { count (1); return (PARSEOP_WORDIO); }
"WordSpace" { count (1); return (PARSEOP_WORDSPACE); }
+
+ /****************************************************************************
+ *
+ * Keywords used as arguments to ASL operators and macros
+ *
+ ****************************************************************************/
+
+ /* AccessAttribKeyword: Serial Bus Attributes (ACPI 5.0) */
+
+"AttribQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
+"AttribSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
+"AttribByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
+"AttribWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
+"AttribBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
+"AttribProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
+"AttribBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
+
+ /* AccessAttribKeyword: Legacy synonyms for above (pre-ACPI 5.0) */
+
+"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
+"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
+"SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
+"SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
+"SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
+"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
+"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
+
+ /* AccessTypeKeyword: Field Access Types */
+
+"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
+"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
+"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
+"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
+"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
+"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
+
+ /* AddressingModeKeyword: Mode - Resource Descriptors (ACPI 5.0) */
+
+"AddressingMode7Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_7BIT); }
+"AddressingMode10Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_10BIT); }
+
+ /* AddressKeyword: ACPI memory range types */
+
+"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
+"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
+"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
+"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
+
+ /* BusMasterKeyword: DMA Bus Mastering */
+
+"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
+"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
+
+ /* ByteLengthKeyword: Bits per Byte - Resource Descriptors (ACPI 5.0) */
+
+"DataBitsFive" { count (0); return (PARSEOP_BITSPERBYTE_FIVE); }
+"DataBitsSix" { count (0); return (PARSEOP_BITSPERBYTE_SIX); }
+"DataBitsSeven" { count (0); return (PARSEOP_BITSPERBYTE_SEVEN); }
+"DataBitsEight" { count (0); return (PARSEOP_BITSPERBYTE_EIGHT); }
+"DataBitsNine" { count (0); return (PARSEOP_BITSPERBYTE_NINE); }
+
+ /* ClockPhaseKeyword: Resource Descriptors (ACPI 5.0) */
+
+"ClockPhaseFirst" { count (0); return (PARSEOP_CLOCKPHASE_FIRST); }
+"ClockPhaseSecond" { count (0); return (PARSEOP_CLOCKPHASE_SECOND); }
+
+ /* ClockPolarityKeyword: Resource Descriptors (ACPI 5.0) */
+
+"ClockPolarityLow" { count (0); return (PARSEOP_CLOCKPOLARITY_LOW); }
+"ClockPolarityHigh" { count (0); return (PARSEOP_CLOCKPOLARITY_HIGH); }
+
+ /* DecodeKeyword: Type of Memory Decoding - Resource Descriptors */
+
+"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); }
+"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); }
+
+ /* DmaTypeKeyword: DMA Types - DMA Resource Descriptor */
+
+"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
+"TypeA" { count (0); return (PARSEOP_DMATYPE_A); }
+"TypeB" { count (0); return (PARSEOP_DMATYPE_B); }
+"TypeF" { count (0); return (PARSEOP_DMATYPE_F); }
+
+ /* EndianKeyword: Endian type - Resource Descriptor (ACPI 5.0) */
+
+"LittleEndian" { count (0); return (PARSEOP_ENDIAN_LITTLE); }
+"BigEndian" { count (0); return (PARSEOP_ENDIAN_BIG); }
+
+ /* ExtendedAttribKeyword: Bus attributes, AccessAs operator (ACPI 5.0) */
+
+"AttribBytes" { count (0); return (PARSEOP_ACCESSATTRIB_MULTIBYTE); }
+"AttribRawBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_BYTES); }
+"AttribRawProcessBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_PROCESS); }
+
+ /* FlowControlKeyword: Resource Descriptors (ACPI 5.0) */
+
+"FlowControlHardware" { count (0); return (PARSEOP_FLOWCONTROL_HW); }
+"FlowControlNone" { count (0); return (PARSEOP_FLOWCONTROL_NONE); }
+"FlowControlXon" { count (0); return (PARSEOP_FLOWCONTROL_SW); }
+
+ /* InterruptLevelKeyword: Interrupt Active Types */
+
+"ActiveBoth" { count (0); return (PARSEOP_INTLEVEL_ACTIVEBOTH); }
+"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
+"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
+
+ /* InterruptTypeKeyword: Interrupt Types */
+
+"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); }
+"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); }
+
+ /* IoDecodeKeyword: Type of Memory Decoding - Resource Descriptors */
+
+"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); }
+"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); }
+
+ /* IoRestrictionKeyword: I/O Restriction - GPIO Resource Descriptors (ACPI 5.0) */
+
+"IoRestrictionNone" { count (0); return (PARSEOP_IORESTRICT_NONE); }
+"IoRestrictionInputOnly" { count (0); return (PARSEOP_IORESTRICT_IN); }
+"IoRestrictionOutputOnly" { count (0); return (PARSEOP_IORESTRICT_OUT); }
+"IoRestrictionNoneAndPreserve" { count (0); return (PARSEOP_IORESTRICT_PRESERVE); }
+
+ /* LockRuleKeyword: Global Lock use for Field Operator */
+
+"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); }
+"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
+
+ /* MatchOpKeyword: Types for Match Operator */
+
+"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); }
+"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
+"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); }
+"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); }
+"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); }
+"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); }
+
+ /* MaxKeyword: Max Range Type - Resource Descriptors */
+
+"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); }
+"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
+
+ /* MemTypeKeyword: Memory Types - Resource Descriptors */
+
+"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
+"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
+"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
+"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
+
+ /* MinKeyword: Min Range Type - Resource Descriptors */
+
+"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); }
+"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
+
+ /* ObjectTypeKeyword: ACPI Object Types */
+
"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); }
"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); }
@@ -290,22 +468,38 @@ NamePathTail [.]{NameSeg}
"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
-"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
-"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
-"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
-"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
-"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
-"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
+ /* ParityKeyword: Resource Descriptors (ACPI 5.0) */
-"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); }
-"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
+"ParityTypeSpace" { count (0); return (PARSEOP_PARITYTYPE_SPACE); }
+"ParityTypeMark" { count (0); return (PARSEOP_PARITYTYPE_MARK); }
+"ParityTypeOdd" { count (0); return (PARSEOP_PARITYTYPE_ODD); }
+"ParityTypeEven" { count (0); return (PARSEOP_PARITYTYPE_EVEN); }
+"ParityTypeNone" { count (0); return (PARSEOP_PARITYTYPE_NONE); }
-"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
-"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); }
-"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
+ /* PinConfigKeyword: Pin Configuration - GPIO Resource Descriptors (ACPI 5.0) */
-"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
-"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
+"PullDefault" { count (0); return (PARSEOP_PIN_PULLDEFAULT); }
+"PullUp" { count (0); return (PARSEOP_PIN_PULLUP); }
+"PullDown" { count (0); return (PARSEOP_PIN_PULLDOWN); }
+"PullNone" { count (0); return (PARSEOP_PIN_NOPULL); }
+
+ /* PolarityKeyword: Resource Descriptors (ACPI 5.0) */
+
+"PolarityLow" { count (0); return (PARSEOP_DEVICEPOLARITY_LOW); }
+"PolarityHigh" { count (0); return (PARSEOP_DEVICEPOLARITY_HIGH); }
+
+ /* RangeTypeKeyword: I/O Range Types - Resource Descriptors */
+
+"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
+"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
+"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
+
+ /* ReadWriteKeyword: Memory Access Types - Resource Descriptors */
+
+"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
+"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
+
+ /* RegionSpaceKeyword: Operation Region Address Space Types */
"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); }
"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); }
@@ -315,86 +509,82 @@ NamePathTail [.]{NameSeg}
"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
"IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); }
+"GeneralPurposeIo" { count (0); return (PARSEOP_REGIONSPACE_GPIO); } /* ACPI 5.0 */
+"GenericSerialBus" { count (0); return (PARSEOP_REGIONSPACE_GSBUS); } /* ACPI 5.0 */
+"FFixedHW" { count (0); return (PARSEOP_REGIONSPACE_FFIXEDHW); }
-"FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); }
-
-"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
-"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
-"SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
-"SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
-"SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
-"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
-"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
-
-"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); }
-"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
-"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); }
-"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); }
-"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); }
-"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); }
+ /* ResourceTypeKeyword: Resource Usage - Resource Descriptors */
-"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
-"TypeA" { count (0); return (PARSEOP_DMATYPE_A); }
-"TypeB" { count (0); return (PARSEOP_DMATYPE_B); }
-"TypeF" { count (0); return (PARSEOP_DMATYPE_F); }
+"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
+"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
-"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
-"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
+ /* SerializeRuleKeyword: Control Method Serialization */
-"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); }
-"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); }
-"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); }
+"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
+"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
-"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
-"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
+ /* ShareTypeKeyword: Interrupt Sharing - Resource Descriptors */
-"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); }
-"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
+"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); }
+"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
+"SharedAndWake" { count (0); return (PARSEOP_SHARETYPE_SHAREDWAKE); } /* ACPI 5.0 */
+"ExclusiveAndWake" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVEWAKE); } /* ACPI 5.0 */
-"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); }
-"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
+ /* SlaveModeKeyword: Resource Descriptors (ACPI 5.0) */
-"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); }
-"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); }
+"ControllerInitiated" { count (0); return (PARSEOP_SLAVEMODE_CONTROLLERINIT); }
+"DeviceInitiated" { count (0); return (PARSEOP_SLAVEMODE_DEVICEINIT); }
-"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
-"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
-"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
+ /* StopBitsKeyword: Resource Descriptors (ACPI 5.0) */
-"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
-"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
-"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
-"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
+"StopBitsOne" { count (0); return (PARSEOP_STOPBITS_ONE); }
+"StopBitsOnePlusHalf" { count (0); return (PARSEOP_STOPBITS_ONEPLUSHALF); }
+"StopBitsTwo" { count (0); return (PARSEOP_STOPBITS_TWO); }
+"StopBitsZero" { count (0); return (PARSEOP_STOPBITS_ZERO); }
-"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
-"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
+ /* TransferWidthKeyword: DMA Widths - Fixed DMA Resource Descriptor (ACPI 5.0) */
-"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); }
-"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); }
+"Width8bit" { count (0); return (PARSEOP_XFERSIZE_8); }
+"Width16bit" { count (0); return (PARSEOP_XFERSIZE_16); }
+"Width32bit" { count (0); return (PARSEOP_XFERSIZE_32); }
+"Width64bit" { count (0); return (PARSEOP_XFERSIZE_64); }
+"Width128bit" { count (0); return (PARSEOP_XFERSIZE_128); }
+"Width256bit" { count (0); return (PARSEOP_XFERSIZE_256); }
-"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
-"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
+ /* TranslationKeyword: Translation Density Types - Resource Descriptors */
-"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); }
-"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
+"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
+"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
-"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); }
-"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); }
+ /* TypeKeyword: Translation Types - Resource Descriptors */
"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); }
"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); }
-"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
-"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
+ /* UpdateRuleKeyword: Field Update Rules */
-"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
-"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
-"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
-"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
+"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
+"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); }
+"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
+
+ /* WireModeKeyword: SPI Wire Mode - Resource Descriptors (ACPI 5.0) */
+
+"FourWireMode" { count (0); return (PARSEOP_WIREMODE_FOUR); }
+"ThreeWireMode" { count (0); return (PARSEOP_WIREMODE_THREE); }
+
+ /* XferTypeKeyword: DMA Transfer Types */
+
+"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); }
+"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); }
+"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); }
+
+ /* Predefined compiler names */
"__DATE__" { count (0); return (PARSEOP___DATE__); }
"__FILE__" { count (0); return (PARSEOP___FILE__); }
"__LINE__" { count (0); return (PARSEOP___LINE__); }
+"__PATH__" { count (0); return (PARSEOP___PATH__); }
+
"{" { count (0); return('{'); }
"}" { count (0); return('}'); }
@@ -402,7 +592,6 @@ NamePathTail [.]{NameSeg}
"(" { count (0); return('('); }
")" { count (0); return(')'); }
-
{NameSeg} { char *s;
count (0);
s=malloc (ACPI_NAME_SIZE + 1);
@@ -478,7 +667,6 @@ AslPopInputFileStack (
void)
{
ASL_FILE_NODE *Fnode;
- FILE *InputFile = NULL;
Fnode = InputStack;
@@ -497,7 +685,6 @@ AslPopInputFileStack (
/* Update the top-of-stack */
InputStack = Fnode->Next;
- InputFile = Fnode->File;
/* Reset global line counter and filename */
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.y b/sys/contrib/dev/acpica/compiler/aslcompiler.y
index 79e716f..eb0cc9f 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.y
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.y
@@ -1,8 +1,7 @@
-
%{
/******************************************************************************
*
- * Module Name: aslcompiler.y - Bison input file (ASL grammar and actions)
+ * Module Name: aslcompiler.y - Bison/Yacc input file (ASL grammar and actions)
*
*****************************************************************************/
@@ -106,22 +105,28 @@ void * AslLocalAllocate (unsigned int Size);
* These shift/reduce conflicts are expected. There should be zero
* reduce/reduce conflicts.
*/
-%expect 60
+%expect 86
-/*
+/******************************************************************************
+ *
* Token types: These are returned by the lexer
*
* NOTE: This list MUST match the AslKeywordMapping table found
* in aslmap.c EXACTLY! Double check any changes!
- */
+ *
+ *****************************************************************************/
+
%token <i> PARSEOP_ACCESSAS
%token <i> PARSEOP_ACCESSATTRIB_BLOCK
%token <i> PARSEOP_ACCESSATTRIB_BLOCK_CALL
%token <i> PARSEOP_ACCESSATTRIB_BYTE
-%token <i> PARSEOP_ACCESSATTRIB_WORD_CALL
+%token <i> PARSEOP_ACCESSATTRIB_MULTIBYTE
%token <i> PARSEOP_ACCESSATTRIB_QUICK
+%token <i> PARSEOP_ACCESSATTRIB_RAW_BYTES
+%token <i> PARSEOP_ACCESSATTRIB_RAW_PROCESS
%token <i> PARSEOP_ACCESSATTRIB_SND_RCV
%token <i> PARSEOP_ACCESSATTRIB_WORD
+%token <i> PARSEOP_ACCESSATTRIB_WORD_CALL
%token <i> PARSEOP_ACCESSTYPE_ANY
%token <i> PARSEOP_ACCESSTYPE_BUF
%token <i> PARSEOP_ACCESSTYPE_BYTE
@@ -130,7 +135,8 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_ACCESSTYPE_WORD
%token <i> PARSEOP_ACQUIRE
%token <i> PARSEOP_ADD
-%token <i> PARSEOP_ADDRESSSPACE_FFIXEDHW
+%token <i> PARSEOP_ADDRESSINGMODE_7BIT
+%token <i> PARSEOP_ADDRESSINGMODE_10BIT
%token <i> PARSEOP_ADDRESSTYPE_ACPI
%token <i> PARSEOP_ADDRESSTYPE_MEMORY
%token <i> PARSEOP_ADDRESSTYPE_NVS
@@ -145,6 +151,11 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_ARG5
%token <i> PARSEOP_ARG6
%token <i> PARSEOP_BANKFIELD
+%token <i> PARSEOP_BITSPERBYTE_EIGHT
+%token <i> PARSEOP_BITSPERBYTE_FIVE
+%token <i> PARSEOP_BITSPERBYTE_NINE
+%token <i> PARSEOP_BITSPERBYTE_SEVEN
+%token <i> PARSEOP_BITSPERBYTE_SIX
%token <i> PARSEOP_BREAK
%token <i> PARSEOP_BREAKPOINT
%token <i> PARSEOP_BUFFER
@@ -152,9 +163,14 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_BUSMASTERTYPE_NOTMASTER
%token <i> PARSEOP_BYTECONST
%token <i> PARSEOP_CASE
+%token <i> PARSEOP_CLOCKPHASE_FIRST
+%token <i> PARSEOP_CLOCKPHASE_SECOND
+%token <i> PARSEOP_CLOCKPOLARITY_HIGH
+%token <i> PARSEOP_CLOCKPOLARITY_LOW
%token <i> PARSEOP_CONCATENATE
%token <i> PARSEOP_CONCATENATERESTEMPLATE
%token <i> PARSEOP_CONDREFOF
+%token <i> PARSEOP_CONNECTION
%token <i> PARSEOP_CONTINUE
%token <i> PARSEOP_COPYOBJECT
%token <i> PARSEOP_CREATEBITFIELD
@@ -163,6 +179,7 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_CREATEFIELD
%token <i> PARSEOP_CREATEQWORDFIELD
%token <i> PARSEOP_CREATEWORDFIELD
+%token <i> PARSEOP_DATABUFFER
%token <i> PARSEOP_DATATABLEREGION
%token <i> PARSEOP_DEBUG
%token <i> PARSEOP_DECODETYPE_POS
@@ -173,6 +190,8 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_DEFINITIONBLOCK
%token <i> PARSEOP_DEREFOF
%token <i> PARSEOP_DEVICE
+%token <i> PARSEOP_DEVICEPOLARITY_HIGH
+%token <i> PARSEOP_DEVICEPOLARITY_LOW
%token <i> PARSEOP_DIVIDE
%token <i> PARSEOP_DMA
%token <i> PARSEOP_DMATYPE_A
@@ -187,6 +206,8 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_ELSE
%token <i> PARSEOP_ELSEIF
%token <i> PARSEOP_ENDDEPENDENTFN
+%token <i> PARSEOP_ENDIAN_BIG
+%token <i> PARSEOP_ENDIAN_LITTLE
%token <i> PARSEOP_ENDTAG
%token <i> PARSEOP_ERRORNODE
%token <i> PARSEOP_EVENT
@@ -198,9 +219,16 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_FIELD
%token <i> PARSEOP_FINDSETLEFTBIT
%token <i> PARSEOP_FINDSETRIGHTBIT
+%token <i> PARSEOP_FIXEDDMA
%token <i> PARSEOP_FIXEDIO
+%token <i> PARSEOP_FLOWCONTROL_HW
+%token <i> PARSEOP_FLOWCONTROL_NONE
+%token <i> PARSEOP_FLOWCONTROL_SW
%token <i> PARSEOP_FROMBCD
%token <i> PARSEOP_FUNCTION
+%token <i> PARSEOP_GPIO_INT
+%token <i> PARSEOP_GPIO_IO
+%token <i> PARSEOP_I2C_SERIALBUS
%token <i> PARSEOP_IF
%token <i> PARSEOP_INCLUDE
%token <i> PARSEOP_INCLUDE_CSTYLE
@@ -210,6 +238,7 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_INDEXFIELD
%token <i> PARSEOP_INTEGER
%token <i> PARSEOP_INTERRUPT
+%token <i> PARSEOP_INTLEVEL_ACTIVEBOTH
%token <i> PARSEOP_INTLEVEL_ACTIVEHIGH
%token <i> PARSEOP_INTLEVEL_ACTIVELOW
%token <i> PARSEOP_INTTYPE_EDGE
@@ -217,6 +246,10 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_IO
%token <i> PARSEOP_IODECODETYPE_10
%token <i> PARSEOP_IODECODETYPE_16
+%token <i> PARSEOP_IORESTRICT_IN
+%token <i> PARSEOP_IORESTRICT_NONE
+%token <i> PARSEOP_IORESTRICT_OUT
+%token <i> PARSEOP_IORESTRICT_PRESERVE
%token <i> PARSEOP_IRQ
%token <i> PARSEOP_IRQNOFLAGS
%token <i> PARSEOP_LAND
@@ -297,6 +330,15 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_OR
%token <i> PARSEOP_PACKAGE
%token <i> PARSEOP_PACKAGE_LENGTH
+%token <i> PARSEOP_PARITYTYPE_EVEN
+%token <i> PARSEOP_PARITYTYPE_MARK
+%token <i> PARSEOP_PARITYTYPE_NONE
+%token <i> PARSEOP_PARITYTYPE_ODD
+%token <i> PARSEOP_PARITYTYPE_SPACE
+%token <i> PARSEOP_PIN_NOPULL
+%token <i> PARSEOP_PIN_PULLDEFAULT
+%token <i> PARSEOP_PIN_PULLDOWN
+%token <i> PARSEOP_PIN_PULLUP
%token <i> PARSEOP_POWERRESOURCE
%token <i> PARSEOP_PROCESSOR
%token <i> PARSEOP_QWORDCONST
@@ -312,6 +354,9 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_REFOF
%token <i> PARSEOP_REGIONSPACE_CMOS
%token <i> PARSEOP_REGIONSPACE_EC
+%token <i> PARSEOP_REGIONSPACE_FFIXEDHW
+%token <i> PARSEOP_REGIONSPACE_GPIO
+%token <i> PARSEOP_REGIONSPACE_GSBUS
%token <i> PARSEOP_REGIONSPACE_IO
%token <i> PARSEOP_REGIONSPACE_IPMI
%token <i> PARSEOP_REGIONSPACE_MEM
@@ -331,15 +376,24 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_SERIALIZERULE_NOTSERIAL
%token <i> PARSEOP_SERIALIZERULE_SERIAL
%token <i> PARSEOP_SHARETYPE_EXCLUSIVE
+%token <i> PARSEOP_SHARETYPE_EXCLUSIVEWAKE
%token <i> PARSEOP_SHARETYPE_SHARED
+%token <i> PARSEOP_SHARETYPE_SHAREDWAKE
%token <i> PARSEOP_SHIFTLEFT
%token <i> PARSEOP_SHIFTRIGHT
%token <i> PARSEOP_SIGNAL
%token <i> PARSEOP_SIZEOF
+%token <i> PARSEOP_SLAVEMODE_CONTROLLERINIT
+%token <i> PARSEOP_SLAVEMODE_DEVICEINIT
%token <i> PARSEOP_SLEEP
+%token <i> PARSEOP_SPI_SERIALBUS
%token <i> PARSEOP_STALL
%token <i> PARSEOP_STARTDEPENDENTFN
%token <i> PARSEOP_STARTDEPENDENTFN_NOPRI
+%token <i> PARSEOP_STOPBITS_ONE
+%token <i> PARSEOP_STOPBITS_ONEPLUSHALF
+%token <i> PARSEOP_STOPBITS_TWO
+%token <i> PARSEOP_STOPBITS_ZERO
%token <i> PARSEOP_STORE
%token <s> PARSEOP_STRING_LITERAL
%token <i> PARSEOP_SUBTRACT
@@ -357,6 +411,7 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_TRANSLATIONTYPE_SPARSE
%token <i> PARSEOP_TYPE_STATIC
%token <i> PARSEOP_TYPE_TRANSLATION
+%token <i> PARSEOP_UART_SERIALBUS
%token <i> PARSEOP_UNICODE
%token <i> PARSEOP_UNLOAD
%token <i> PARSEOP_UPDATERULE_ONES
@@ -367,10 +422,18 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_VENDORSHORT
%token <i> PARSEOP_WAIT
%token <i> PARSEOP_WHILE
+%token <i> PARSEOP_WIREMODE_FOUR
+%token <i> PARSEOP_WIREMODE_THREE
%token <i> PARSEOP_WORDBUSNUMBER
%token <i> PARSEOP_WORDCONST
%token <i> PARSEOP_WORDIO
%token <i> PARSEOP_WORDSPACE
+%token <i> PARSEOP_XFERSIZE_8
+%token <i> PARSEOP_XFERSIZE_16
+%token <i> PARSEOP_XFERSIZE_32
+%token <i> PARSEOP_XFERSIZE_64
+%token <i> PARSEOP_XFERSIZE_128
+%token <i> PARSEOP_XFERSIZE_256
%token <i> PARSEOP_XFERTYPE_8
%token <i> PARSEOP_XFERTYPE_8_16
%token <i> PARSEOP_XFERTYPE_16
@@ -384,64 +447,64 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP___DATE__
%token <i> PARSEOP___FILE__
%token <i> PARSEOP___LINE__
+%token <i> PARSEOP___PATH__
-/*
+
+/******************************************************************************
+ *
* Production names
- */
+ *
+ *****************************************************************************/
+%type <n> ArgList
%type <n> ASLCode
-%type <n> DefinitionBlockTerm
-%type <n> TermList
-%type <n> Term
+%type <n> BufferData
+%type <n> BufferTermData
%type <n> CompilerDirective
-%type <n> ObjectList
-%type <n> Object
%type <n> DataObject
-%type <n> BufferData
-%type <n> PackageData
+%type <n> DefinitionBlockTerm
%type <n> IntegerData
-%type <n> StringData
%type <n> NamedObject
%type <n> NameSpaceModifier
-%type <n> UserTerm
-%type <n> ArgList
-%type <n> TermArg
-%type <n> Target
-%type <n> RequiredTarget
-%type <n> SimpleTarget
-%type <n> BufferTermData
+%type <n> Object
+%type <n> ObjectList
+%type <n> PackageData
%type <n> ParameterTypePackage
%type <n> ParameterTypePackageList
%type <n> ParameterTypesPackage
%type <n> ParameterTypesPackageList
+%type <n> RequiredTarget
+%type <n> SimpleTarget
+%type <n> StringData
+%type <n> Target
+%type <n> Term
+%type <n> TermArg
+%type <n> TermList
+%type <n> UserTerm
+
+/* Type4Opcode is obsolete */
%type <n> Type1Opcode
-%type <n> Type2Opcode
-%type <n> Type2IntegerOpcode
-%type <n> Type2StringOpcode
%type <n> Type2BufferOpcode
%type <n> Type2BufferOrStringOpcode
+%type <n> Type2IntegerOpcode
+%type <n> Type2Opcode
+%type <n> Type2StringOpcode
%type <n> Type3Opcode
-
-/* Obsolete %type <n> Type4Opcode */
-
%type <n> Type5Opcode
%type <n> Type6Opcode
-%type <n> LineTerm
-%type <n> IncludeTerm
-%type <n> IncludeCStyleTerm
+%type <n> AccessAsTerm
%type <n> ExternalTerm
-
-%type <n> FieldUnitList
%type <n> FieldUnit
%type <n> FieldUnitEntry
-
+%type <n> FieldUnitList
+%type <n> IncludeCStyleTerm
+%type <n> IncludeTerm
+%type <n> LineTerm
%type <n> OffsetTerm
-%type <n> AccessAsTerm
%type <n> OptionalAccessAttribTerm
-
/* Named Objects */
%type <n> BankFieldTerm
@@ -465,7 +528,6 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> ProcessorTerm
%type <n> ThermalZoneTerm
-
/* Namespace modifiers */
%type <n> AliasTerm
@@ -474,13 +536,16 @@ void * AslLocalAllocate (unsigned int Size);
/* Type 1 opcodes */
-%type <n> BreakTerm
%type <n> BreakPointTerm
+%type <n> BreakTerm
+%type <n> CaseDefaultTermList
+%type <n> CaseTerm
%type <n> ContinueTerm
+%type <n> DefaultTerm
+%type <n> ElseTerm
%type <n> FatalTerm
%type <n> IfElseTerm
%type <n> IfTerm
-%type <n> ElseTerm
%type <n> LoadTerm
%type <n> NoOpTerm
%type <n> NotifyTerm
@@ -491,20 +556,17 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> SleepTerm
%type <n> StallTerm
%type <n> SwitchTerm
-%type <n> CaseDefaultTermList
-//%type <n> CaseTermList
-%type <n> CaseTerm
-%type <n> DefaultTerm
%type <n> UnloadTerm
%type <n> WhileTerm
+//%type <n> CaseTermList
/* Type 2 opcodes */
%type <n> AcquireTerm
%type <n> AddTerm
%type <n> AndTerm
-%type <n> ConcatTerm
%type <n> ConcatResTerm
+%type <n> ConcatTerm
%type <n> CondRefOfTerm
%type <n> CopyObjectTerm
%type <n> DecTerm
@@ -517,12 +579,12 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> IndexTerm
%type <n> LAndTerm
%type <n> LEqualTerm
-%type <n> LGreaterTerm
%type <n> LGreaterEqualTerm
-%type <n> LLessTerm
+%type <n> LGreaterTerm
%type <n> LLessEqualTerm
-%type <n> LNotTerm
+%type <n> LLessTerm
%type <n> LNotEqualTerm
+%type <n> LNotTerm
%type <n> LoadTableTerm
%type <n> LOrTerm
%type <n> MatchTerm
@@ -550,39 +612,49 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> WaitTerm
%type <n> XOrTerm
-%type <n> OptionalTermArg
-%type <n> OptionalReturnArg
-%type <n> OptionalListString
-
-
/* Keywords */
-%type <n> ObjectTypeKeyword
-%type <n> AccessTypeKeyword
%type <n> AccessAttribKeyword
-%type <n> LockRuleKeyword
-%type <n> UpdateRuleKeyword
-%type <n> RegionSpaceKeyword
+%type <n> AccessTypeKeyword
+%type <n> AddressingModeKeyword
+%type <n> AddressKeyword
%type <n> AddressSpaceKeyword
-%type <n> MatchOpKeyword
-%type <n> SerializeRuleKeyword
+%type <n> BitsPerByteKeyword
+%type <n> ClockPhaseKeyword
+%type <n> ClockPolarityKeyword
+%type <n> DecodeKeyword
+%type <n> DevicePolarityKeyword
%type <n> DMATypeKeyword
-%type <n> OptionalBusMasterKeyword
-%type <n> XferTypeKeyword
-%type <n> ResourceTypeKeyword
-%type <n> MinKeyword
+%type <n> EndianKeyword
+%type <n> FlowControlKeyword
+%type <n> InterruptLevel
+%type <n> InterruptTypeKeyword
+%type <n> IODecodeKeyword
+%type <n> IoRestrictionKeyword
+%type <n> LockRuleKeyword
+%type <n> MatchOpKeyword
%type <n> MaxKeyword
-%type <n> DecodeKeyword
-%type <n> RangeTypeKeyword
%type <n> MemTypeKeyword
+%type <n> MinKeyword
+%type <n> ObjectTypeKeyword
+%type <n> OptionalBusMasterKeyword
%type <n> OptionalReadWriteKeyword
-%type <n> InterruptTypeKeyword
-%type <n> InterruptLevel
+%type <n> ParityTypeKeyword
+%type <n> PinConfigByte
+%type <n> PinConfigKeyword
+%type <n> RangeTypeKeyword
+%type <n> RegionSpaceKeyword
+%type <n> ResourceTypeKeyword
+%type <n> SerializeRuleKeyword
%type <n> ShareTypeKeyword
-%type <n> IODecodeKeyword
-%type <n> TypeKeyword
+%type <n> SlaveModeKeyword
+%type <n> StopBitsKeyword
%type <n> TranslationKeyword
-%type <n> AddressKeyword
+%type <n> TypeKeyword
+%type <n> UpdateRuleKeyword
+%type <n> WireModeKeyword
+%type <n> XferSizeKeyword
+%type <n> XferTypeKeyword
/* Types */
@@ -599,31 +671,34 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> String
%type <n> ConstTerm
+%type <n> ConstExprTerm
%type <n> ByteConstExpr
%type <n> WordConstExpr
%type <n> DWordConstExpr
%type <n> QWordConstExpr
-%type <n> ConstExprTerm
+%type <n> DWordList
%type <n> BufferTerm
%type <n> ByteList
-%type <n> DWordList
-%type <n> PackageTerm
-%type <n> PackageList
%type <n> PackageElement
-
+%type <n> PackageList
+%type <n> PackageTerm
%type <n> VarPackageLengthTerm
/* Macros */
%type <n> EISAIDTerm
+%type <n> ResourceMacroList
+%type <n> ResourceMacroTerm
%type <n> ResourceTemplateTerm
%type <n> ToUUIDTerm
%type <n> UnicodeTerm
-%type <n> ResourceMacroList
-%type <n> ResourceMacroTerm
+/* Resource Descriptors */
+
+%type <n> ConnectionTerm
+%type <n> DataBufferTerm
%type <n> DMATerm
%type <n> DWordIOTerm
%type <n> DWordMemoryTerm
@@ -632,7 +707,11 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> ExtendedIOTerm
%type <n> ExtendedMemoryTerm
%type <n> ExtendedSpaceTerm
+%type <n> FixedDmaTerm
%type <n> FixedIOTerm
+%type <n> GpioIntTerm
+%type <n> GpioIoTerm
+%type <n> I2cSerialBusTerm
%type <n> InterruptTerm
%type <n> IOTerm
%type <n> IRQNoFlagsTerm
@@ -640,59 +719,75 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> Memory24Term
%type <n> Memory32FixedTerm
%type <n> Memory32Term
+%type <n> NameSeg
+%type <n> NameString
%type <n> QWordIOTerm
%type <n> QWordMemoryTerm
%type <n> QWordSpaceTerm
%type <n> RegisterTerm
-%type <n> StartDependentFnTerm
+%type <n> SpiSerialBusTerm
%type <n> StartDependentFnNoPriTerm
+%type <n> StartDependentFnTerm
+%type <n> UartSerialBusTerm
%type <n> VendorLongTerm
%type <n> VendorShortTerm
%type <n> WordBusNumberTerm
%type <n> WordIOTerm
%type <n> WordSpaceTerm
-%type <n> NameString
-%type <n> NameSeg
-
-
/* Local types that help construct the AML, not in ACPI spec */
-%type <n> IncludeEndTerm
%type <n> AmlPackageLengthTerm
+%type <n> IncludeEndTerm
+%type <n> NameStringItem
+%type <n> TermArgItem
+
+%type <n> OptionalAccessSize
+%type <n> OptionalAddressingMode
+%type <n> OptionalAddressRange
+%type <n> OptionalBitsPerByte
+%type <n> OptionalBuffer_Last
%type <n> OptionalByteConstExpr
+%type <n> OptionalCount
+%type <n> OptionalDecodeType
+%type <n> OptionalDevicePolarity
%type <n> OptionalDWordConstExpr
-%type <n> OptionalQWordConstExpr
-%type <n> OptionalSerializeRuleKeyword
-%type <n> OptionalResourceType_First
-%type <n> OptionalResourceType
-%type <n> OptionalMinType
+%type <n> OptionalEndian
+%type <n> OptionalFlowControl
+%type <n> OptionalIoRestriction
+%type <n> OptionalListString
%type <n> OptionalMaxType
%type <n> OptionalMemType
-%type <n> OptionalCount
-%type <n> OptionalDecodeType
-%type <n> OptionalRangeType
-%type <n> OptionalShareType
-%type <n> OptionalType
-%type <n> OptionalType_Last
-%type <n> OptionalTranslationType_Last
-%type <n> OptionalStringData
+%type <n> OptionalMinType
%type <n> OptionalNameString
%type <n> OptionalNameString_First
%type <n> OptionalNameString_Last
-%type <n> OptionalAddressRange
%type <n> OptionalObjectTypeKeyword
%type <n> OptionalParameterTypePackage
%type <n> OptionalParameterTypesPackage
+%type <n> OptionalParityType
+%type <n> OptionalQWordConstExpr
+%type <n> OptionalRangeType
%type <n> OptionalReference
-%type <n> OptionalAccessSize
-
-%type <n> TermArgItem
-%type <n> NameStringItem
+%type <n> OptionalResourceType
+%type <n> OptionalResourceType_First
+%type <n> OptionalReturnArg
+%type <n> OptionalSerializeRuleKeyword
+%type <n> OptionalShareType
+%type <n> OptionalShareType_First
+%type <n> OptionalSlaveMode
+%type <n> OptionalStopBits
+%type <n> OptionalStringData
+%type <n> OptionalTermArg
+%type <n> OptionalTranslationType_Last
+%type <n> OptionalType
+%type <n> OptionalType_Last
+%type <n> OptionalWireMode
+%type <n> OptionalWordConst
+%type <n> OptionalWordConstExpr
+%type <n> OptionalXferSize
%%
-
-
/*******************************************************************************
*
* Production rules start here
@@ -745,7 +840,9 @@ DefinitionBlockTerm
TermList
: {$$ = NULL;}
| TermList Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
+ | TermList Term ';' {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
| TermList ';' Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
+ | TermList ';' Term ';' {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
;
Term
@@ -1107,6 +1204,7 @@ FieldUnit
: FieldUnitEntry {}
| OffsetTerm {}
| AccessAsTerm {}
+ | ConnectionTerm {}
;
FieldUnitEntry
@@ -1132,6 +1230,21 @@ AccessAsTerm
error ')' {$$ = AslDoError(); yyclearin;}
;
+ConnectionTerm
+ : PARSEOP_CONNECTION '('
+ NameString
+ ')' {$$ = TrCreateNode (PARSEOP_CONNECTION,1,$3);}
+ | PARSEOP_CONNECTION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONNECTION);}
+ ResourceMacroTerm
+ ')' {$$ = TrLinkChildren ($<n>3, 1,
+ TrLinkChildren (TrCreateLeafNode (PARSEOP_RESOURCETEMPLATE), 3,
+ TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
+ TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
+ $4));}
+ | PARSEOP_CONNECTION '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
CreateBitFieldTerm
: PARSEOP_CREATEBITFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);}
TermArg
@@ -2052,23 +2165,23 @@ XOrTerm
/******* Keywords *************************************************************/
-ObjectTypeKeyword
- : PARSEOP_OBJECTTYPE_UNK {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
- | PARSEOP_OBJECTTYPE_INT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);}
- | PARSEOP_OBJECTTYPE_STR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);}
- | PARSEOP_OBJECTTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);}
- | PARSEOP_OBJECTTYPE_PKG {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);}
- | PARSEOP_OBJECTTYPE_FLD {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);}
- | PARSEOP_OBJECTTYPE_DEV {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);}
- | PARSEOP_OBJECTTYPE_EVT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);}
- | PARSEOP_OBJECTTYPE_MTH {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);}
- | PARSEOP_OBJECTTYPE_MTX {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);}
- | PARSEOP_OBJECTTYPE_OPR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);}
- | PARSEOP_OBJECTTYPE_POW {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);}
- | PARSEOP_OBJECTTYPE_PRO {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);}
- | PARSEOP_OBJECTTYPE_THZ {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);}
- | PARSEOP_OBJECTTYPE_BFF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);}
- | PARSEOP_OBJECTTYPE_DDB {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);}
+AccessAttribKeyword
+ : PARSEOP_ACCESSATTRIB_BLOCK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);}
+ | PARSEOP_ACCESSATTRIB_BLOCK_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);}
+ | PARSEOP_ACCESSATTRIB_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);}
+ | PARSEOP_ACCESSATTRIB_QUICK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );}
+ | PARSEOP_ACCESSATTRIB_SND_RCV {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);}
+ | PARSEOP_ACCESSATTRIB_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);}
+ | PARSEOP_ACCESSATTRIB_WORD_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);}
+ | PARSEOP_ACCESSATTRIB_MULTIBYTE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_MULTIBYTE);}
+ ByteConst
+ ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
+ | PARSEOP_ACCESSATTRIB_RAW_BYTES '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_BYTES);}
+ ByteConst
+ ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
+ | PARSEOP_ACCESSATTRIB_RAW_PROCESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_PROCESS);}
+ ByteConst
+ ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
;
AccessTypeKeyword
@@ -2080,49 +2193,95 @@ AccessTypeKeyword
| PARSEOP_ACCESSTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BUF);}
;
-AccessAttribKeyword
- : PARSEOP_ACCESSATTRIB_QUICK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );}
- | PARSEOP_ACCESSATTRIB_SND_RCV {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);}
- | PARSEOP_ACCESSATTRIB_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);}
- | PARSEOP_ACCESSATTRIB_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);}
- | PARSEOP_ACCESSATTRIB_BLOCK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);}
- | PARSEOP_ACCESSATTRIB_WORD_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);}
- | PARSEOP_ACCESSATTRIB_BLOCK_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);}
+AddressingModeKeyword
+ : PARSEOP_ADDRESSINGMODE_7BIT {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_7BIT);}
+ | PARSEOP_ADDRESSINGMODE_10BIT {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_10BIT);}
;
-LockRuleKeyword
- : PARSEOP_LOCKRULE_LOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);}
- | PARSEOP_LOCKRULE_NOLOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);}
+AddressKeyword
+ : PARSEOP_ADDRESSTYPE_MEMORY {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);}
+ | PARSEOP_ADDRESSTYPE_RESERVED {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);}
+ | PARSEOP_ADDRESSTYPE_NVS {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);}
+ | PARSEOP_ADDRESSTYPE_ACPI {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);}
;
-UpdateRuleKeyword
- : PARSEOP_UPDATERULE_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);}
- | PARSEOP_UPDATERULE_ONES {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);}
- | PARSEOP_UPDATERULE_ZEROS {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);}
+AddressSpaceKeyword
+ : ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
+ | RegionSpaceKeyword {}
;
+BitsPerByteKeyword
+ : PARSEOP_BITSPERBYTE_FIVE {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_FIVE);}
+ | PARSEOP_BITSPERBYTE_SIX {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SIX);}
+ | PARSEOP_BITSPERBYTE_SEVEN {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SEVEN);}
+ | PARSEOP_BITSPERBYTE_EIGHT {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_EIGHT);}
+ | PARSEOP_BITSPERBYTE_NINE {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_NINE);}
+ ;
-RegionSpaceKeyword
- : PARSEOP_REGIONSPACE_IO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);}
- | PARSEOP_REGIONSPACE_MEM {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);}
- | PARSEOP_REGIONSPACE_PCI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);}
- | PARSEOP_REGIONSPACE_EC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);}
- | PARSEOP_REGIONSPACE_SMBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);}
- | PARSEOP_REGIONSPACE_CMOS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);}
- | PARSEOP_REGIONSPACE_PCIBAR {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);}
- | PARSEOP_REGIONSPACE_IPMI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);}
+ClockPhaseKeyword
+ : PARSEOP_CLOCKPHASE_FIRST {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_FIRST);}
+ | PARSEOP_CLOCKPHASE_SECOND {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_SECOND);}
;
-AddressSpaceKeyword
- : ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
- | RegionSpaceKeyword {}
- | PARSEOP_ADDRESSSPACE_FFIXEDHW {$$ = TrCreateLeafNode (PARSEOP_ADDRESSSPACE_FFIXEDHW);}
+ClockPolarityKeyword
+ : PARSEOP_CLOCKPOLARITY_LOW {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_LOW);}
+ | PARSEOP_CLOCKPOLARITY_HIGH {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_HIGH);}
;
+DecodeKeyword
+ : PARSEOP_DECODETYPE_POS {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);}
+ | PARSEOP_DECODETYPE_SUB {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);}
+ ;
-SerializeRuleKeyword
- : PARSEOP_SERIALIZERULE_SERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);}
- | PARSEOP_SERIALIZERULE_NOTSERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);}
+DevicePolarityKeyword
+ : PARSEOP_DEVICEPOLARITY_LOW {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_LOW);}
+ | PARSEOP_DEVICEPOLARITY_HIGH {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_HIGH);}
+ ;
+
+DMATypeKeyword
+ : PARSEOP_DMATYPE_A {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);}
+ | PARSEOP_DMATYPE_COMPATIBILITY {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);}
+ | PARSEOP_DMATYPE_B {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);}
+ | PARSEOP_DMATYPE_F {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);}
+ ;
+
+EndianKeyword
+ : PARSEOP_ENDIAN_LITTLE {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_LITTLE);}
+ | PARSEOP_ENDIAN_BIG {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_BIG);}
+ ;
+
+FlowControlKeyword
+ : PARSEOP_FLOWCONTROL_HW {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_HW);}
+ | PARSEOP_FLOWCONTROL_NONE {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_NONE);}
+ | PARSEOP_FLOWCONTROL_SW {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_SW);}
+ ;
+
+InterruptLevel
+ : PARSEOP_INTLEVEL_ACTIVEBOTH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEBOTH);}
+ | PARSEOP_INTLEVEL_ACTIVEHIGH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);}
+ | PARSEOP_INTLEVEL_ACTIVELOW {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);}
+ ;
+
+InterruptTypeKeyword
+ : PARSEOP_INTTYPE_EDGE {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);}
+ | PARSEOP_INTTYPE_LEVEL {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);}
+ ;
+
+IODecodeKeyword
+ : PARSEOP_IODECODETYPE_16 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);}
+ | PARSEOP_IODECODETYPE_10 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);}
+ ;
+
+IoRestrictionKeyword
+ : PARSEOP_IORESTRICT_IN {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_IN);}
+ | PARSEOP_IORESTRICT_OUT {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_OUT);}
+ | PARSEOP_IORESTRICT_NONE {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_NONE);}
+ | PARSEOP_IORESTRICT_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_PRESERVE);}
+ ;
+
+LockRuleKeyword
+ : PARSEOP_LOCKRULE_LOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);}
+ | PARSEOP_LOCKRULE_NOLOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);}
;
MatchOpKeyword
@@ -2134,22 +2293,16 @@ MatchOpKeyword
| PARSEOP_MATCHTYPE_MGT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGT);}
;
-DMATypeKeyword
- : PARSEOP_DMATYPE_A {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);}
- | PARSEOP_DMATYPE_COMPATIBILITY {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);}
- | PARSEOP_DMATYPE_B {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);}
- | PARSEOP_DMATYPE_F {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);}
- ;
-
-XferTypeKeyword
- : PARSEOP_XFERTYPE_8 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);}
- | PARSEOP_XFERTYPE_8_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);}
- | PARSEOP_XFERTYPE_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);}
+MaxKeyword
+ : PARSEOP_MAXTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);}
+ | PARSEOP_MAXTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);}
;
-ResourceTypeKeyword
- : PARSEOP_RESOURCETYPE_CONSUMER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
- | PARSEOP_RESOURCETYPE_PRODUCER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);}
+MemTypeKeyword
+ : PARSEOP_MEMTYPE_CACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);}
+ | PARSEOP_MEMTYPE_WRITECOMBINING {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);}
+ | PARSEOP_MEMTYPE_PREFETCHABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);}
+ | PARSEOP_MEMTYPE_NONCACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);}
;
MinKeyword
@@ -2157,14 +2310,43 @@ MinKeyword
| PARSEOP_MINTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_NOTFIXED);}
;
-MaxKeyword
- : PARSEOP_MAXTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);}
- | PARSEOP_MAXTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);}
+ObjectTypeKeyword
+ : PARSEOP_OBJECTTYPE_UNK {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
+ | PARSEOP_OBJECTTYPE_INT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);}
+ | PARSEOP_OBJECTTYPE_STR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);}
+ | PARSEOP_OBJECTTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);}
+ | PARSEOP_OBJECTTYPE_PKG {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);}
+ | PARSEOP_OBJECTTYPE_FLD {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);}
+ | PARSEOP_OBJECTTYPE_DEV {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);}
+ | PARSEOP_OBJECTTYPE_EVT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);}
+ | PARSEOP_OBJECTTYPE_MTH {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);}
+ | PARSEOP_OBJECTTYPE_MTX {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);}
+ | PARSEOP_OBJECTTYPE_OPR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);}
+ | PARSEOP_OBJECTTYPE_POW {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);}
+ | PARSEOP_OBJECTTYPE_PRO {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);}
+ | PARSEOP_OBJECTTYPE_THZ {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);}
+ | PARSEOP_OBJECTTYPE_BFF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);}
+ | PARSEOP_OBJECTTYPE_DDB {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);}
;
-DecodeKeyword
- : PARSEOP_DECODETYPE_POS {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);}
- | PARSEOP_DECODETYPE_SUB {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);}
+ParityTypeKeyword
+ : PARSEOP_PARITYTYPE_SPACE {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_SPACE);}
+ | PARSEOP_PARITYTYPE_MARK {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_MARK);}
+ | PARSEOP_PARITYTYPE_ODD {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_ODD);}
+ | PARSEOP_PARITYTYPE_EVEN {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_EVEN);}
+ | PARSEOP_PARITYTYPE_NONE {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_NONE);}
+ ;
+
+PinConfigByte
+ : PinConfigKeyword {$$ = $1;}
+ | ByteConstExpr {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
+ ;
+
+PinConfigKeyword
+ : PARSEOP_PIN_NOPULL {$$ = TrCreateLeafNode (PARSEOP_PIN_NOPULL);}
+ | PARSEOP_PIN_PULLDOWN {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDOWN);}
+ | PARSEOP_PIN_PULLUP {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLUP);}
+ | PARSEOP_PIN_PULLDEFAULT {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDEFAULT);}
;
RangeTypeKeyword
@@ -2173,37 +2355,52 @@ RangeTypeKeyword
| PARSEOP_RANGETYPE_ENTIRE {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ENTIRE);}
;
-MemTypeKeyword
- : PARSEOP_MEMTYPE_CACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);}
- | PARSEOP_MEMTYPE_WRITECOMBINING {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);}
- | PARSEOP_MEMTYPE_PREFETCHABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);}
- | PARSEOP_MEMTYPE_NONCACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);}
- ;
-
-OptionalReadWriteKeyword
- : {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
- | PARSEOP_READWRITETYPE_BOTH {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
- | PARSEOP_READWRITETYPE_READONLY {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_READONLY);}
+RegionSpaceKeyword
+ : PARSEOP_REGIONSPACE_IO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);}
+ | PARSEOP_REGIONSPACE_MEM {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);}
+ | PARSEOP_REGIONSPACE_PCI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);}
+ | PARSEOP_REGIONSPACE_EC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);}
+ | PARSEOP_REGIONSPACE_SMBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);}
+ | PARSEOP_REGIONSPACE_CMOS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);}
+ | PARSEOP_REGIONSPACE_PCIBAR {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);}
+ | PARSEOP_REGIONSPACE_IPMI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);}
+ | PARSEOP_REGIONSPACE_GPIO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GPIO);}
+ | PARSEOP_REGIONSPACE_GSBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GSBUS);}
+ | PARSEOP_REGIONSPACE_FFIXEDHW {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_FFIXEDHW);}
;
-InterruptTypeKeyword
- : PARSEOP_INTTYPE_EDGE {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);}
- | PARSEOP_INTTYPE_LEVEL {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);}
+ResourceTypeKeyword
+ : PARSEOP_RESOURCETYPE_CONSUMER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
+ | PARSEOP_RESOURCETYPE_PRODUCER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);}
;
-InterruptLevel
- : PARSEOP_INTLEVEL_ACTIVEHIGH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);}
- | PARSEOP_INTLEVEL_ACTIVELOW {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);}
+SerializeRuleKeyword
+ : PARSEOP_SERIALIZERULE_SERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);}
+ | PARSEOP_SERIALIZERULE_NOTSERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);}
;
ShareTypeKeyword
: PARSEOP_SHARETYPE_SHARED {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHARED);}
| PARSEOP_SHARETYPE_EXCLUSIVE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVE);}
+ | PARSEOP_SHARETYPE_SHAREDWAKE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHAREDWAKE);}
+ | PARSEOP_SHARETYPE_EXCLUSIVEWAKE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVEWAKE);}
+ ;
+
+SlaveModeKeyword
+ : PARSEOP_SLAVEMODE_CONTROLLERINIT {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_CONTROLLERINIT);}
+ | PARSEOP_SLAVEMODE_DEVICEINIT {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_DEVICEINIT);}
;
-IODecodeKeyword
- : PARSEOP_IODECODETYPE_16 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);}
- | PARSEOP_IODECODETYPE_10 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);}
+StopBitsKeyword
+ : PARSEOP_STOPBITS_TWO {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_TWO);}
+ | PARSEOP_STOPBITS_ONEPLUSHALF {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONEPLUSHALF);}
+ | PARSEOP_STOPBITS_ONE {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONE);}
+ | PARSEOP_STOPBITS_ZERO {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ZERO);}
+ ;
+
+TranslationKeyword
+ : PARSEOP_TRANSLATIONTYPE_SPARSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);}
+ | PARSEOP_TRANSLATIONTYPE_DENSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);}
;
TypeKeyword
@@ -2211,16 +2408,30 @@ TypeKeyword
| PARSEOP_TYPE_STATIC {$$ = TrCreateLeafNode (PARSEOP_TYPE_STATIC);}
;
-TranslationKeyword
- : PARSEOP_TRANSLATIONTYPE_SPARSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);}
- | PARSEOP_TRANSLATIONTYPE_DENSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);}
+UpdateRuleKeyword
+ : PARSEOP_UPDATERULE_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);}
+ | PARSEOP_UPDATERULE_ONES {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);}
+ | PARSEOP_UPDATERULE_ZEROS {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);}
;
-AddressKeyword
- : PARSEOP_ADDRESSTYPE_MEMORY {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);}
- | PARSEOP_ADDRESSTYPE_RESERVED {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);}
- | PARSEOP_ADDRESSTYPE_NVS {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);}
- | PARSEOP_ADDRESSTYPE_ACPI {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);}
+WireModeKeyword
+ : PARSEOP_WIREMODE_FOUR {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_FOUR);}
+ | PARSEOP_WIREMODE_THREE {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_THREE);}
+ ;
+
+XferSizeKeyword
+ : PARSEOP_XFERSIZE_8 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_8, 0);}
+ | PARSEOP_XFERSIZE_16 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_16, 1);}
+ | PARSEOP_XFERSIZE_32 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
+ | PARSEOP_XFERSIZE_64 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_64, 3);}
+ | PARSEOP_XFERSIZE_128 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_128, 4);}
+ | PARSEOP_XFERSIZE_256 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_256, 5);}
+ ;
+
+XferTypeKeyword
+ : PARSEOP_XFERTYPE_8 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);}
+ | PARSEOP_XFERTYPE_8_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);}
+ | PARSEOP_XFERTYPE_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);}
;
@@ -2291,6 +2502,16 @@ ConstTerm
| PARSEOP_REVISION {$$ = TrCreateLeafNode (PARSEOP_REVISION);}
;
+ConstExprTerm
+ : PARSEOP_ZERO {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);}
+ | PARSEOP_ONE {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);}
+ | PARSEOP_ONES {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);}
+ | PARSEOP___DATE__ {$$ = TrCreateConstantLeafNode (PARSEOP___DATE__);}
+ | PARSEOP___FILE__ {$$ = TrCreateConstantLeafNode (PARSEOP___FILE__);}
+ | PARSEOP___LINE__ {$$ = TrCreateConstantLeafNode (PARSEOP___LINE__);}
+ | PARSEOP___PATH__ {$$ = TrCreateConstantLeafNode (PARSEOP___PATH__);}
+ ;
+
ByteConstExpr
: Type3Opcode {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
| Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
@@ -2319,15 +2540,6 @@ QWordConstExpr
| QWordConst {}
;
-ConstExprTerm
- : PARSEOP_ZERO {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);}
- | PARSEOP_ONE {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);}
- | PARSEOP_ONES {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);}
- | PARSEOP___DATE__ {$$ = TrCreateConstantLeafNode (PARSEOP___DATE__);}
- | PARSEOP___FILE__ {$$ = TrCreateConstantLeafNode (PARSEOP___FILE__);}
- | PARSEOP___LINE__ {$$ = TrCreateConstantLeafNode (PARSEOP___LINE__);}
- ;
-
/* OptionalCount must appear before ByteList or an incorrect reduction will result */
OptionalCount
@@ -2336,7 +2548,6 @@ OptionalCount
| ',' TermArg {$$ = $2;}
;
-
BufferTerm
: PARSEOP_BUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BUFFER);}
OptionalTermArg
@@ -2359,6 +2570,15 @@ ByteList
ByteConstExpr {$$ = TrLinkPeerNode ($1,$3);}
;
+DataBufferTerm
+ : PARSEOP_DATABUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DATABUFFER);}
+ OptionalWordConst
+ ')' '{'
+ ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
+ | PARSEOP_DATABUFFER '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
DWordList
: {$$ = NULL;}
| DWordConstExpr
@@ -2376,11 +2596,6 @@ PackageTerm
error ')' {$$ = AslDoError(); yyclearin;}
;
-VarPackageLengthTerm
- : {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
- | TermArg {$$ = $1;}
- ;
-
PackageList
: {$$ = NULL;}
| PackageElement
@@ -2394,6 +2609,15 @@ PackageElement
| NameString {}
;
+VarPackageLengthTerm
+ : {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
+ | TermArg {$$ = $1;}
+ ;
+
+
+/******* Macros ***********************************************/
+
+
EISAIDTerm
: PARSEOP_EISAID '('
StringData ')' {$$ = TrUpdateNode (PARSEOP_EISAID, $3);}
@@ -2401,6 +2625,14 @@ EISAIDTerm
error ')' {$$ = AslDoError(); yyclearin;}
;
+UnicodeTerm
+ : PARSEOP_UNICODE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNICODE);}
+ StringData
+ ')' {$$ = TrLinkChildren ($<n>3,2,0,$4);}
+ | PARSEOP_UNICODE '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
/******* Resources and Memory ***********************************************/
@@ -2419,14 +2651,6 @@ ResourceTemplateTerm
TrCreateLeafNode (PARSEOP_ENDTAG));}
;
-UnicodeTerm
- : PARSEOP_UNICODE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNICODE);}
- StringData
- ')' {$$ = TrLinkChildren ($<n>3,2,0,$4);}
- | PARSEOP_UNICODE '('
- error ')' {$$ = AslDoError(); yyclearin;}
- ;
-
ResourceMacroList
: {$$ = NULL;}
| ResourceMacroList
@@ -2442,7 +2666,11 @@ ResourceMacroTerm
| ExtendedIOTerm {}
| ExtendedMemoryTerm {}
| ExtendedSpaceTerm {}
+ | FixedDmaTerm {}
| FixedIOTerm {}
+ | GpioIntTerm {}
+ | GpioIoTerm {}
+ | I2cSerialBusTerm {}
| InterruptTerm {}
| IOTerm {}
| IRQNoFlagsTerm {}
@@ -2454,8 +2682,10 @@ ResourceMacroTerm
| QWordMemoryTerm {}
| QWordSpaceTerm {}
| RegisterTerm {}
- | StartDependentFnTerm {}
+ | SpiSerialBusTerm {}
| StartDependentFnNoPriTerm {}
+ | StartDependentFnTerm {}
+ | UartSerialBusTerm {}
| VendorLongTerm {}
| VendorShortTerm {}
| WordBusNumberTerm {}
@@ -2612,6 +2842,17 @@ ExtendedSpaceTerm
error ')' {$$ = AslDoError(); yyclearin;}
;
+FixedDmaTerm
+ : PARSEOP_FIXEDDMA '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDDMA);}
+ WordConstExpr // 04: DMA RequestLines
+ ',' WordConstExpr // 06: DMA Channels
+ OptionalXferSize // 07: DMA TransferSize
+ OptionalNameString // 08: DescriptorName
+ ')' {$$ = TrLinkChildren ($<n>3,4,$4,$6,$7,$8);}
+ | PARSEOP_FIXEDDMA '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
FixedIOTerm
: PARSEOP_FIXEDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDIO);}
WordConstExpr
@@ -2622,6 +2863,58 @@ FixedIOTerm
error ')' {$$ = AslDoError(); yyclearin;}
;
+GpioIntTerm
+ : PARSEOP_GPIO_INT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_INT);}
+ InterruptTypeKeyword // 04: InterruptType
+ ',' InterruptLevel // 06: InterruptLevel
+ OptionalShareType // 07: SharedType
+ ',' PinConfigByte // 09: PinConfig
+ OptionalWordConstExpr // 10: DebounceTimeout
+ ',' StringData // 12: ResourceSource
+ OptionalByteConstExpr // 13: ResourceSourceIndex
+ OptionalResourceType // 14: ResourceType
+ OptionalNameString // 15: DescriptorName
+ OptionalBuffer_Last // 16: VendorData
+ ')' '{'
+ DWordConstExpr '}' {$$ = TrLinkChildren ($<n>3,11,$4,$6,$7,$9,$10,$12,$13,$14,$15,$16,$19);}
+ | PARSEOP_GPIO_INT '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
+GpioIoTerm
+ : PARSEOP_GPIO_IO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_IO);}
+ OptionalShareType_First // 04: SharedType
+ ',' PinConfigByte // 06: PinConfig
+ OptionalWordConstExpr // 07: DebounceTimeout
+ OptionalWordConstExpr // 08: DriveStrength
+ OptionalIoRestriction // 09: IoRestriction
+ ',' StringData // 11: ResourceSource
+ OptionalByteConstExpr // 12: ResourceSourceIndex
+ OptionalResourceType // 13: ResourceType
+ OptionalNameString // 14: DescriptorName
+ OptionalBuffer_Last // 15: VendorData
+ ')' '{'
+ DWordList '}' {$$ = TrLinkChildren ($<n>3,11,$4,$6,$7,$8,$9,$11,$12,$13,$14,$15,$18);}
+ | PARSEOP_GPIO_IO '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
+I2cSerialBusTerm
+ : PARSEOP_I2C_SERIALBUS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_I2C_SERIALBUS);}
+ WordConstExpr // 04: SlaveAddress
+ OptionalSlaveMode // 05: SlaveMode
+ ',' DWordConstExpr // 07: ConnectionSpeed
+ OptionalAddressingMode // 08: AddressingMode
+ ',' StringData // 10: ResourceSource
+ OptionalByteConstExpr // 11: ResourceSourceIndex
+ OptionalResourceType // 12: ResourceType
+ OptionalNameString // 13: DescriptorName
+ OptionalBuffer_Last // 14: VendorData
+ ')' {$$ = TrLinkChildren ($<n>3,9,$4,$5,$7,$8,$10,$11,$12,$13,$14);}
+ | PARSEOP_I2C_SERIALBUS '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
InterruptTerm
: PARSEOP_INTERRUPT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INTERRUPT);}
OptionalResourceType_First
@@ -2787,6 +3080,34 @@ RegisterTerm
error ')' {$$ = AslDoError(); yyclearin;}
;
+SpiSerialBusTerm
+ : PARSEOP_SPI_SERIALBUS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SPI_SERIALBUS);}
+ WordConstExpr // 04: DeviceSelection
+ OptionalDevicePolarity // 05: DevicePolarity
+ OptionalWireMode // 06: WireMode
+ ',' ByteConstExpr // 08: DataBitLength
+ OptionalSlaveMode // 09: SlaveMode
+ ',' DWordConstExpr // 11: ConnectionSpeed
+ ',' ClockPolarityKeyword // 13: ClockPolarity
+ ',' ClockPhaseKeyword // 15: ClockPhase
+ ',' StringData // 17: ResourceSource
+ OptionalByteConstExpr // 18: ResourceSourceIndex
+ OptionalResourceType // 19: ResourceType
+ OptionalNameString // 20: DescriptorName
+ OptionalBuffer_Last // 21: VendorData
+ ')' {$$ = TrLinkChildren ($<n>3,13,$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,$21);}
+ | PARSEOP_SPI_SERIALBUS '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
+StartDependentFnNoPriTerm
+ : PARSEOP_STARTDEPENDENTFN_NOPRI '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);}
+ ')' '{'
+ ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,1,$6);}
+ | PARSEOP_STARTDEPENDENTFN_NOPRI '('
+ error ')' {$$ = AslDoError(); yyclearin;}
+ ;
+
StartDependentFnTerm
: PARSEOP_STARTDEPENDENTFN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);}
ByteConstExpr
@@ -2797,11 +3118,24 @@ StartDependentFnTerm
error ')' {$$ = AslDoError(); yyclearin;}
;
-StartDependentFnNoPriTerm
- : PARSEOP_STARTDEPENDENTFN_NOPRI '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);}
- ')' '{'
- ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,1,$6);}
- | PARSEOP_STARTDEPENDENTFN_NOPRI '('
+UartSerialBusTerm
+ : PARSEOP_UART_SERIALBUS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UART_SERIALBUS);}
+ DWordConstExpr // 04: ConnectionSpeed
+ OptionalBitsPerByte // 05: BitsPerByte
+ OptionalStopBits // 06: StopBits
+ ',' ByteConstExpr // 08: LinesInUse
+ OptionalEndian // 09: Endianess
+ OptionalParityType // 10: Parity
+ OptionalFlowControl // 11: FlowControl
+ ',' WordConstExpr // 13: Rx BufferSize
+ ',' WordConstExpr // 15: Tx BufferSize
+ ',' StringData // 17: ResourceSource
+ OptionalByteConstExpr // 18: ResourceSourceIndex
+ OptionalResourceType // 19: ResourceType
+ OptionalNameString // 20: DescriptorName
+ OptionalBuffer_Last // 21: VendorData
+ ')' {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,$21);}
+ | PARSEOP_UART_SERIALBUS '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@@ -2910,6 +3244,16 @@ AmlPackageLengthTerm
: Integer {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);}
;
+NameStringItem
+ : ',' NameString {$$ = $2;}
+ | ',' error {$$ = AslDoError (); yyclearin;}
+ ;
+
+TermArgItem
+ : ',' TermArg {$$ = $2;}
+ | ',' error {$$ = AslDoError (); yyclearin;}
+ ;
+
OptionalBusMasterKeyword
: ',' {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
| ',' PARSEOP_BUSMASTERTYPE_MASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
@@ -2929,12 +3273,28 @@ OptionalAccessSize
| ',' ByteConstExpr {$$ = $2;}
;
+OptionalAddressingMode
+ : ',' {$$ = NULL;}
+ | ',' AddressingModeKeyword {$$ = $2;}
+ ;
+
OptionalAddressRange
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' AddressKeyword {$$ = $2;}
;
+OptionalBitsPerByte
+ : ',' {$$ = NULL;}
+ | ',' BitsPerByteKeyword {$$ = $2;}
+ ;
+
+OptionalBuffer_Last
+ : {$$ = NULL;}
+ | ',' {$$ = NULL;}
+ | ',' DataBufferTerm {$$ = $2;}
+ ;
+
OptionalByteConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
@@ -2946,12 +3306,32 @@ OptionalDecodeType
| ',' DecodeKeyword {$$ = $2;}
;
+OptionalDevicePolarity
+ : ',' {$$ = NULL;}
+ | ',' DevicePolarityKeyword {$$ = $2;}
+ ;
+
OptionalDWordConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' DWordConstExpr {$$ = $2;}
;
+OptionalEndian
+ : ',' {$$ = NULL;}
+ | ',' EndianKeyword {$$ = $2;}
+ ;
+
+OptionalFlowControl
+ : ',' {$$ = NULL;}
+ | ',' FlowControlKeyword {$$ = $2;}
+ ;
+
+OptionalIoRestriction
+ : ',' {$$ = NULL;}
+ | ',' IoRestrictionKeyword {$$ = $2;}
+ ;
+
OptionalListString
: {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
| ',' {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
@@ -2995,6 +3375,11 @@ OptionalObjectTypeKeyword
| ',' ObjectTypeKeyword {$$ = $2;}
;
+OptionalParityType
+ : ',' {$$ = NULL;}
+ | ',' ParityTypeKeyword {$$ = $2;}
+ ;
+
OptionalQWordConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
@@ -3006,6 +3391,12 @@ OptionalRangeType
| ',' RangeTypeKeyword {$$ = $2;}
;
+OptionalReadWriteKeyword
+ : {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
+ | PARSEOP_READWRITETYPE_BOTH {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
+ | PARSEOP_READWRITETYPE_READONLY {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_READONLY);}
+ ;
+
OptionalReference
: {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */
| ',' {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */
@@ -3013,27 +3404,48 @@ OptionalReference
;
OptionalResourceType_First
- : {$$ = NULL;}
+ : {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
| ResourceTypeKeyword {$$ = $1;}
;
OptionalResourceType
- : ',' {$$ = NULL;}
+ : {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
+ | ',' {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
| ',' ResourceTypeKeyword {$$ = $2;}
;
+OptionalReturnArg
+ : {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN);} /* Placeholder is a ZeroOp object */
+ | TermArg {$$ = $1;}
+ ;
+
OptionalSerializeRuleKeyword
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' SerializeRuleKeyword {$$ = $2;}
;
+OptionalSlaveMode
+ : ',' {$$ = NULL;}
+ | ',' SlaveModeKeyword {$$ = $2;}
+ ;
+
OptionalShareType
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' ShareTypeKeyword {$$ = $2;}
;
+OptionalShareType_First
+ : {$$ = NULL;}
+ | ShareTypeKeyword {$$ = $1;}
+ ;
+
+OptionalStopBits
+ : ',' {$$ = NULL;}
+ | ',' StopBitsKeyword {$$ = $2;}
+ ;
+
OptionalStringData
: {$$ = NULL;}
| ',' {$$ = NULL;}
@@ -3045,11 +3457,6 @@ OptionalTermArg
| TermArg {$$ = $1;}
;
-OptionalReturnArg
- : {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN);} /* Placeholder is a ZeroOp object */
- | TermArg {$$ = $1;}
- ;
-
OptionalType
: {$$ = NULL;}
| ',' {$$ = NULL;}
@@ -3068,23 +3475,33 @@ OptionalTranslationType_Last
| ',' TranslationKeyword {$$ = $2;}
;
-
-TermArgItem
- : ',' TermArg {$$ = $2;}
- | ',' error {$$ = AslDoError (); yyclearin;}
+OptionalWireMode
+ : ',' {$$ = NULL;}
+ | ',' WireModeKeyword {$$ = $2;}
;
-NameStringItem
- : ',' NameString {$$ = $2;}
- | ',' error {$$ = AslDoError (); yyclearin;}
+OptionalWordConst
+ : {$$ = NULL;}
+ | WordConst {$$ = $1;}
;
-%%
+OptionalWordConstExpr
+ : ',' {$$ = NULL;}
+ | ',' WordConstExpr {$$ = $2;}
+ ;
+OptionalXferSize
+ : {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
+ | ',' {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
+ | ',' XferSizeKeyword {$$ = $2;}
+ ;
-/*
+%%
+/******************************************************************************
+ *
* Local support functions
- */
+ *
+ *****************************************************************************/
int
AslCompilerwrap(void)
diff --git a/sys/contrib/dev/acpica/compiler/asldefine.h b/sys/contrib/dev/acpica/compiler/asldefine.h
index 04e3b60..eafd700 100644
--- a/sys/contrib/dev/acpica/compiler/asldefine.h
+++ b/sys/contrib/dev/acpica/compiler/asldefine.h
@@ -56,7 +56,7 @@
#define ASL_INVOCATION_NAME "iasl"
#define ASL_CREATOR_ID "INTL"
-#define ASL_COMPLIANCE "Supports ACPI Specification Revision 4.0a"
+#define ASL_COMPLIANCE "Supports ACPI Specification Revision 5.0"
/* Configuration constants */
@@ -153,5 +153,25 @@
#define POSITIVE 0
+/* Helper macros for resource tag creation */
+
+#define RsCreateMultiBitField \
+ RsCreateResourceField
+
+#define RsCreateBitField(Op, Name, ByteOffset, BitOffset) \
+ RsCreateResourceField (Op, Name, ByteOffset, BitOffset, 1)
+
+#define RsCreateByteField(Op, Name, ByteOffset) \
+ RsCreateResourceField (Op, Name, ByteOffset, 0, 8);
+
+#define RsCreateWordField(Op, Name, ByteOffset) \
+ RsCreateResourceField (Op, Name, ByteOffset, 0, 16);
+
+#define RsCreateDwordField(Op, Name, ByteOffset) \
+ RsCreateResourceField (Op, Name, ByteOffset, 0, 32);
+
+#define RsCreateQwordField(Op, Name, ByteOffset) \
+ RsCreateResourceField (Op, Name, ByteOffset, 0, 64);
+
#endif /* ASLDEFINE.H */
diff --git a/sys/contrib/dev/acpica/compiler/aslerror.c b/sys/contrib/dev/acpica/compiler/aslerror.c
index aca5280..e5e3e61 100644
--- a/sys/contrib/dev/acpica/compiler/aslerror.c
+++ b/sys/contrib/dev/acpica/compiler/aslerror.c
@@ -319,10 +319,23 @@ AePrintException (
if (Enode->LineNumber)
{
+ /* Main message: try to use string from AslMessages first */
+
+ if (!MainMessage)
+ {
+ MainMessage = "";
+ }
+
MsgLength = strlen (MainMessage);
if (MsgLength == 0)
{
+ /* Use the secondary/extra message as main message */
+
MainMessage = Enode->Message;
+ if (!MainMessage)
+ {
+ MainMessage = "";
+ }
MsgLength = strlen (MainMessage);
ExtraMessage = NULL;
@@ -620,13 +633,13 @@ AslCoreSubsystemError (
int
AslCompilererror (
- char *CompilerMessage)
+ const char *CompilerMessage)
{
AslCommonError (ASL_ERROR, ASL_MSG_SYNTAX, Gbl_CurrentLineNumber,
- Gbl_LogicalLineNumber, Gbl_CurrentLineOffset,
- Gbl_CurrentColumn, Gbl_Files[ASL_FILE_INPUT].Filename,
- CompilerMessage);
+ Gbl_LogicalLineNumber, Gbl_CurrentLineOffset,
+ Gbl_CurrentColumn, Gbl_Files[ASL_FILE_INPUT].Filename,
+ ACPI_CAST_PTR (char, CompilerMessage));
return 0;
}
diff --git a/sys/contrib/dev/acpica/compiler/aslfiles.c b/sys/contrib/dev/acpica/compiler/aslfiles.c
index 725b715..4cde09d 100644
--- a/sys/contrib/dev/acpica/compiler/aslfiles.c
+++ b/sys/contrib/dev/acpica/compiler/aslfiles.c
@@ -174,14 +174,18 @@ FlGetFileSize (
{
FILE *fp;
UINT32 FileSize;
+ long Offset;
fp = Gbl_Files[FileId].Handle;
+ Offset = ftell (fp);
fseek (fp, 0, SEEK_END);
FileSize = (UINT32) ftell (fp);
- fseek (fp, 0, SEEK_SET);
+ /* Restore file pointer */
+
+ fseek (fp, Offset, SEEK_SET);
return (FileSize);
}
diff --git a/sys/contrib/dev/acpica/compiler/aslglobal.h b/sys/contrib/dev/acpica/compiler/aslglobal.h
index f80c89f..dd1dd49 100644
--- a/sys/contrib/dev/acpica/compiler/aslglobal.h
+++ b/sys/contrib/dev/acpica/compiler/aslglobal.h
@@ -128,6 +128,7 @@ ASL_EXTERN UINT8 ASL_INIT_GLOBAL (Gbl_WarningLevel, ASL_WARNI
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_UseOriginalCompilerId, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_VerboseTemplates, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DoTemplates, FALSE);
+ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_CompileGeneric, FALSE);
#define HEX_OUTPUT_NONE 0
diff --git a/sys/contrib/dev/acpica/compiler/asllisting.c b/sys/contrib/dev/acpica/compiler/asllisting.c
index 2c3febb..070695d 100644
--- a/sys/contrib/dev/acpica/compiler/asllisting.c
+++ b/sys/contrib/dev/acpica/compiler/asllisting.c
@@ -850,9 +850,9 @@ LsFinishSourceListing (
FlPrintFile (FileId, "\n\nSummary of errors and warnings\n\n");
AePrintErrorLog (FileId);
- FlPrintFile (FileId, "\n\n");
+ FlPrintFile (FileId, "\n");
UtDisplaySummary (FileId);
- FlPrintFile (FileId, "\n\n");
+ FlPrintFile (FileId, "\n");
}
}
@@ -1309,6 +1309,7 @@ LsDoHexOutputC (
/* Get AML size, seek back to start */
AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
+ FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
FlPrintFile (ASL_FILE_HEX_OUTPUT, " * C source code output\n");
FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n",
@@ -1365,7 +1366,6 @@ LsDoHexOutputC (
}
FlPrintFile (ASL_FILE_HEX_OUTPUT, "};\n");
- FlCloseFile (ASL_FILE_HEX_OUTPUT);
}
@@ -1397,6 +1397,7 @@ LsDoHexOutputAsl (
/* Get AML size, seek back to start */
AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
+ FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
FlPrintFile (ASL_FILE_HEX_OUTPUT, " * ASL source code output\n");
FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n",
@@ -1453,7 +1454,6 @@ LsDoHexOutputAsl (
}
FlPrintFile (ASL_FILE_HEX_OUTPUT, " })\n");
- FlCloseFile (ASL_FILE_HEX_OUTPUT);
}
@@ -1485,6 +1485,7 @@ LsDoHexOutputAsm (
/* Get AML size, seek back to start */
AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
+ FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
FlPrintFile (ASL_FILE_HEX_OUTPUT, "; Assembly code source output\n");
FlPrintFile (ASL_FILE_HEX_OUTPUT, "; AML code block contains 0x%X bytes\n;\n",
@@ -1536,7 +1537,6 @@ LsDoHexOutputAsm (
}
FlPrintFile (ASL_FILE_HEX_OUTPUT, "\n");
- FlCloseFile (ASL_FILE_HEX_OUTPUT);
}
diff --git a/sys/contrib/dev/acpica/compiler/aslload.c b/sys/contrib/dev/acpica/compiler/aslload.c
index 2e27767..064116e 100644
--- a/sys/contrib/dev/acpica/compiler/aslload.c
+++ b/sys/contrib/dev/acpica/compiler/aslload.c
@@ -189,7 +189,7 @@ LdLoadFieldElements (
{
case AML_INT_RESERVEDFIELD_OP:
case AML_INT_ACCESSFIELD_OP:
-
+ case AML_INT_CONNECTION_OP:
break;
default:
@@ -224,8 +224,10 @@ LdLoadFieldElements (
}
break;
}
+
Child = Child->Asl.Next;
}
+
return (AE_OK);
}
@@ -290,7 +292,6 @@ LdLoadResourceElements (
InitializerOp = ASL_GET_CHILD_NODE (Op);
while (InitializerOp)
{
-
if (InitializerOp->Asl.ExternalName)
{
Status = AcpiNsLookup (WalkState->ScopeInfo,
@@ -305,20 +306,15 @@ LdLoadResourceElements (
}
/*
- * Store the field offset in the namespace node so it
- * can be used when the field is referenced
+ * Store the field offset and length in the namespace node
+ * so it can be used when the field is referenced
*/
- Node->Value = (UINT32) InitializerOp->Asl.Value.Integer;
+ Node->Value = InitializerOp->Asl.Value.Tag.BitOffset;
+ Node->Length = InitializerOp->Asl.Value.Tag.BitLength;
InitializerOp->Asl.Node = Node;
Node->Op = InitializerOp;
-
- /* Pass thru the field type (Bitfield or Bytefield) */
-
- if (InitializerOp->Asl.CompileFlags & NODE_IS_BIT_OFFSET)
- {
- Node->Flags |= ANOBJ_IS_BIT_OFFSET;
- }
}
+
InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
}
diff --git a/sys/contrib/dev/acpica/compiler/asllookup.c b/sys/contrib/dev/acpica/compiler/asllookup.c
index 7112236..c8f5417 100644
--- a/sys/contrib/dev/acpica/compiler/asllookup.c
+++ b/sys/contrib/dev/acpica/compiler/asllookup.c
@@ -822,7 +822,10 @@ LkNamespaceLocateBegin (
ACPI_PARSE_OBJECT *OwningOp;
ACPI_PARSE_OBJECT *SpaceIdOp;
UINT32 MinimumLength;
- UINT32 Temp;
+ UINT32 Offset;
+ UINT32 FieldBitLength;
+ UINT32 TagBitLength;
+ UINT8 Message = 0;
const ACPI_OPCODE_INFO *OpInfo;
UINT32 Flags;
@@ -1026,74 +1029,106 @@ LkNamespaceLocateBegin (
/* 2) Check for a reference to a resource descriptor */
if ((Node->Type == ACPI_TYPE_LOCAL_RESOURCE_FIELD) ||
- (Node->Type == ACPI_TYPE_LOCAL_RESOURCE))
+ (Node->Type == ACPI_TYPE_LOCAL_RESOURCE))
{
/*
- * This was a reference to a field within a resource descriptor. Extract
- * the associated field offset (either a bit or byte offset depending on
- * the field type) and change the named reference into an integer for
- * AML code generation
+ * This was a reference to a field within a resource descriptor.
+ * Extract the associated field offset (either a bit or byte
+ * offset depending on the field type) and change the named
+ * reference into an integer for AML code generation
*/
- Temp = Node->Value;
- if (Node->Flags & ANOBJ_IS_BIT_OFFSET)
- {
- Op->Asl.CompileFlags |= NODE_IS_BIT_OFFSET;
- }
-
- /* Perform BitOffset <--> ByteOffset conversion if necessary */
+ Offset = Node->Value;
+ TagBitLength = Node->Length;
+ /*
+ * If a field is being created, generate the length (in bits) of
+ * the field. Note: Opcodes other than CreateXxxField and Index
+ * can come through here. For other opcodes, we just need to
+ * convert the resource tag reference to an integer offset.
+ */
switch (Op->Asl.Parent->Asl.AmlOpcode)
{
- case AML_CREATE_FIELD_OP:
+ case AML_CREATE_FIELD_OP: /* Variable "Length" field, in bits */
+ /*
+ * We know the length operand is an integer constant because
+ * we know that it contains a reference to a resource
+ * descriptor tag.
+ */
+ FieldBitLength = (UINT32) Op->Asl.Next->Asl.Value.Integer;
+ break;
- /* We allow a Byte offset to Bit Offset conversion for this op */
+ case AML_CREATE_BIT_FIELD_OP:
+ FieldBitLength = 1;
+ break;
- if (!(Op->Asl.CompileFlags & NODE_IS_BIT_OFFSET))
- {
- /* Simply multiply byte offset times 8 to get bit offset */
+ case AML_CREATE_BYTE_FIELD_OP:
+ case AML_INDEX_OP:
+ FieldBitLength = 8;
+ break;
- Temp = ACPI_MUL_8 (Temp);
- }
+ case AML_CREATE_WORD_FIELD_OP:
+ FieldBitLength = 16;
break;
+ case AML_CREATE_DWORD_FIELD_OP:
+ FieldBitLength = 32;
+ break;
- case AML_CREATE_BIT_FIELD_OP:
+ case AML_CREATE_QWORD_FIELD_OP:
+ FieldBitLength = 64;
+ break;
+
+ default:
+ FieldBitLength = 0;
+ break;
+ }
- /* This op requires a Bit Offset */
+ /* Check the field length against the length of the resource tag */
- if (!(Op->Asl.CompileFlags & NODE_IS_BIT_OFFSET))
+ if (FieldBitLength)
+ {
+ if (TagBitLength < FieldBitLength)
{
- AslError (ASL_ERROR, ASL_MSG_BYTES_TO_BITS, Op, NULL);
+ Message = ASL_MSG_TAG_SMALLER;
}
- break;
+ else if (TagBitLength > FieldBitLength)
+ {
+ Message = ASL_MSG_TAG_LARGER;
+ }
+
+ if (Message)
+ {
+ sprintf (MsgBuffer, "Tag: %u bit%s, Field: %u bit%s",
+ TagBitLength, (TagBitLength > 1) ? "s" : "",
+ FieldBitLength, (FieldBitLength > 1) ? "s" : "");
+ AslError (ASL_WARNING, Message, Op, MsgBuffer);
+ }
+ }
+ /* Convert the BitOffset to a ByteOffset for certain opcodes */
+
+ switch (Op->Asl.Parent->Asl.AmlOpcode)
+ {
case AML_CREATE_BYTE_FIELD_OP:
case AML_CREATE_WORD_FIELD_OP:
case AML_CREATE_DWORD_FIELD_OP:
case AML_CREATE_QWORD_FIELD_OP:
case AML_INDEX_OP:
- /* These Ops require Byte offsets */
-
- if (Op->Asl.CompileFlags & NODE_IS_BIT_OFFSET)
- {
- AslError (ASL_ERROR, ASL_MSG_BITS_TO_BYTES, Op, NULL);
- }
+ Offset = ACPI_DIV_8 (Offset);
break;
-
default:
- /* Nothing to do for other opcodes */
break;
}
/* Now convert this node to an integer whose value is the field offset */
- Op->Asl.AmlLength = 0;
- Op->Asl.ParseOpcode = PARSEOP_INTEGER;
- Op->Asl.Value.Integer = (UINT64) Temp;
- Op->Asl.CompileFlags |= NODE_IS_RESOURCE_FIELD;
+ Op->Asl.AmlLength = 0;
+ Op->Asl.ParseOpcode = PARSEOP_INTEGER;
+ Op->Asl.Value.Integer = (UINT64) Offset;
+ Op->Asl.CompileFlags |= NODE_IS_RESOURCE_FIELD;
OpcGenerateAmlOpcode (Op);
}
@@ -1253,6 +1288,7 @@ LkNamespaceLocateBegin (
{
case ACPI_ADR_SPACE_EC:
case ACPI_ADR_SPACE_CMOS:
+ case ACPI_ADR_SPACE_GPIO:
if ((UINT8) Op->Asl.Parent->Asl.Value.Integer != AML_FIELD_ACCESS_BYTE)
{
@@ -1262,6 +1298,7 @@ LkNamespaceLocateBegin (
case ACPI_ADR_SPACE_SMBUS:
case ACPI_ADR_SPACE_IPMI:
+ case ACPI_ADR_SPACE_GSBUS:
if ((UINT8) Op->Asl.Parent->Asl.Value.Integer != AML_FIELD_ACCESS_BUFFER)
{
diff --git a/sys/contrib/dev/acpica/compiler/aslmain.c b/sys/contrib/dev/acpica/compiler/aslmain.c
index fbad685..8a4f266 100644
--- a/sys/contrib/dev/acpica/compiler/aslmain.c
+++ b/sys/contrib/dev/acpica/compiler/aslmain.c
@@ -96,7 +96,7 @@ AslDoResponseFile (
#define ASL_TOKEN_SEPARATORS " \t\n"
-#define ASL_SUPPORTED_OPTIONS "@:2b:c:d^e:fgh^i^I:l^no:p:r:s:t:T:v:w:x:z"
+#define ASL_SUPPORTED_OPTIONS "@:2b:c:d^e:fgh^i^I:l^mno:p:r:s:t:T:G^v:w:x:z"
/*******************************************************************************
@@ -116,55 +116,57 @@ Options (
void)
{
- printf ("Global:\n");
- printf (" -@<file> Specify command file\n");
- printf (" -I<dir> Specify additional include directory\n");
+ printf ("\nGlobal:\n");
+ ACPI_OPTION ("-@ <file>", "Specify command file");
+ ACPI_OPTION ("-I <dir>", "Specify additional include directory");
printf ("\nGeneral Output:\n");
- printf (" -p<prefix> Specify path/filename prefix for all output files\n");
- printf (" -va Disable all errors and warnings (summary only)\n");
- printf (" -vi Less verbose errors and warnings for use with IDEs\n");
- printf (" -vo Enable optimization comments\n");
- printf (" -vr Disable remarks\n");
- printf (" -vs Disable signon\n");
- printf (" -w<1|2|3> Set warning reporting level\n");
+ ACPI_OPTION ("-p <prefix>", "Specify path/filename prefix for all output files");
+ ACPI_OPTION ("-va", "Disable all errors and warnings (summary only)");
+ ACPI_OPTION ("-vi", "Less verbose errors and warnings for use with IDEs");
+ ACPI_OPTION ("-vo", "Enable optimization comments");
+ ACPI_OPTION ("-vr", "Disable remarks");
+ ACPI_OPTION ("-vs", "Disable signon");
+ ACPI_OPTION ("-w <1|2|3>", "Set warning reporting level");
printf ("\nAML Output Files:\n");
- printf (" -s<a|c> Create AML in assembler or C source file (*.asm or *.c)\n");
- printf (" -i<a|c> Create assembler or C include file (*.inc or *.h)\n");
- printf (" -t<a|c|s> Create AML in assembler, C, or ASL hex table (*.hex)\n");
+ ACPI_OPTION ("-s <a|c>", "Create AML in assembler or C source file (*.asm or *.c)");
+ ACPI_OPTION ("-i <a|c>", "Create assembler or C include file (*.inc or *.h)");
+ ACPI_OPTION ("-t <a|c|s>", "Create AML in assembler, C, or ASL hex table (*.hex)");
printf ("\nAML Code Generation:\n");
- printf (" -oa Disable all optimizations (compatibility mode)\n");
- printf (" -of Disable constant folding\n");
- printf (" -oi Disable integer optimization to Zero/One/Ones\n");
- printf (" -on Disable named reference string optimization\n");
- printf (" -cr Disable Resource Descriptor error checking\n");
- printf (" -r<Revision> Override table header Revision (1-255)\n");
+ ACPI_OPTION ("-oa", "Disable all optimizations (compatibility mode)");
+ ACPI_OPTION ("-of", "Disable constant folding");
+ ACPI_OPTION ("-oi", "Disable integer optimization to Zero/One/Ones");
+ ACPI_OPTION ("-on", "Disable named reference string optimization");
+ ACPI_OPTION ("-cr", "Disable Resource Descriptor error checking");
+ ACPI_OPTION ("-r <revision>", "Override table header Revision (1-255)");
printf ("\nASL Listing Files:\n");
- printf (" -l Create mixed listing file (ASL source and AML) (*.lst)\n");
- printf (" -ln Create namespace file (*.nsp)\n");
- printf (" -ls Create combined source file (expanded includes) (*.src)\n");
+ ACPI_OPTION ("-l", "Create mixed listing file (ASL source and AML) (*.lst)");
+ ACPI_OPTION ("-ln", "Create namespace file (*.nsp)");
+ ACPI_OPTION ("-ls", "Create combined source file (expanded includes) (*.src)");
printf ("\nACPI Data Tables:\n");
- printf (" -T <Sig>|ALL|* Create table template file(s) for <Sig>\n");
- printf (" -vt Create verbose templates (full disassembly)\n");
+ ACPI_OPTION ("-G", "Compile custom table containing generic operators");
+ ACPI_OPTION ("-T <sig>|ALL|*", "Create table template file(s) for <Sig>");
+ ACPI_OPTION ("-vt", "Create verbose templates (full disassembly)");
printf ("\nAML Disassembler:\n");
- printf (" -d [file] Disassemble or decode binary ACPI table to file (*.dsl)\n");
- printf (" -da [f1,f2] Disassemble multiple tables from single namespace\n");
- printf (" -dc [file] Disassemble AML and immediately compile it\n");
- printf (" (Obtain DSDT from current system if no input file)\n");
- printf (" -e [f1,f2] Include ACPI table(s) for external symbol resolution\n");
- printf (" -2 Emit ACPI 2.0 compatible ASL code\n");
- printf (" -g Get ACPI tables and write to files (*.dat)\n");
+ ACPI_OPTION ("-d [file]", "Disassemble or decode binary ACPI table to file (*.dsl)");
+ ACPI_OPTION ("-da [f1,f2]", "Disassemble multiple tables from single namespace");
+ ACPI_OPTION ("-dc [file]", "Disassemble AML and immediately compile it");
+ ACPI_OPTION ("", "(Obtain DSDT from current system if no input file)");
+ ACPI_OPTION ("-e [f1,f2]", "Include ACPI table(s) for external symbol resolution");
+ ACPI_OPTION ("-m", "Do not translate Buffers to Resource Templates");
+ ACPI_OPTION ("-2", "Emit ACPI 2.0 compatible ASL code");
+ ACPI_OPTION ("-g", "Get ACPI tables and write to files (*.dat)");
printf ("\nHelp:\n");
- printf (" -h Additional help and compiler debug options\n");
- printf (" -hc Display operators allowed in constant expressions\n");
- printf (" -hr Display ACPI reserved method names\n");
- printf (" -ht Display currently supported ACPI table names\n");
+ ACPI_OPTION ("-h", "Additional help and compiler debug options");
+ ACPI_OPTION ("-hc", "Display operators allowed in constant expressions");
+ ACPI_OPTION ("-hr", "Display ACPI reserved method names");
+ ACPI_OPTION ("-ht", "Display currently supported ACPI table names");
}
@@ -185,7 +187,7 @@ HelpMessage (
void)
{
- printf ("AML output filename generation:\n");
+ printf ("\nAML output filename generation:\n");
printf (" Output filenames are generated by appending an extension to a common\n");
printf (" filename prefix. The filename prefix is obtained via one of the\n");
printf (" following methods (in priority order):\n");
@@ -197,13 +199,13 @@ HelpMessage (
Options ();
printf ("\nCompiler/Disassembler Debug Options:\n");
- printf (" -b<p|t|b> Create compiler debug/trace file (*.txt)\n");
- printf (" Types: Parse/Tree/Both\n");
- printf (" -f Ignore errors, force creation of AML output file(s)\n");
- printf (" -n Parse only, no output generation\n");
- printf (" -ot Display compile times\n");
- printf (" -x<level> Set debug level for trace output\n");
- printf (" -z Do not insert new compiler ID for DataTables\n");
+ ACPI_OPTION ("-b<p|t|b>", "Create compiler debug/trace file (*.txt)");
+ ACPI_OPTION ("", "Types: Parse/Tree/Both");
+ ACPI_OPTION ("-f", "Ignore errors, force creation of AML output file(s)");
+ ACPI_OPTION ("-n", "Parse only, no output generation");
+ ACPI_OPTION ("-ot", "Display compile times");
+ ACPI_OPTION ("-x<level>", "Set debug level for trace output");
+ ACPI_OPTION ("-z", "Do not insert new compiler ID for DataTables");
}
@@ -224,8 +226,8 @@ Usage (
void)
{
- printf ("%s\n", ASL_COMPLIANCE);
- printf ("Usage: %s [Options] [Files]\n\n", ASL_INVOCATION_NAME);
+ printf ("%s\n\n", ASL_COMPLIANCE);
+ ACPI_USAGE_HEADER ("iasl [Options] [Files]");
Options ();
}
@@ -600,6 +602,20 @@ AslDoOptions (
break;
+ case 'm':
+
+ AcpiGbl_NoResourceDisassembly = TRUE;
+ break;
+
+
+ case 'n':
+
+ /* Parse only */
+
+ Gbl_ParseOnlyFlag = TRUE;
+ break;
+
+
case 'o':
switch (AcpiGbl_Optarg[0])
@@ -648,14 +664,6 @@ AslDoOptions (
break;
- case 'n':
-
- /* Parse only */
-
- Gbl_ParseOnlyFlag = TRUE;
- break;
-
-
case 'p':
/* Override default AML output filename */
@@ -720,6 +728,11 @@ AslDoOptions (
break;
+ case 'G':
+ Gbl_CompileGeneric = TRUE;
+ break;
+
+
case 'T':
Gbl_DoTemplates = TRUE;
Gbl_TemplateSignature = AcpiGbl_Optarg;
diff --git a/sys/contrib/dev/acpica/compiler/aslmap.c b/sys/contrib/dev/acpica/compiler/aslmap.c
index 594f29a..aef79d8 100644
--- a/sys/contrib/dev/acpica/compiler/aslmap.c
+++ b/sys/contrib/dev/acpica/compiler/aslmap.c
@@ -126,13 +126,16 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* ACCESSAS */ OP_TABLE_ENTRY (AML_INT_ACCESSFIELD_OP, 0, 0, 0),
-/* ACCESSATTRIB_BLOCK */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SMB_BLOCK, 0, 0),
-/* ACCESSATTRIB_BLOCK_CALL */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SMB_BLOCK_CALL,0, 0),
-/* ACCESSATTRIB_BYTE */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SMB_BYTE, 0, 0),
-/* ACCESSATTRIB_WORD_CALL */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SMB_WORD_CALL, 0, 0),
-/* ACCESSATTRIB_QUICK */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SMB_QUICK, 0, 0),
-/* ACCESSATTRIB_SND_RCV */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SMB_SEND_RCV, 0, 0),
-/* ACCESSATTRIB_WORD */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SMB_WORD, 0, 0),
+/* ACCESSATTRIB_BLOCK */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_BLOCK, 0, 0),
+/* ACCESSATTRIB_BLOCK_CALL */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_BLOCK_CALL, 0, 0),
+/* ACCESSATTRIB_BYTE */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_BYTE, 0, 0),
+/* ACCESSATTRIB_MULTIBYTE */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_MULTIBYTE, 0, 0),
+/* ACCESSATTRIB_QUICK */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_QUICK, 0, 0),
+/* ACCESSATTRIB_RAW_BYTES */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_RAW_BYTES, 0, 0),
+/* ACCESSATTRIB_RAW_PROCESS */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_RAW_PROCESS, 0, 0),
+/* ACCESSATTRIB_SND_RCV */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_SEND_RCV, 0, 0),
+/* ACCESSATTRIB_WORD */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_WORD, 0, 0),
+/* ACCESSATTRIB_WORD_CALL */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ATTRIB_WORD_CALL, 0, 0),
/* ACCESSTYPE_ANY */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ACCESS_ANY, 0, 0),
/* ACCESSTYPE_BUF */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ACCESS_BUFFER, 0, 0),
/* ACCESSTYPE_BYTE */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ACCESS_BYTE, 0, 0),
@@ -141,7 +144,8 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* ACCESSTYPE_WORD */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_ACCESS_WORD, 0, 0),
/* ACQUIRE */ OP_TABLE_ENTRY (AML_ACQUIRE_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* ADD */ OP_TABLE_ENTRY (AML_ADD_OP, 0, 0, ACPI_BTYPE_INTEGER),
-/* ADDRESSSPACE_FFIXEDHW */ OP_TABLE_ENTRY (AML_BYTE_OP, ACPI_ADR_SPACE_FIXED_HARDWARE, 0, 0),
+/* ADDRESSINGMODE_7BIT */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* ADDRESSINGMODE_10BIT */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* ADDRESSTYPE_ACPI */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
/* ADDRESSTYPE_MEMORY */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* ADDRESSTYPE_NVS */ OP_TABLE_ENTRY (AML_BYTE_OP, 3, 0, 0),
@@ -156,6 +160,11 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* ARG5 */ OP_TABLE_ENTRY (AML_ARG5, 0, 0, ACPI_BTYPE_OBJECTS_AND_REFS),
/* ARG6 */ OP_TABLE_ENTRY (AML_ARG6, 0, 0, ACPI_BTYPE_OBJECTS_AND_REFS),
/* BANKFIELD */ OP_TABLE_ENTRY (AML_BANK_FIELD_OP, 0, NODE_AML_PACKAGE, 0),
+/* BITSPERBYTE_EIGHT */ OP_TABLE_ENTRY (AML_BYTE_OP, 3, 0, 0),
+/* BITSPERBYTE_FIVE */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* BITSPERBYTE_NINE */ OP_TABLE_ENTRY (AML_BYTE_OP, 4, 0, 0),
+/* BITSPERBYTE_SEVEN */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
+/* BITSPERBYTE_SIX */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* BREAK */ OP_TABLE_ENTRY (AML_BREAK_OP, 0, 0, 0),
/* BREAKPOINT */ OP_TABLE_ENTRY (AML_BREAK_POINT_OP, 0, 0, 0),
/* BUFFER */ OP_TABLE_ENTRY (AML_BUFFER_OP, 0, NODE_AML_PACKAGE, ACPI_BTYPE_BUFFER),
@@ -163,9 +172,14 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* BUSMASTERTYPE_NOTMASTER */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* BYTECONST */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, 0, 0, ACPI_BTYPE_INTEGER),
/* CASE */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
+/* CLOCKPHASE_FIRST */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* CLOCKPHASE_SECOND */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* CLOCKPOLARITY_HIGH */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* CLOCKPOLARITY_LOW */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* CONCATENATE */ OP_TABLE_ENTRY (AML_CONCAT_OP, 0, 0, ACPI_BTYPE_COMPUTE_DATA),
/* CONCATENATERESTEMPLATE */ OP_TABLE_ENTRY (AML_CONCAT_RES_OP, 0, 0, ACPI_BTYPE_BUFFER),
/* CONDREFOF */ OP_TABLE_ENTRY (AML_COND_REF_OF_OP, 0, 0, ACPI_BTYPE_INTEGER),
+/* CONNECTION */ OP_TABLE_ENTRY (AML_INT_CONNECTION_OP, 0, 0, 0),
/* CONTINUE */ OP_TABLE_ENTRY (AML_CONTINUE_OP, 0, 0, 0),
/* COPY */ OP_TABLE_ENTRY (AML_COPY_OP, 0, 0, ACPI_BTYPE_DATA_REFERENCE),
/* CREATEBITFIELD */ OP_TABLE_ENTRY (AML_CREATE_BIT_FIELD_OP, 0, 0, 0),
@@ -174,6 +188,7 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* CREATEFIELD */ OP_TABLE_ENTRY (AML_CREATE_FIELD_OP, 0, 0, 0),
/* CREATEQWORDFIELD */ OP_TABLE_ENTRY (AML_CREATE_QWORD_FIELD_OP, 0, 0, 0),
/* CREATEWORDFIELD */ OP_TABLE_ENTRY (AML_CREATE_WORD_FIELD_OP, 0, 0, 0),
+/* DATABUFFER */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* DATATABLEREGION */ OP_TABLE_ENTRY (AML_DATA_REGION_OP, 0, 0, 0),
/* DEBUG */ OP_TABLE_ENTRY (AML_DEBUG_OP, 0, 0, ACPI_BTYPE_DEBUG_OBJECT),
/* DECODETYPE_POS */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
@@ -184,6 +199,8 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* DEFINITIONBLOCK */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* DEREFOF */ OP_TABLE_ENTRY (AML_DEREF_OF_OP, 0, 0, ACPI_BTYPE_DATA_REFERENCE | ACPI_BTYPE_STRING),
/* DEVICE */ OP_TABLE_ENTRY (AML_DEVICE_OP, 0, NODE_AML_PACKAGE, 0),
+/* DEVICEPOLARITY_HIGH */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* DEVICEPOLARITY_LOW */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* DIVIDE */ OP_TABLE_ENTRY (AML_DIVIDE_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* DMA */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* DMATYPE_A */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
@@ -198,6 +215,8 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* ELSE */ OP_TABLE_ENTRY (AML_ELSE_OP, 0, NODE_AML_PACKAGE, 0),
/* ELSEIF */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, NODE_AML_PACKAGE, 0),
/* ENDDEPENDENTFN */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
+/* ENDIAN_BIG */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* ENDIAN_LITTLE */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* ENDTAG */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* ERRORNODE */ OP_TABLE_ENTRY (AML_NOOP_OP, 0, 0, 0),
/* EVENT */ OP_TABLE_ENTRY (AML_EVENT_OP, 0, 0, 0),
@@ -209,9 +228,16 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* FIELD */ OP_TABLE_ENTRY (AML_FIELD_OP, 0, NODE_AML_PACKAGE, 0),
/* FINDSETLEFTBIT */ OP_TABLE_ENTRY (AML_FIND_SET_LEFT_BIT_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* FINDSETRIGHTBIT */ OP_TABLE_ENTRY (AML_FIND_SET_RIGHT_BIT_OP, 0, 0, ACPI_BTYPE_INTEGER),
+/* FIXEDDMA */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* FIXEDIO */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
+/* FLOWCONTROL_HW */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* FLOWCONTROL_NONE */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* FLOWCONTROL_SW */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
/* FROMBCD */ OP_TABLE_ENTRY (AML_FROM_BCD_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* FUNCTION */ OP_TABLE_ENTRY (AML_METHOD_OP, 0, NODE_AML_PACKAGE, 0),
+/* GPIOINT */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
+/* GPIOIO */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
+/* I2CSERIALBUS */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* IF */ OP_TABLE_ENTRY (AML_IF_OP, 0, NODE_AML_PACKAGE, 0),
/* INCLUDE */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* INCLUDE_CSTYLE */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
@@ -221,6 +247,7 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* INDEXFIELD */ OP_TABLE_ENTRY (AML_INDEX_FIELD_OP, 0, NODE_AML_PACKAGE, 0),
/* INTEGER */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* INTERRUPT */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
+/* INTLEVEL_ACTIVEBOTH */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
/* INTLEVEL_ACTIVEHIGH */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* INTLEVEL_ACTIVELOW */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* INTTYPE_EDGE */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
@@ -228,6 +255,10 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* IO */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* IODECODETYPE_10 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* IODECODETYPE_16 */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* IORESTRICT_IN */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* IORESTRICT_NONE */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* IORESTRICT_OUT */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
+/* IORESTRICT_PRESERVE */ OP_TABLE_ENTRY (AML_BYTE_OP, 3, 0, 0),
/* IRQ */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* IRQNOFLAGS */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* LAND */ OP_TABLE_ENTRY (AML_LAND_OP, 0, 0, ACPI_BTYPE_INTEGER),
@@ -308,6 +339,15 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* OR */ OP_TABLE_ENTRY (AML_BIT_OR_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* PACKAGE */ OP_TABLE_ENTRY (AML_PACKAGE_OP, 0, NODE_AML_PACKAGE, ACPI_BTYPE_PACKAGE),
/* PACKAGEP_LENGTH */ OP_TABLE_ENTRY (AML_PACKAGE_LENGTH, 0, NODE_AML_PACKAGE, 0),
+/* PARITYTYPE_EVEN */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* PARITYTYPE_MARK */ OP_TABLE_ENTRY (AML_BYTE_OP, 3, 0, 0),
+/* PARITYTYPE_NONE */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* PARITYTYPE_ODD */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
+/* PARITYTYPE_SPACE */ OP_TABLE_ENTRY (AML_BYTE_OP, 4, 0, 0),
+/* PIN_NOPULL */ OP_TABLE_ENTRY (AML_BYTE_OP, 3, 0, 0),
+/* PIN_PULLDEFAULT */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* PIN_PULLDOWN */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
+/* PIN_PULLUP */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* POWERRESOURCE */ OP_TABLE_ENTRY (AML_POWER_RES_OP, 0, NODE_AML_PACKAGE, 0),
/* PROCESSOR */ OP_TABLE_ENTRY (AML_PROCESSOR_OP, 0, NODE_AML_PACKAGE, 0),
/* QWORDCONST */ OP_TABLE_ENTRY (AML_RAW_DATA_QWORD, 0, 0, ACPI_BTYPE_INTEGER),
@@ -323,6 +363,9 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* REFOF */ OP_TABLE_ENTRY (AML_REF_OF_OP, 0, 0, ACPI_BTYPE_REFERENCE),
/* REGIONSPACE_CMOS */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_CMOS, 0, 0),
/* REGIONSPACE_EC */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_EC, 0, 0),
+/* REGIONSPACE_FFIXEDHW */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_FIXED_HARDWARE, 0, 0),
+/* REGIONSPACE_GPIO */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_GPIO, 0, 0),
+/* REGIONSPACE_GSBUS */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_GSBUS, 0, 0),
/* REGIONSPACE_IO */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_SYSTEM_IO, 0, 0),
/* REGIONSPACE_IPMI */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_IPMI, 0, 0),
/* REGIONSPACE_MEM */ OP_TABLE_ENTRY (AML_RAW_DATA_BYTE, ACPI_ADR_SPACE_SYSTEM_MEMORY, 0, 0),
@@ -342,15 +385,24 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* SERIALIZERULE_NOTSERIAL */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* SERIALIZERULE_SERIAL */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* SHARETYPE_EXCLUSIVE */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* SHARETYPE_EXCLUSIVEWAKE */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
/* SHARETYPE_SHARED */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* SHARETYPE_SHAREDWAKE */ OP_TABLE_ENTRY (AML_BYTE_OP, 3, 0, 0),
/* SHIFTLEFT */ OP_TABLE_ENTRY (AML_SHIFT_LEFT_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* SHIFTRIGHT */ OP_TABLE_ENTRY (AML_SHIFT_RIGHT_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* SIGNAL */ OP_TABLE_ENTRY (AML_SIGNAL_OP, 0, 0, 0),
/* SIZEOF */ OP_TABLE_ENTRY (AML_SIZE_OF_OP, 0, 0, ACPI_BTYPE_INTEGER),
+/* SLAVEMODE_CONTROLLERINIT */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* SLAVEMODE_DEVICEINIT */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* SLEEP */ OP_TABLE_ENTRY (AML_SLEEP_OP, 0, 0, 0),
+/* SPISERIALBUS */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* STALL */ OP_TABLE_ENTRY (AML_STALL_OP, 0, 0, 0),
/* STARTDEPENDENTFN */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* STARTDEPENDENTFN_NOPRI */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* STOPBITS_ONE */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* STOPBITS_ONEPLUSHALF */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
+/* STOPBITS_TWO */ OP_TABLE_ENTRY (AML_BYTE_OP, 3, 0, 0),
+/* STOPBITS_ZERO */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* STORE */ OP_TABLE_ENTRY (AML_STORE_OP, 0, 0, ACPI_BTYPE_DATA_REFERENCE),
/* STRING_LITERAL */ OP_TABLE_ENTRY (AML_STRING_OP, 0, 0, ACPI_BTYPE_STRING),
/* SUBTRACT */ OP_TABLE_ENTRY (AML_SUBTRACT_OP, 0, 0, ACPI_BTYPE_INTEGER),
@@ -368,6 +420,7 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* TRANSLATIONTYPE_SPARSE */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* TYPE_STATIC */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* TYPE_TRANSLATION */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
+/* UART_SERIALBUS */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* UNICODE */ OP_TABLE_ENTRY (AML_BUFFER_OP, 0, NODE_AML_PACKAGE, 0),
/* UNLOAD */ OP_TABLE_ENTRY (AML_UNLOAD_OP, 0, 0, 0),
/* UPDATERULE_ONES */ OP_TABLE_ENTRY (AML_BYTE_OP, AML_FIELD_UPDATE_WRITE_AS_ONES, 0, 0),
@@ -378,10 +431,18 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* VENDORSHORT */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* WAIT */ OP_TABLE_ENTRY (AML_WAIT_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* WHILE */ OP_TABLE_ENTRY (AML_WHILE_OP, 0, NODE_AML_PACKAGE, 0),
+/* WIREMODE_FOUR */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* WIREMODE_THREE */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* WORDBUSNUMBER */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* WORDCONST */ OP_TABLE_ENTRY (AML_RAW_DATA_WORD, 0, 0, ACPI_BTYPE_INTEGER),
/* WORDIO */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* WORDSPACE */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* XFERSIZE_8 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* XFERSIZE_16 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* XFERSIZE_32 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* XFERSIZE_64 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* XFERSIZE_128 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
+/* XFERSIZE_256 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* XFERTYPE_8 */ OP_TABLE_ENTRY (AML_BYTE_OP, 0, 0, 0),
/* XFERTYPE_8_16 */ OP_TABLE_ENTRY (AML_BYTE_OP, 1, 0, 0),
/* XFERTYPE_16 */ OP_TABLE_ENTRY (AML_BYTE_OP, 2, 0, 0),
diff --git a/sys/contrib/dev/acpica/compiler/aslmessages.h b/sys/contrib/dev/acpica/compiler/aslmessages.h
index 269c0a4..77a5c02 100644
--- a/sys/contrib/dev/acpica/compiler/aslmessages.h
+++ b/sys/contrib/dev/acpica/compiler/aslmessages.h
@@ -61,17 +61,20 @@
typedef enum
{
ASL_MSG_RESERVED = 0,
+
+ ASL_MSG_ALIGNMENT,
ASL_MSG_ALPHANUMERIC_STRING,
ASL_MSG_AML_NOT_IMPLEMENTED,
ASL_MSG_ARG_COUNT_HI,
ASL_MSG_ARG_COUNT_LO,
ASL_MSG_ARG_INIT,
ASL_MSG_BACKWARDS_OFFSET,
- ASL_MSG_BITS_TO_BYTES,
ASL_MSG_BUFFER_LENGTH,
- ASL_MSG_BYTES_TO_BITS,
ASL_MSG_CLOSE,
ASL_MSG_COMPILER_INTERNAL,
+ ASL_MSG_COMPILER_RESERVED,
+ ASL_MSG_CONNECTION_MISSING,
+ ASL_MSG_CONNECTION_INVALID,
ASL_MSG_CONSTANT_EVALUATION,
ASL_MSG_CONSTANT_FOLDED,
ASL_MSG_CORE_EXCEPTION,
@@ -90,15 +93,26 @@ typedef enum
ASL_MSG_FIELD_ACCESS_WIDTH,
ASL_MSG_FIELD_UNIT_ACCESS_WIDTH,
ASL_MSG_FIELD_UNIT_OFFSET,
+ ASL_MSG_GPE_NAME_CONFLICT,
+ ASL_MSG_HID_LENGTH,
+ ASL_MSG_HID_PREFIX,
+ ASL_MSG_HID_SUFFIX,
ASL_MSG_INCLUDE_FILE_OPEN,
ASL_MSG_INPUT_FILE_OPEN,
ASL_MSG_INTEGER_LENGTH,
ASL_MSG_INTEGER_OPTIMIZATION,
ASL_MSG_INTERRUPT_LIST,
ASL_MSG_INTERRUPT_NUMBER,
+ ASL_MSG_INVALID_ACCESS_SIZE,
+ ASL_MSG_INVALID_ADDR_FLAGS,
ASL_MSG_INVALID_CONSTANT_OP,
ASL_MSG_INVALID_EISAID,
ASL_MSG_INVALID_ESCAPE,
+ ASL_MSG_INVALID_GRAN_FIXED,
+ ASL_MSG_INVALID_GRANULARITY,
+ ASL_MSG_INVALID_LENGTH,
+ ASL_MSG_INVALID_LENGTH_FIXED,
+ ASL_MSG_INVALID_MIN_MAX,
ASL_MSG_INVALID_OPERAND,
ASL_MSG_INVALID_PERFORMANCE,
ASL_MSG_INVALID_PRIORITY,
@@ -107,28 +121,38 @@ typedef enum
ASL_MSG_INVALID_TIME,
ASL_MSG_INVALID_TYPE,
ASL_MSG_INVALID_UUID,
+ ASL_MSG_ISA_ADDRESS,
+ ASL_MSG_LEADING_ASTERISK,
ASL_MSG_LIST_LENGTH_LONG,
ASL_MSG_LIST_LENGTH_SHORT,
ASL_MSG_LISTING_FILE_OPEN,
ASL_MSG_LISTING_FILENAME,
ASL_MSG_LOCAL_INIT,
+ ASL_MSG_LOCAL_OUTSIDE_METHOD,
ASL_MSG_LONG_LINE,
ASL_MSG_MEMORY_ALLOCATION,
ASL_MSG_MISSING_ENDDEPENDENT,
ASL_MSG_MISSING_STARTDEPENDENT,
+ ASL_MSG_MULTIPLE_DEFAULT,
ASL_MSG_MULTIPLE_TYPES,
ASL_MSG_NAME_EXISTS,
ASL_MSG_NAME_OPTIMIZATION,
+ ASL_MSG_NAMED_OBJECT_IN_WHILE,
ASL_MSG_NESTED_COMMENT,
ASL_MSG_NO_CASES,
+ ASL_MSG_NO_REGION,
ASL_MSG_NO_RETVAL,
ASL_MSG_NO_WHILE,
ASL_MSG_NON_ASCII,
+ ASL_MSG_NON_ZERO,
ASL_MSG_NOT_EXIST,
ASL_MSG_NOT_FOUND,
ASL_MSG_NOT_METHOD,
ASL_MSG_NOT_PARAMETER,
ASL_MSG_NOT_REACHABLE,
+ ASL_MSG_NOT_REFERENCED,
+ ASL_MSG_NULL_DESCRIPTOR,
+ ASL_MSG_NULL_STRING,
ASL_MSG_OPEN,
ASL_MSG_OUTPUT_FILE_OPEN,
ASL_MSG_OUTPUT_FILENAME,
@@ -140,6 +164,7 @@ typedef enum
ASL_MSG_RESERVED_ARG_COUNT_HI,
ASL_MSG_RESERVED_ARG_COUNT_LO,
ASL_MSG_RESERVED_METHOD,
+ ASL_MSG_RESERVED_NO_RETURN_VAL,
ASL_MSG_RESERVED_OPERAND_TYPE,
ASL_MSG_RESERVED_RETURN_VALUE,
ASL_MSG_RESERVED_USE,
@@ -148,63 +173,45 @@ typedef enum
ASL_MSG_RESOURCE_INDEX,
ASL_MSG_RESOURCE_LIST,
ASL_MSG_RESOURCE_SOURCE,
+ ASL_MSG_RESULT_NOT_USED,
ASL_MSG_RETURN_TYPES,
ASL_MSG_SCOPE_FWD_REF,
ASL_MSG_SCOPE_TYPE,
ASL_MSG_SEEK,
+ ASL_MSG_SERIALIZED,
ASL_MSG_SINGLE_NAME_OPTIMIZATION,
ASL_MSG_SOME_NO_RETVAL,
+ ASL_MSG_STRING_LENGTH,
ASL_MSG_SWITCH_TYPE,
ASL_MSG_SYNC_LEVEL,
ASL_MSG_SYNTAX,
ASL_MSG_TABLE_SIGNATURE,
+ ASL_MSG_TAG_LARGER,
+ ASL_MSG_TAG_SMALLER,
+ ASL_MSG_TIMEOUT,
ASL_MSG_TOO_MANY_TEMPS,
ASL_MSG_UNKNOWN_RESERVED_NAME,
ASL_MSG_UNREACHABLE_CODE,
ASL_MSG_UNSUPPORTED,
+ ASL_MSG_UPPER_CASE,
ASL_MSG_VENDOR_LIST,
ASL_MSG_WRITE,
- ASL_MSG_MULTIPLE_DEFAULT,
- ASL_MSG_TIMEOUT,
- ASL_MSG_RESULT_NOT_USED,
- ASL_MSG_NOT_REFERENCED,
- ASL_MSG_NON_ZERO,
- ASL_MSG_STRING_LENGTH,
- ASL_MSG_SERIALIZED,
- ASL_MSG_COMPILER_RESERVED,
- ASL_MSG_NAMED_OBJECT_IN_WHILE,
- ASL_MSG_LOCAL_OUTSIDE_METHOD,
- ASL_MSG_ALIGNMENT,
- ASL_MSG_ISA_ADDRESS,
- ASL_MSG_INVALID_MIN_MAX,
- ASL_MSG_INVALID_LENGTH,
- ASL_MSG_INVALID_LENGTH_FIXED,
- ASL_MSG_INVALID_GRANULARITY,
- ASL_MSG_INVALID_GRAN_FIXED,
- ASL_MSG_INVALID_ACCESS_SIZE,
- ASL_MSG_INVALID_ADDR_FLAGS,
- ASL_MSG_NULL_DESCRIPTOR,
- ASL_MSG_UPPER_CASE,
- ASL_MSG_HID_LENGTH,
- ASL_MSG_NULL_STRING,
- ASL_MSG_LEADING_ASTERISK,
- ASL_MSG_RESERVED_NO_RETURN_VAL,
- ASL_MSG_GPE_NAME_CONFLICT,
- ASL_MSG_NO_REGION,
- ASL_MSG_INVALID_FIELD_NAME,
- ASL_MSG_INTEGER_SIZE,
- ASL_MSG_INVALID_HEX_INTEGER,
+/* These messages are used by the data table compiler only */
+
ASL_MSG_BUFFER_ELEMENT,
- ASL_MSG_RESERVED_VALUE,
+ ASL_MSG_DIVIDE_BY_ZERO,
ASL_MSG_FLAG_VALUE,
- ASL_MSG_ZERO_VALUE,
- ASL_MSG_UNKNOWN_TABLE,
- ASL_MSG_UNKNOWN_SUBTABLE,
+ ASL_MSG_INTEGER_SIZE,
+ ASL_MSG_INVALID_EXPRESSION,
+ ASL_MSG_INVALID_FIELD_NAME,
+ ASL_MSG_INVALID_HEX_INTEGER,
ASL_MSG_OEM_TABLE,
+ ASL_MSG_RESERVED_VALUE,
ASL_MSG_UNKNOWN_LABEL,
- ASL_MSG_INVALID_EXPRESSION,
- ASL_MSG_DIVIDE_BY_ZERO
+ ASL_MSG_UNKNOWN_SUBTABLE,
+ ASL_MSG_UNKNOWN_TABLE,
+ ASL_MSG_ZERO_VALUE
} ASL_MESSAGE_IDS;
@@ -215,17 +222,19 @@ typedef enum
char *AslMessages [] = {
/* The zeroth message is reserved */ "",
+/* ASL_MSG_ALIGNMENT */ "Must be a multiple of alignment/granularity value",
/* ASL_MSG_ALPHANUMERIC_STRING */ "String must be entirely alphanumeric",
/* ASL_MSG_AML_NOT_IMPLEMENTED */ "Opcode is not implemented in compiler AML code generator",
/* ASL_MSG_ARG_COUNT_HI */ "Too many arguments",
/* ASL_MSG_ARG_COUNT_LO */ "Too few arguments",
/* ASL_MSG_ARG_INIT */ "Method argument is not initialized",
/* ASL_MSG_BACKWARDS_OFFSET */ "Invalid backwards offset",
-/* ASL_MSG_BITS_TO_BYTES */ "Field offset is in bits, but a byte offset is required",
/* ASL_MSG_BUFFER_LENGTH */ "Effective AML buffer length is zero",
-/* ASL_MSG_BYTES_TO_BITS */ "Field offset is in bytes, but a bit offset is required",
/* ASL_MSG_CLOSE */ "Could not close file",
/* ASL_MSG_COMPILER_INTERNAL */ "Internal compiler error",
+/* ASL_MSG_COMPILER_RESERVED */ "Use of compiler reserved name",
+/* ASL_MSG_CONNECTION_MISSING */ "A Connection operator is required for this field SpaceId",
+/* ASL_MSG_CONNECTION_INVALID */ "Invalid OpRegion SpaceId for use of Connection operator",
/* ASL_MSG_CONSTANT_EVALUATION */ "Could not evaluate constant expression",
/* ASL_MSG_CONSTANT_FOLDED */ "Constant expression evaluated and reduced",
/* ASL_MSG_CORE_EXCEPTION */ "From ACPI CA Subsystem",
@@ -244,15 +253,26 @@ char *AslMessages [] = {
/* ASL_MSG_FIELD_ACCESS_WIDTH */ "Access width is greater than region size",
/* ASL_MSG_FIELD_UNIT_ACCESS_WIDTH */ "Access width of Field Unit extends beyond region limit",
/* ASL_MSG_FIELD_UNIT_OFFSET */ "Field Unit extends beyond region limit",
+/* ASL_MSG_GPE_NAME_CONFLICT */ "Name conflicts with a previous GPE method",
+/* ASL_MSG_HID_LENGTH */ "_HID string must be exactly 7 or 8 characters",
+/* ASL_MSG_HID_PREFIX */ "_HID prefix must be all uppercase or decimal digits",
+/* ASL_MSG_HID_SUFFIX */ "_HID suffix must be all hex digits",
/* ASL_MSG_INCLUDE_FILE_OPEN */ "Could not open include file",
/* ASL_MSG_INPUT_FILE_OPEN */ "Could not open input file",
/* ASL_MSG_INTEGER_LENGTH */ "64-bit integer in 32-bit table, truncating",
/* ASL_MSG_INTEGER_OPTIMIZATION */ "Integer optimized to single-byte AML opcode",
/* ASL_MSG_INTERRUPT_LIST */ "Too many interrupts (16 max)",
/* ASL_MSG_INTERRUPT_NUMBER */ "Invalid interrupt number (must be 0-15)",
+/* ASL_MSG_INVALID_ACCESS_SIZE */ "Invalid AccessSize (Maximum is 4 - QWord access)",
+/* ASL_MSG_INVALID_ADDR_FLAGS */ "Invalid combination of Length and Min/Max fixed flags",
/* ASL_MSG_INVALID_CONSTANT_OP */ "Invalid operator in constant expression (not type 3/4/5)",
/* ASL_MSG_INVALID_EISAID */ "EISAID string must be of the form \"UUUXXXX\" (3 uppercase, 4 hex digits)",
/* ASL_MSG_INVALID_ESCAPE */ "Invalid or unknown escape sequence",
+/* ASL_MSG_INVALID_GRAN_FIXED */ "Granularity must be zero for fixed Min/Max",
+/* ASL_MSG_INVALID_GRANULARITY */ "Granularity must be zero or a power of two minus one",
+/* ASL_MSG_INVALID_LENGTH */ "Length is larger than Min/Max window",
+/* ASL_MSG_INVALID_LENGTH_FIXED */ "Length is not equal to fixed Min/Max window",
+/* ASL_MSG_INVALID_MIN_MAX */ "Address Min is greater than Address Max",
/* ASL_MSG_INVALID_OPERAND */ "Invalid operand",
/* ASL_MSG_INVALID_PERFORMANCE */ "Invalid performance/robustness value",
/* ASL_MSG_INVALID_PRIORITY */ "Invalid priority value",
@@ -261,28 +281,38 @@ char *AslMessages [] = {
/* ASL_MSG_INVALID_TIME */ "Time parameter too long (255 max)",
/* ASL_MSG_INVALID_TYPE */ "Invalid type",
/* ASL_MSG_INVALID_UUID */ "UUID string must be of the form \"aabbccdd-eeff-gghh-iijj-kkllmmnnoopp\"",
+/* ASL_MSG_ISA_ADDRESS */ "Maximum 10-bit ISA address (0x3FF)",
+/* ASL_MSG_LEADING_ASTERISK */ "Invalid leading asterisk",
/* ASL_MSG_LIST_LENGTH_LONG */ "Initializer list longer than declared package length",
/* ASL_MSG_LIST_LENGTH_SHORT */ "Initializer list shorter than declared package length",
/* ASL_MSG_LISTING_FILE_OPEN */ "Could not open listing file",
/* ASL_MSG_LISTING_FILENAME */ "Could not create listing filename",
/* ASL_MSG_LOCAL_INIT */ "Method local variable is not initialized",
+/* ASL_MSG_LOCAL_OUTSIDE_METHOD */ "Local or Arg used outside a control method",
/* ASL_MSG_LONG_LINE */ "Splitting long input line",
/* ASL_MSG_MEMORY_ALLOCATION */ "Memory allocation failure",
/* ASL_MSG_MISSING_ENDDEPENDENT */ "Missing EndDependentFn() macro in dependent resource list",
/* ASL_MSG_MISSING_STARTDEPENDENT */ "Missing StartDependentFn() macro in dependent resource list",
+/* ASL_MSG_MULTIPLE_DEFAULT */ "More than one Default statement within Switch construct",
/* ASL_MSG_MULTIPLE_TYPES */ "Multiple types",
/* ASL_MSG_NAME_EXISTS */ "Name already exists in scope",
/* ASL_MSG_NAME_OPTIMIZATION */ "NamePath optimized",
+/* ASL_MSG_NAMED_OBJECT_IN_WHILE */ "Creating a named object in a While loop",
/* ASL_MSG_NESTED_COMMENT */ "Nested comment found",
/* ASL_MSG_NO_CASES */ "No Case statements under Switch",
+/* ASL_MSG_NO_REGION */ "_REG has no corresponding Operation Region",
/* ASL_MSG_NO_RETVAL */ "Called method returns no value",
/* ASL_MSG_NO_WHILE */ "No enclosing While statement",
/* ASL_MSG_NON_ASCII */ "Invalid characters found in file",
+/* ASL_MSG_NON_ZERO */ "Operand evaluates to zero",
/* ASL_MSG_NOT_EXIST */ "Object does not exist",
/* ASL_MSG_NOT_FOUND */ "Object not found or not accessible from scope",
/* ASL_MSG_NOT_METHOD */ "Not a control method, cannot invoke",
/* ASL_MSG_NOT_PARAMETER */ "Not a parameter, used as local only",
/* ASL_MSG_NOT_REACHABLE */ "Object is not accessible from this scope",
+/* ASL_MSG_NOT_REFERENCED */ "Namespace object is not referenced",
+/* ASL_MSG_NULL_DESCRIPTOR */ "Min/Max/Length/Gran are all zero, but no resource tag",
+/* ASL_MSG_NULL_STRING */ "Invalid zero-length (null) string",
/* ASL_MSG_OPEN */ "Could not open file",
/* ASL_MSG_OUTPUT_FILE_OPEN */ "Could not open output AML file",
/* ASL_MSG_OUTPUT_FILENAME */ "Could not create output filename",
@@ -294,6 +324,7 @@ char *AslMessages [] = {
/* ASL_MSG_RESERVED_ARG_COUNT_HI */ "Reserved method has too many arguments",
/* ASL_MSG_RESERVED_ARG_COUNT_LO */ "Reserved method has too few arguments",
/* ASL_MSG_RESERVED_METHOD */ "Reserved name must be a control method",
+/* ASL_MSG_RESERVED_NO_RETURN_VAL */ "Reserved method should not return a value",
/* ASL_MSG_RESERVED_OPERAND_TYPE */ "Invalid object type for reserved name",
/* ASL_MSG_RESERVED_RETURN_VALUE */ "Reserved method must return a value",
/* ASL_MSG_RESERVED_USE */ "Invalid use of reserved name",
@@ -302,65 +333,45 @@ char *AslMessages [] = {
/* ASL_MSG_RESOURCE_INDEX */ "Missing ResourceSourceIndex (required)",
/* ASL_MSG_RESOURCE_LIST */ "Too many resource items (internal error)",
/* ASL_MSG_RESOURCE_SOURCE */ "Missing ResourceSource string (required)",
+/* ASL_MSG_RESULT_NOT_USED */ "Result is not used, operator has no effect",
/* ASL_MSG_RETURN_TYPES */ "Not all control paths return a value",
/* ASL_MSG_SCOPE_FWD_REF */ "Forward references from Scope operator not allowed",
/* ASL_MSG_SCOPE_TYPE */ "Existing object has invalid type for Scope operator",
/* ASL_MSG_SEEK */ "Could not seek file",
+/* ASL_MSG_SERIALIZED */ "Control Method marked Serialized",
/* ASL_MSG_SINGLE_NAME_OPTIMIZATION */ "NamePath optimized to NameSeg (uses run-time search path)",
/* ASL_MSG_SOME_NO_RETVAL */ "Called method may not always return a value",
+/* ASL_MSG_STRING_LENGTH */ "String literal too long",
/* ASL_MSG_SWITCH_TYPE */ "Switch expression is not a static Integer/Buffer/String data type, defaulting to Integer",
/* ASL_MSG_SYNC_LEVEL */ "SyncLevel must be in the range 0-15",
/* ASL_MSG_SYNTAX */ "",
/* ASL_MSG_TABLE_SIGNATURE */ "Invalid Table Signature",
+/* ASL_MSG_TAG_LARGER */ "ResourceTag larger than Field",
+/* ASL_MSG_TAG_SMALLER */ "ResourceTag smaller than Field",
+/* ASL_MSG_TIMEOUT */ "Result is not used, possible operator timeout will be missed",
/* ASL_MSG_TOO_MANY_TEMPS */ "Method requires too many temporary variables (_T_x)",
/* ASL_MSG_UNKNOWN_RESERVED_NAME */ "Unknown reserved name",
/* ASL_MSG_UNREACHABLE_CODE */ "Statement is unreachable",
/* ASL_MSG_UNSUPPORTED */ "Unsupported feature",
+/* ASL_MSG_UPPER_CASE */ "Non-hex letters must be upper case",
/* ASL_MSG_VENDOR_LIST */ "Too many vendor data bytes (7 max)",
/* ASL_MSG_WRITE */ "Could not write file",
-/* ASL_MSG_MULTIPLE_DEFAULT */ "More than one Default statement within Switch construct",
-/* ASL_MSG_TIMEOUT */ "Result is not used, possible operator timeout will be missed",
-/* ASL_MSG_RESULT_NOT_USED */ "Result is not used, operator has no effect",
-/* ASL_MSG_NOT_REFERENCED */ "Namespace object is not referenced",
-/* ASL_MSG_NON_ZERO */ "Operand evaluates to zero",
-/* ASL_MSG_STRING_LENGTH */ "String literal too long",
-/* ASL_MSG_SERIALIZED */ "Control Method marked Serialized",
-/* ASL_MSG_COMPILER_RESERVED */ "Use of compiler reserved name",
-/* ASL_MSG_NAMED_OBJECT_IN_WHILE */ "Creating a named object in a While loop",
-/* ASL_MSG_LOCAL_OUTSIDE_METHOD */ "Local or Arg used outside a control method",
-/* ASL_MSG_ALIGNMENT */ "Must be a multiple of alignment/granularity value",
-/* ASL_MSG_ISA_ADDRESS */ "Maximum 10-bit ISA address (0x3FF)",
-/* ASL_MSG_INVALID_MIN_MAX */ "Address Min is greater than Address Max",
-/* ASL_MSG_INVALID_LENGTH */ "Length is larger than Min/Max window",
-/* ASL_MSG_INVALID_LENGTH_FIXED */ "Length is not equal to fixed Min/Max window",
-/* ASL_MSG_INVALID_GRANULARITY */ "Granularity must be zero or a power of two minus one",
-/* ASL_MSG_INVALID_GRAN_FIXED */ "Granularity must be zero for fixed Min/Max",
-/* ASL_MSG_INVALID_ACCESS_SIZE */ "Invalid AccessSize (Maximum is 4 - QWord access)",
-/* ASL_MSG_INVALID_ADDR_FLAGS */ "Invalid combination of Length and Min/Max fixed flags",
-/* ASL_MSG_NULL_DESCRIPTOR */ "Min/Max/Length/Gran are all zero, but no resource tag",
-/* ASL_MSG_UPPER_CASE */ "Non-hex letters must be upper case",
-/* ASL_MSG_HID_LENGTH */ "_HID string must be exactly 7 or 8 characters",
-/* ASL_MSG_NULL_STRING */ "Invalid zero-length (null) string",
-/* ASL_MSG_LEADING_ASTERISK */ "Invalid leading asterisk",
-/* ASL_MSG_RESERVED_NO_RETURN_VAL */ "Reserved method should not return a value",
-/* ASL_MSG_GPE_NAME_CONFLICT */ "Name conflicts with a previous GPE method",
-/* ASL_MSG_NO_REGION */ "_REG has no corresponding Operation Region",
/* These messages are used by the data table compiler only */
-/* ASL_MSG_INVALID_FIELD_NAME */ "Invalid Field Name",
-/* ASL_MSG_INTEGER_SIZE */ "Integer too large for target",
-/* ASL_MSG_INVALID_HEX_INTEGER */ "Invalid hex integer constant",
/* ASL_MSG_BUFFER_ELEMENT */ "Invalid element in buffer initializer list",
-/* ASL_MSG_RESERVED_VALUE */ "Reserved field must be zero",
+/* ASL_MSG_DIVIDE_BY_ZERO */ "Expression contains divide-by-zero",
/* ASL_MSG_FLAG_VALUE */ "Flag value is too large",
-/* ASL_MSG_ZERO_VALUE */ "Value must be non-zero",
-/* ASL_MSG_UNKNOWN_TABLE */ "Unknown ACPI table signature",
-/* ASL_MSG_UNKNOWN_SUBTABLE */ "Unknown subtable type",
+/* ASL_MSG_INTEGER_SIZE */ "Integer too large for target",
+/* ASL_MSG_INVALID_EXPRESSION */ "Invalid expression",
+/* ASL_MSG_INVALID_FIELD_NAME */ "Invalid Field Name",
+/* ASL_MSG_INVALID_HEX_INTEGER */ "Invalid hex integer constant",
/* ASL_MSG_OEM_TABLE */ "OEM table - unknown contents",
+/* ASL_MSG_RESERVED_VALUE */ "Reserved field must be zero",
/* ASL_MSG_UNKNOWN_LABEL */ "Label is undefined",
-/* ASL_MSG_INVALID_EXPRESSION */ "Invalid expression",
-/* ASL_MSG_DIVIDE_BY_ZERO */ "Expression contains divide-by-zero"
+/* ASL_MSG_UNKNOWN_SUBTABLE */ "Unknown subtable type",
+/* ASL_MSG_UNKNOWN_TABLE */ "Unknown ACPI table signature",
+/* ASL_MSG_ZERO_VALUE */ "Value must be non-zero"
};
diff --git a/sys/contrib/dev/acpica/compiler/aslopcodes.c b/sys/contrib/dev/acpica/compiler/aslopcodes.c
index dfe87ea..7852720 100644
--- a/sys/contrib/dev/acpica/compiler/aslopcodes.c
+++ b/sys/contrib/dev/acpica/compiler/aslopcodes.c
@@ -58,6 +58,10 @@ OpcDoAccessAs (
ACPI_PARSE_OBJECT *Op);
static void
+OpcDoConnection (
+ ACPI_PARSE_OBJECT *Op);
+
+static void
OpcDoUnicode (
ACPI_PARSE_OBJECT *Op);
@@ -321,26 +325,128 @@ static void
OpcDoAccessAs (
ACPI_PARSE_OBJECT *Op)
{
- ACPI_PARSE_OBJECT *Next;
+ ACPI_PARSE_OBJECT *TypeOp;
+ ACPI_PARSE_OBJECT *AttribOp;
+ ACPI_PARSE_OBJECT *LengthOp;
+ UINT8 Attribute;
Op->Asl.AmlOpcodeLength = 1;
- Next = Op->Asl.Child;
+ TypeOp = Op->Asl.Child;
/* First child is the access type */
- Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
- Next->Asl.ParseOpcode = PARSEOP_RAW_DATA;
+ TypeOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
+ TypeOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
/* Second child is the optional access attribute */
- Next = Next->Asl.Next;
- if (Next->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+ AttribOp = TypeOp->Asl.Next;
+ if (AttribOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+ {
+ AttribOp->Asl.Value.Integer = 0;
+ }
+ AttribOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
+ AttribOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
+
+ /* Only a few AccessAttributes support AccessLength */
+
+ Attribute = (UINT8) AttribOp->Asl.Value.Integer;
+ if ((Attribute != AML_FIELD_ATTRIB_MULTIBYTE) &&
+ (Attribute != AML_FIELD_ATTRIB_RAW_BYTES) &&
+ (Attribute != AML_FIELD_ATTRIB_RAW_PROCESS))
+ {
+ return;
+ }
+
+ Op->Asl.AmlOpcode = AML_FIELD_EXT_ACCESS_OP;
+
+ /*
+ * Child of Attributes is the AccessLength (required for Multibyte,
+ * RawBytes, RawProcess.)
+ */
+ LengthOp = AttribOp->Asl.Child;
+ if (!LengthOp)
+ {
+ return;
+ }
+
+ /* TBD: probably can remove */
+
+ if (LengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+ {
+ LengthOp->Asl.Value.Integer = 16;
+ }
+
+ LengthOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
+ LengthOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: OpcDoConnection
+ *
+ * PARAMETERS: Op - Parse node
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Implement the Connection ASL keyword.
+ *
+ ******************************************************************************/
+
+static void
+OpcDoConnection (
+ ACPI_PARSE_OBJECT *Op)
+{
+ ASL_RESOURCE_NODE *Rnode;
+ ACPI_PARSE_OBJECT *BufferOp;
+ ACPI_PARSE_OBJECT *BufferLengthOp;
+ ACPI_PARSE_OBJECT *BufferDataOp;
+ 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;
+
+ State = ACPI_RSTATE_NORMAL;
+ Rnode = RsDoOneResourceDescriptor (BufferDataOp->Asl.Next, 0, &State);
+ if (!Rnode)
{
- Next->Asl.Value.Integer = 0;
+ return; /* error */
}
- Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
- Next->Asl.ParseOpcode = PARSEOP_RAW_DATA;
+
+ /*
+ * 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);
}
@@ -545,7 +651,7 @@ OpcDoEisaId (
/*******************************************************************************
*
- * FUNCTION: OpcDoUiId
+ * FUNCTION: OpcDoUuId
*
* PARAMETERS: Op - Parse node
*
@@ -665,6 +771,11 @@ OpcGenerateAmlOpcode (
OpcDoAccessAs (Op);
break;
+ case PARSEOP_CONNECTION:
+
+ OpcDoConnection (Op);
+ break;
+
case PARSEOP_EISAID:
OpcDoEisaId (Op);
diff --git a/sys/contrib/dev/acpica/compiler/asloperands.c b/sys/contrib/dev/acpica/compiler/asloperands.c
index 81fdbfa..9ce7b31 100644
--- a/sys/contrib/dev/acpica/compiler/asloperands.c
+++ b/sys/contrib/dev/acpica/compiler/asloperands.c
@@ -761,6 +761,7 @@ OpnDoPackage (
if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) ||
(PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST) ||
+ (PackageLengthOp->Asl.ParseOpcode == PARSEOP_ZERO) ||
(PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG))
{
if (!PackageLength)
@@ -778,8 +779,11 @@ OpnDoPackage (
* 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))
+ 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;
diff --git a/sys/contrib/dev/acpica/compiler/aslpredef.c b/sys/contrib/dev/acpica/compiler/aslpredef.c
index 0743d91..d67fcac 100644
--- a/sys/contrib/dev/acpica/compiler/aslpredef.c
+++ b/sys/contrib/dev/acpica/compiler/aslpredef.c
@@ -100,30 +100,49 @@ static const ACPI_PREDEFINED_INFO ResourceNames[] = {
{{"_ATT", 0, 0}},
{{"_BAS", 0, 0}},
{{"_BM_", 0, 0}},
+ {{"_DBT", 0, 0}}, /* Acpi 5.0 */
{{"_DEC", 0, 0}},
+ {{"_DPL", 0, 0}}, /* Acpi 5.0 */
+ {{"_DRS", 0, 0}}, /* Acpi 5.0 */
+ {{"_END", 0, 0}}, /* Acpi 5.0 */
+ {{"_FLC", 0, 0}}, /* Acpi 5.0 */
{{"_GRA", 0, 0}},
{{"_HE_", 0, 0}},
{{"_INT", 0, 0}},
+ {{"_IOR", 0, 0}}, /* Acpi 5.0 */
{{"_LEN", 0, 0}},
+ {{"_LIN", 0, 0}}, /* Acpi 5.0 */
{{"_LL_", 0, 0}},
{{"_MAF", 0, 0}},
{{"_MAX", 0, 0}},
{{"_MEM", 0, 0}},
{{"_MIF", 0, 0}},
{{"_MIN", 0, 0}},
+ {{"_MOD", 0, 0}}, /* Acpi 5.0 */
{{"_MTP", 0, 0}},
+ {{"_PAR", 0, 0}}, /* Acpi 5.0 */
+ {{"_PHA", 0, 0}}, /* Acpi 5.0 */
+ {{"_PIN", 0, 0}}, /* Acpi 5.0 */
+ {{"_PPI", 0, 0}}, /* Acpi 5.0 */
+ {{"_POL", 0, 0}}, /* Acpi 5.0 */
{{"_RBO", 0, 0}},
{{"_RBW", 0, 0}},
{{"_RNG", 0, 0}},
{{"_RT_", 0, 0}}, /* Acpi 3.0 */
{{"_RW_", 0, 0}},
+ {{"_RXL", 0, 0}}, /* Acpi 5.0 */
{{"_SHR", 0, 0}},
{{"_SIZ", 0, 0}},
+ {{"_SLV", 0, 0}}, /* Acpi 5.0 */
+ {{"_SPE", 0, 0}}, /* Acpi 5.0 */
+ {{"_STB", 0, 0}}, /* Acpi 5.0 */
{{"_TRA", 0, 0}},
{{"_TRS", 0, 0}},
{{"_TSF", 0, 0}}, /* Acpi 3.0 */
{{"_TTP", 0, 0}},
+ {{"_TXL", 0, 0}}, /* Acpi 5.0 */
{{"_TYP", 0, 0}},
+ {{"_VEN", 0, 0}}, /* Acpi 5.0 */
{{{0,0,0,0}, 0, 0}} /* Table terminator */
};
@@ -658,6 +677,7 @@ ApCheckObjectType (
break;
case PARSEOP_PACKAGE:
+ case PARSEOP_VAR_PACKAGE:
ReturnBtype = ACPI_RTYPE_PACKAGE;
break;
@@ -817,4 +837,3 @@ ApGetExpectedTypes (
ThisRtype <<= 1; /* Next Rtype */
}
}
-
diff --git a/sys/contrib/dev/acpica/compiler/aslresource.c b/sys/contrib/dev/acpica/compiler/aslresource.c
index e77a265..cec0c97 100644
--- a/sys/contrib/dev/acpica/compiler/aslresource.c
+++ b/sys/contrib/dev/acpica/compiler/aslresource.c
@@ -437,13 +437,14 @@ RsAllocateResourceNode (
/*******************************************************************************
*
- * FUNCTION: RsCreateBitField
+ * FUNCTION: RsCreateResourceField
*
* PARAMETERS: Op - Resource field node
* Name - Name of the field (Used only to reference
* the field in the ASL, not in the AML)
* ByteOffset - Offset from the field start
* BitOffset - Additional bit offset
+ * BitLength - Number of bits in the field
*
* RETURN: None, sets fields within the input node
*
@@ -454,46 +455,20 @@ RsAllocateResourceNode (
******************************************************************************/
void
-RsCreateBitField (
+RsCreateResourceField (
ACPI_PARSE_OBJECT *Op,
char *Name,
UINT32 ByteOffset,
- UINT32 BitOffset)
+ UINT32 BitOffset,
+ UINT32 BitLength)
{
- Op->Asl.ExternalName = Name;
- Op->Asl.Value.Integer = ((UINT64) ByteOffset * 8) + BitOffset;
- Op->Asl.CompileFlags |= (NODE_IS_RESOURCE_FIELD | NODE_IS_BIT_OFFSET);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION: RsCreateByteField
- *
- * PARAMETERS: Op - Resource field node
- * Name - Name of the field (Used only to reference
- * the field in the ASL, not in the AML)
- * ByteOffset - Offset from the field start
- *
- * RETURN: None, sets fields within the input node
- *
- * DESCRIPTION: Utility function to generate a named byte field within a
- * resource descriptor. Mark a node as 1) a field in a resource
- * descriptor, and 2) set the value to be a BYTE offset
- *
- ******************************************************************************/
+ Op->Asl.ExternalName = Name;
+ Op->Asl.CompileFlags |= NODE_IS_RESOURCE_FIELD;
-void
-RsCreateByteField (
- ACPI_PARSE_OBJECT *Op,
- char *Name,
- UINT32 ByteOffset)
-{
- Op->Asl.ExternalName = Name;
- Op->Asl.Value.Integer = ByteOffset;
- Op->Asl.CompileFlags |= NODE_IS_RESOURCE_FIELD;
+ Op->Asl.Value.Tag.BitOffset = (ByteOffset * 8) + BitOffset;
+ Op->Asl.Value.Tag.BitLength = BitLength;
}
@@ -538,6 +513,29 @@ RsSetFlagBits (
}
+void
+RsSetFlagBits16 (
+ UINT16 *Flags,
+ ACPI_PARSE_OBJECT *Op,
+ UINT8 Position,
+ UINT8 DefaultBit)
+{
+
+ if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+ {
+ /* Use the default bit */
+
+ *Flags |= (DefaultBit << Position);
+ }
+ else
+ {
+ /* Use the bit specified in the initialization node */
+
+ *Flags |= (((UINT16) Op->Asl.Value.Integer) << Position);
+ }
+}
+
+
/*******************************************************************************
*
* FUNCTION: RsCompleteNodeAndGetNext
@@ -662,6 +660,11 @@ RsDoOneResourceDescriptor (
CurrentByteOffset);
break;
+ case PARSEOP_FIXEDDMA:
+ Rnode = RsDoFixedDmaDescriptor (DescriptorTypeOp,
+ CurrentByteOffset);
+ break;
+
case PARSEOP_DWORDIO:
Rnode = RsDoDwordIoDescriptor (DescriptorTypeOp,
CurrentByteOffset);
@@ -845,6 +848,31 @@ RsDoOneResourceDescriptor (
CurrentByteOffset);
break;
+ case PARSEOP_GPIO_INT:
+ Rnode = RsDoGpioIntDescriptor (DescriptorTypeOp,
+ CurrentByteOffset);
+ break;
+
+ case PARSEOP_GPIO_IO:
+ Rnode = RsDoGpioIoDescriptor (DescriptorTypeOp,
+ CurrentByteOffset);
+ break;
+
+ case PARSEOP_I2C_SERIALBUS:
+ Rnode = RsDoI2cSerialBusDescriptor (DescriptorTypeOp,
+ CurrentByteOffset);
+ break;
+
+ case PARSEOP_SPI_SERIALBUS:
+ Rnode = RsDoSpiSerialBusDescriptor (DescriptorTypeOp,
+ CurrentByteOffset);
+ break;
+
+ case PARSEOP_UART_SERIALBUS:
+ Rnode = RsDoUartSerialBusDescriptor (DescriptorTypeOp,
+ CurrentByteOffset);
+ break;
+
case PARSEOP_DEFAULT_ARG:
/* Just ignore any of these, they are used as fillers/placeholders */
break;
@@ -1019,10 +1047,12 @@ RsDoResourceTemplate (
Op->Asl.ParseOpcode = PARSEOP_BUFFER;
Op->Asl.AmlOpcode = AML_BUFFER_OP;
Op->Asl.CompileFlags = NODE_AML_PACKAGE | NODE_IS_RESOURCE_DESC;
+ UtSetParseOpName (Op);
BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
BufferLengthOp->Asl.Value.Integer = CurrentByteOffset;
(void) OpcSetOptimalIntegerSize (BufferLengthOp);
+ UtSetParseOpName (BufferLengthOp);
BufferOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
BufferOp->Asl.AmlOpcode = AML_RAW_DATA_CHAIN;
@@ -1030,8 +1060,7 @@ RsDoResourceTemplate (
BufferOp->Asl.AmlLength = CurrentByteOffset;
BufferOp->Asl.Value.Buffer = (UINT8 *) HeadRnode.Next;
BufferOp->Asl.CompileFlags |= NODE_IS_RESOURCE_DATA;
+ UtSetParseOpName (BufferOp);
return;
}
-
-
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype1.c b/sys/contrib/dev/acpica/compiler/aslrestype1.c
index 17a248e..7f34a37 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype1.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype1.c
@@ -179,7 +179,7 @@ RsDoMemory24Descriptor (
case 1: /* Min Address */
Descriptor->Memory24.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum));
MinOp = InitializerOp;
break;
@@ -187,7 +187,7 @@ RsDoMemory24Descriptor (
case 2: /* Max Address */
Descriptor->Memory24.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum));
MaxOp = InitializerOp;
break;
@@ -195,14 +195,14 @@ RsDoMemory24Descriptor (
case 3: /* Alignment */
Descriptor->Memory24.Alignment = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment));
break;
case 4: /* Length */
Descriptor->Memory24.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength));
LengthOp = InitializerOp;
break;
@@ -286,7 +286,7 @@ RsDoMemory32Descriptor (
case 1: /* Min Address */
Descriptor->Memory32.Minimum = (UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum));
MinOp = InitializerOp;
break;
@@ -294,7 +294,7 @@ RsDoMemory32Descriptor (
case 2: /* Max Address */
Descriptor->Memory32.Maximum = (UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum));
MaxOp = InitializerOp;
break;
@@ -302,7 +302,7 @@ RsDoMemory32Descriptor (
case 3: /* Alignment */
Descriptor->Memory32.Alignment = (UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment));
AlignOp = InitializerOp;
break;
@@ -310,7 +310,7 @@ RsDoMemory32Descriptor (
case 4: /* Length */
Descriptor->Memory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength));
LengthOp = InitializerOp;
break;
@@ -390,14 +390,14 @@ RsDoMemory32FixedDescriptor (
case 1: /* Address */
Descriptor->FixedMemory32.Address = (UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address));
break;
case 2: /* Length */
Descriptor->FixedMemory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength));
break;
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype1i.c b/sys/contrib/dev/acpica/compiler/aslrestype1i.c
index 062ba23..e4462f4 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype1i.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype1i.c
@@ -53,6 +53,7 @@
* This module contains the I/O-related small resource descriptors:
*
* DMA
+ * FixedDMA
* FixedIO
* IO
* IRQ
@@ -102,8 +103,8 @@ RsDoDmaDescriptor (
case 0: /* DMA type */
RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 5, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_DMATYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 5);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_DMATYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 5, 2);
break;
case 1: /* Bus Master */
@@ -116,8 +117,8 @@ RsDoDmaDescriptor (
case 2: /* Xfer Type (transfer width) */
RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 0, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_XFERTYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_XFERTYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 0, 2);
break;
case 3: /* Name */
@@ -182,6 +183,81 @@ RsDoDmaDescriptor (
/*******************************************************************************
*
+ * FUNCTION: RsDoFixedDmaDescriptor
+ *
+ * PARAMETERS: Op - Parent resource descriptor parse node
+ * CurrentByteOffset - Offset into the resource template AML
+ * buffer (to track references to the desc)
+ *
+ * RETURN: Completed resource node
+ *
+ * DESCRIPTION: Construct a short "FixedDMA" descriptor
+ *
+ ******************************************************************************/
+
+ASL_RESOURCE_NODE *
+RsDoFixedDmaDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset)
+{
+ AML_RESOURCE *Descriptor;
+ ACPI_PARSE_OBJECT *InitializerOp;
+ ASL_RESOURCE_NODE *Rnode;
+ UINT32 i;
+
+
+ InitializerOp = Op->Asl.Child;
+ Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_FIXED_DMA));
+
+ Descriptor = Rnode->Buffer;
+ Descriptor->FixedDma.DescriptorType =
+ ACPI_RESOURCE_NAME_FIXED_DMA | ASL_RDESC_FIXED_DMA_SIZE;
+
+ /* Process all child initialization nodes */
+
+ for (i = 0; InitializerOp; i++)
+ {
+ switch (i)
+ {
+ case 0: /* DMA Request Lines [WORD] (_DMA) */
+
+ Descriptor->FixedDma.RequestLines = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_DMA,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.RequestLines));
+ break;
+
+ case 1: /* DMA Channel [WORD] (_TYP) */
+
+ Descriptor->FixedDma.Channels = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_DMATYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.Channels));
+ break;
+
+ case 2: /* Transfer Width [BYTE] (_SIZ) */
+
+ Descriptor->FixedDma.Width = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_XFERTYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.Width));
+ break;
+
+ case 3: /* Descriptor Name (optional) */
+
+ UtAttachNamepathToOwner (Op, InitializerOp);
+ break;
+
+ default: /* Ignore any extra nodes */
+ break;
+ }
+
+ InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
+ }
+
+ return (Rnode);
+}
+
+
+/*******************************************************************************
+ *
* FUNCTION: RsDoFixedIoDescriptor
*
* PARAMETERS: Op - Parent resource descriptor parse node
@@ -223,7 +299,7 @@ RsDoFixedIoDescriptor (
Descriptor->FixedIo.Address =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.Address));
AddressOp = InitializerOp;
break;
@@ -314,7 +390,7 @@ RsDoIoDescriptor (
Descriptor->Io.Minimum =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Minimum));
MinOp = InitializerOp;
break;
@@ -323,7 +399,7 @@ RsDoIoDescriptor (
Descriptor->Io.Maximum =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Maximum));
MaxOp = InitializerOp;
break;
@@ -480,7 +556,7 @@ RsDoIrqDescriptor (
/* Create a named field at the start of the list */
- RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_INTERRUPT,
CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask));
}
break;
@@ -580,7 +656,7 @@ RsDoIrqNoFlagsDescriptor (
/* Create a named field at the start of the list */
- RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_INTERRUPT,
CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask));
}
break;
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype2.c b/sys/contrib/dev/acpica/compiler/aslrestype2.c
index 9b7f3dc..5499196 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype2.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype2.c
@@ -1,4 +1,3 @@
-
/******************************************************************************
*
* Module Name: aslrestype2 - Miscellaneous Large resource descriptors
@@ -120,7 +119,7 @@ RsDoGeneralRegisterDescriptor (
case 3: /* Register Address */
Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESS,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_ADDRESS,
CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address));
break;
@@ -354,7 +353,7 @@ RsDoInterruptDescriptor (
/* Create a named field at the start of the list */
- RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_INTERRUPT,
CurrentByteOffset +
ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]));
}
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype2d.c b/sys/contrib/dev/acpica/compiler/aslrestype2d.c
index 485c84a..1a9ec48 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype2d.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype2d.c
@@ -144,15 +144,15 @@ RsDoDwordIoDescriptor (
case 4: /* Range Type */
RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0, 2);
break;
case 5: /* Address Granularity */
Descriptor->Address32.Granularity =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
GranOp = InitializerOp;
break;
@@ -161,7 +161,7 @@ RsDoDwordIoDescriptor (
Descriptor->Address32.Minimum =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
MinOp = InitializerOp;
break;
@@ -170,7 +170,7 @@ RsDoDwordIoDescriptor (
Descriptor->Address32.Maximum =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
MaxOp = InitializerOp;
break;
@@ -179,7 +179,7 @@ RsDoDwordIoDescriptor (
Descriptor->Address32.TranslationOffset =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
break;
@@ -187,7 +187,7 @@ RsDoDwordIoDescriptor (
Descriptor->Address32.AddressLength =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
LengthOp = InitializerOp;
break;
@@ -376,8 +376,8 @@ RsDoDwordMemoryDescriptor (
case 4: /* Memory Type */
RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1, 2);
break;
case 5: /* Read/Write Type */
@@ -391,7 +391,7 @@ RsDoDwordMemoryDescriptor (
Descriptor->Address32.Granularity =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
GranOp = InitializerOp;
break;
@@ -400,7 +400,7 @@ RsDoDwordMemoryDescriptor (
Descriptor->Address32.Minimum =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
MinOp = InitializerOp;
break;
@@ -409,7 +409,7 @@ RsDoDwordMemoryDescriptor (
Descriptor->Address32.Maximum =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
MaxOp = InitializerOp;
break;
@@ -418,7 +418,7 @@ RsDoDwordMemoryDescriptor (
Descriptor->Address32.TranslationOffset =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
break;
@@ -426,7 +426,7 @@ RsDoDwordMemoryDescriptor (
Descriptor->Address32.AddressLength =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
LengthOp = InitializerOp;
break;
@@ -488,8 +488,8 @@ RsDoDwordMemoryDescriptor (
case 14: /* Address Range */
RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3, 2);
break;
case 15: /* Type */
@@ -623,7 +623,7 @@ RsDoDwordSpaceDescriptor (
Descriptor->Address32.Granularity =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
GranOp = InitializerOp;
break;
@@ -632,7 +632,7 @@ RsDoDwordSpaceDescriptor (
Descriptor->Address32.Minimum =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
MinOp = InitializerOp;
break;
@@ -641,7 +641,7 @@ RsDoDwordSpaceDescriptor (
Descriptor->Address32.Maximum =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
MaxOp = InitializerOp;
break;
@@ -650,7 +650,7 @@ RsDoDwordSpaceDescriptor (
Descriptor->Address32.TranslationOffset =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
break;
@@ -658,7 +658,7 @@ RsDoDwordSpaceDescriptor (
Descriptor->Address32.AddressLength =
(UINT32) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
LengthOp = InitializerOp;
break;
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype2e.c b/sys/contrib/dev/acpica/compiler/aslrestype2e.c
index 06251b0..c60a8ea 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype2e.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype2e.c
@@ -136,14 +136,14 @@ RsDoExtendedIoDescriptor (
case 4: /* Range Type */
RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0, 2);
break;
case 5: /* Address Granularity */
Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
GranOp = InitializerOp;
break;
@@ -151,7 +151,7 @@ RsDoExtendedIoDescriptor (
case 6: /* Address Min */
Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
MinOp = InitializerOp;
break;
@@ -159,7 +159,7 @@ RsDoExtendedIoDescriptor (
case 7: /* Address Max */
Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
MaxOp = InitializerOp;
break;
@@ -167,14 +167,14 @@ RsDoExtendedIoDescriptor (
case 8: /* Translation Offset */
Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
break;
case 9: /* Address Length */
Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
LengthOp = InitializerOp;
break;
@@ -182,7 +182,7 @@ RsDoExtendedIoDescriptor (
case 10: /* Type-Specific Attributes */
Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
break;
@@ -309,8 +309,8 @@ RsDoExtendedMemoryDescriptor (
case 4: /* Memory Type */
RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
break;
case 5: /* Read/Write Type */
@@ -323,7 +323,7 @@ RsDoExtendedMemoryDescriptor (
case 6: /* Address Granularity */
Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
GranOp = InitializerOp;
break;
@@ -331,7 +331,7 @@ RsDoExtendedMemoryDescriptor (
case 7: /* Min Address */
Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
MinOp = InitializerOp;
break;
@@ -339,7 +339,7 @@ RsDoExtendedMemoryDescriptor (
case 8: /* Max Address */
Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
MaxOp = InitializerOp;
break;
@@ -347,14 +347,14 @@ RsDoExtendedMemoryDescriptor (
case 9: /* Translation Offset */
Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
break;
case 10: /* Address Length */
Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
LengthOp = InitializerOp;
break;
@@ -362,7 +362,7 @@ RsDoExtendedMemoryDescriptor (
case 11: /* Type-Specific Attributes */
Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
break;
@@ -375,8 +375,8 @@ RsDoExtendedMemoryDescriptor (
case 13: /* Address Range */
RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
- CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
break;
case 14: /* Type */
@@ -501,7 +501,7 @@ RsDoExtendedSpaceDescriptor (
case 6: /* Address Granularity */
Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
GranOp = InitializerOp;
break;
@@ -509,7 +509,7 @@ RsDoExtendedSpaceDescriptor (
case 7: /* Min Address */
Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
MinOp = InitializerOp;
break;
@@ -517,7 +517,7 @@ RsDoExtendedSpaceDescriptor (
case 8: /* Max Address */
Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
MaxOp = InitializerOp;
break;
@@ -525,14 +525,14 @@ RsDoExtendedSpaceDescriptor (
case 9: /* Translation Offset */
Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
break;
case 10: /* Address Length */
Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
LengthOp = InitializerOp;
break;
@@ -540,7 +540,7 @@ RsDoExtendedSpaceDescriptor (
case 11: /* Type-Specific Attributes */
Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
break;
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype2q.c b/sys/contrib/dev/acpica/compiler/aslrestype2q.c
index b01129a..7a01106 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype2q.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype2q.c
@@ -144,14 +144,14 @@ RsDoQwordIoDescriptor (
case 4: /* Range Type */
RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0, 2);
break;
case 5: /* Address Granularity */
Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
GranOp = InitializerOp;
break;
@@ -159,7 +159,7 @@ RsDoQwordIoDescriptor (
case 6: /* Address Min */
Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
MinOp = InitializerOp;
break;
@@ -167,7 +167,7 @@ RsDoQwordIoDescriptor (
case 7: /* Address Max */
Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
MaxOp = InitializerOp;
break;
@@ -182,7 +182,7 @@ RsDoQwordIoDescriptor (
case 9: /* Address Length */
Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
LengthOp = InitializerOp;
break;
@@ -366,8 +366,8 @@ RsDoQwordMemoryDescriptor (
case 4: /* Memory Type */
RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1, 2);
break;
case 5: /* Read/Write Type */
@@ -380,7 +380,7 @@ RsDoQwordMemoryDescriptor (
case 6: /* Address Granularity */
Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
GranOp = InitializerOp;
break;
@@ -388,7 +388,7 @@ RsDoQwordMemoryDescriptor (
case 7: /* Min Address */
Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
MinOp = InitializerOp;
break;
@@ -396,7 +396,7 @@ RsDoQwordMemoryDescriptor (
case 8: /* Max Address */
Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
MaxOp = InitializerOp;
break;
@@ -404,14 +404,14 @@ RsDoQwordMemoryDescriptor (
case 9: /* Translation Offset */
Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
break;
case 10: /* Address Length */
Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
LengthOp = InitializerOp;
break;
@@ -473,8 +473,8 @@ RsDoQwordMemoryDescriptor (
case 14: /* Address Range */
RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3, 2);
break;
case 15: /* Type */
@@ -607,7 +607,7 @@ RsDoQwordSpaceDescriptor (
case 6: /* Address Granularity */
Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
GranOp = InitializerOp;
break;
@@ -615,7 +615,7 @@ RsDoQwordSpaceDescriptor (
case 7: /* Min Address */
Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
MinOp = InitializerOp;
break;
@@ -623,7 +623,7 @@ RsDoQwordSpaceDescriptor (
case 8: /* Max Address */
Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
MaxOp = InitializerOp;
break;
@@ -631,14 +631,14 @@ RsDoQwordSpaceDescriptor (
case 9: /* Translation Offset */
Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
break;
case 10: /* Address Length */
Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
LengthOp = InitializerOp;
break;
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype2s.c b/sys/contrib/dev/acpica/compiler/aslrestype2s.c
new file mode 100644
index 0000000..2fa9085
--- /dev/null
+++ b/sys/contrib/dev/acpica/compiler/aslrestype2s.c
@@ -0,0 +1,1187 @@
+/******************************************************************************
+ *
+ * Module Name: aslrestype2s - Serial Large resource descriptors
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2011, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions, and the following disclaimer,
+ * without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ * substantially similar to the "NO WARRANTY" disclaimer below
+ * ("Disclaimer") and any redistribution must be conditioned upon
+ * including a substantially similar Disclaimer requirement for further
+ * binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ * of any contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+
+#include <contrib/dev/acpica/compiler/aslcompiler.h>
+#include "aslcompiler.y.h"
+#include <contrib/dev/acpica/include/amlcode.h>
+
+#define _COMPONENT ACPI_COMPILER
+ ACPI_MODULE_NAME ("aslrestype2s")
+
+
+static UINT16
+RsGetBufferDataLength (
+ ACPI_PARSE_OBJECT *InitializerOp);
+
+static UINT16
+RsGetInterruptDataLength (
+ ACPI_PARSE_OBJECT *InitializerOp);
+
+static BOOLEAN
+RsGetVendorData (
+ ACPI_PARSE_OBJECT *InitializerOp,
+ UINT8 *VendorData,
+ ACPI_SIZE DescriptorOffset);
+
+/*
+ * This module contains descriptors for serial buses and GPIO:
+ *
+ * GpioInt
+ * GpioIo
+ * I2cSerialBus
+ * SpiSerialBus
+ * UartSerialBus
+ */
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsGetBufferDataLength
+ *
+ * PARAMETERS: InitializerOp - Current parse op, start of the resource
+ * descriptor
+ *
+ * RETURN: Length of the data buffer
+ *
+ * DESCRIPTION: Get the length of a RawDataBuffer, used for vendor data.
+ *
+ ******************************************************************************/
+
+static UINT16
+RsGetBufferDataLength (
+ ACPI_PARSE_OBJECT *InitializerOp)
+{
+ UINT16 ExtraDataSize = 0;
+ ACPI_PARSE_OBJECT *DataList;
+
+
+ /* Find the byte-initializer list */
+
+ while (InitializerOp)
+ {
+ if (InitializerOp->Asl.ParseOpcode == PARSEOP_DATABUFFER)
+ {
+ /* First child is the optional length (ignore it here) */
+
+ DataList = InitializerOp->Asl.Child;
+ DataList = ASL_GET_PEER_NODE (DataList);
+
+ /* Count the data items (each one is a byte of data) */
+
+ while (DataList)
+ {
+ ExtraDataSize++;
+ DataList = ASL_GET_PEER_NODE (DataList);
+ }
+
+ return (ExtraDataSize);
+ }
+
+ InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
+ }
+
+ return (ExtraDataSize);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsGetInterruptDataLength
+ *
+ * PARAMETERS: InitializerOp - Current parse op, start of the resource
+ * descriptor
+ *
+ * RETURN: Length of the interrupt data list
+ *
+ * DESCRIPTION: Get the length of a list of interrupt DWORDs for the GPIO
+ * descriptors.
+ *
+ ******************************************************************************/
+
+static UINT16
+RsGetInterruptDataLength (
+ ACPI_PARSE_OBJECT *InitializerOp)
+{
+ UINT16 InterruptLength;
+ UINT32 i;
+
+
+ /* Count the interrupt numbers */
+
+ InterruptLength = 0;
+ for (i = 0; InitializerOp; i++)
+ {
+ InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
+
+ /* Interrupt list starts at offset 10 (Gpio descriptors) */
+
+ if (i >= 10)
+ {
+ InterruptLength += 2;
+ }
+ }
+
+ return (InterruptLength);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsGetVendorData
+ *
+ * PARAMETERS: InitializerOp - Current parse op, start of the resource
+ * descriptor.
+ * VendorData - Where the vendor data is returned
+ * DescriptorOffset - Where vendor data begins in descriptor
+ *
+ * RETURN: TRUE if valid vendor data was returned, FALSE otherwise.
+ *
+ * DESCRIPTION: Extract the vendor data and construct a vendor data buffer.
+ *
+ ******************************************************************************/
+
+static BOOLEAN
+RsGetVendorData (
+ ACPI_PARSE_OBJECT *InitializerOp,
+ UINT8 *VendorData,
+ ACPI_SIZE DescriptorOffset)
+{
+ ACPI_PARSE_OBJECT *BufferOp;
+ UINT32 SpecifiedLength = ACPI_UINT32_MAX;
+ UINT16 ActualLength = 0;
+
+
+ /* VendorData field is always optional */
+
+ if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+ {
+ return (FALSE);
+ }
+
+ BufferOp = InitializerOp->Asl.Child;
+ if (!BufferOp)
+ {
+ AslError (ASL_ERROR, ASL_MSG_SYNTAX, InitializerOp, "");
+ return (FALSE);
+ }
+
+ /* First child is the optional buffer length (WORD) */
+
+ if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
+ {
+ SpecifiedLength = (UINT16) BufferOp->Asl.Value.Integer;
+ }
+
+ /* Insert field tag _VEN */
+
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_VENDORDATA,
+ (UINT16) DescriptorOffset);
+
+ /* Walk the list of buffer initializers (each is one byte) */
+
+ BufferOp = RsCompleteNodeAndGetNext (BufferOp);
+ if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
+ {
+ while (BufferOp)
+ {
+ *VendorData = (UINT8) BufferOp->Asl.Value.Integer;
+ VendorData++;
+ ActualLength++;
+ BufferOp = RsCompleteNodeAndGetNext (BufferOp);
+ }
+ }
+
+ /* Length validation. Buffer cannot be of zero length */
+
+ if ((SpecifiedLength == 0) ||
+ ((SpecifiedLength == ACPI_UINT32_MAX) && (ActualLength == 0)))
+ {
+ AslError (ASL_ERROR, ASL_MSG_BUFFER_LENGTH, InitializerOp, NULL);
+ return (FALSE);
+ }
+
+ if (SpecifiedLength != ACPI_UINT32_MAX)
+ {
+ /* ActualLength > SpecifiedLength -> error */
+
+ if (ActualLength > SpecifiedLength)
+ {
+ AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG, InitializerOp, NULL);
+ return (FALSE);
+ }
+
+ /* ActualLength < SpecifiedLength -> remark */
+
+ else if (ActualLength < SpecifiedLength)
+ {
+ AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT, InitializerOp, NULL);
+ return (FALSE);
+ }
+ }
+
+ return (TRUE);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsDoGpioIntDescriptor
+ *
+ * PARAMETERS: Op - Parent resource descriptor parse node
+ * CurrentByteOffset - Offset into the resource template AML
+ * buffer (to track references to the desc)
+ *
+ * RETURN: Completed resource node
+ *
+ * DESCRIPTION: Construct a long "GpioInt" descriptor
+ *
+ ******************************************************************************/
+
+ASL_RESOURCE_NODE *
+RsDoGpioIntDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset)
+{
+ AML_RESOURCE *Descriptor;
+ ACPI_PARSE_OBJECT *InitializerOp;
+ ASL_RESOURCE_NODE *Rnode;
+ char *ResourceSource = NULL;
+ UINT8 *VendorData = NULL;
+ UINT16 *InterruptList = NULL;
+ UINT16 ResSourceLength;
+ UINT16 VendorLength;
+ UINT16 InterruptLength;
+ UINT16 DescriptorSize;
+ UINT32 i;
+
+
+ InitializerOp = Op->Asl.Child;
+
+ /*
+ * Calculate lengths for fields that have variable length:
+ * 1) Resource Source string
+ * 2) Vendor Data buffer
+ * 3) PIN (interrupt) list
+ */
+ ResSourceLength = RsGetStringDataLength (InitializerOp);
+ VendorLength = RsGetBufferDataLength (InitializerOp);
+ InterruptLength = RsGetInterruptDataLength (InitializerOp);
+
+ DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
+ ResSourceLength + VendorLength + InterruptLength;
+
+ /* Allocate the local resource node and initialize */
+
+ Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
+
+ Descriptor = Rnode->Buffer;
+ Descriptor->Gpio.ResourceLength = DescriptorSize;
+ Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
+ Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
+ Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_INT;
+
+ /* Build pointers to optional areas */
+
+ InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO));
+ ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
+ VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
+
+ /* Setup offsets within the descriptor */
+
+ Descriptor->Gpio.PinTableOffset = (UINT16)
+ ACPI_PTR_DIFF (InterruptList, Descriptor);
+
+ Descriptor->Gpio.ResSourceOffset = (UINT16)
+ ACPI_PTR_DIFF (ResourceSource, Descriptor);
+
+ DbgPrint (ASL_DEBUG_OUTPUT,
+ "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, IntLen: %.2X\n",
+ "GpioInt", Descriptor->Gpio.ResourceLength, (UINT16) sizeof (AML_RESOURCE_GPIO),
+ ResSourceLength, VendorLength, InterruptLength);
+
+ /* Process all child initialization nodes */
+
+ for (i = 0; InitializerOp; i++)
+ {
+ switch (i)
+ {
+ case 0: /* Interrupt Mode - edge/level [Flag] (_MOD) */
+
+ RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0);
+ break;
+
+ case 1: /* Interrupt Polarity - Active high/low [Flags] (_POL) */
+
+ RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 1, 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_POLARITY,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 1, 2);
+ break;
+
+ case 2: /* Share Type - Default: exclusive (0) [Flags] (_SHR) */
+
+ RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3, 2);
+ break;
+
+ case 3: /* Pin Config [BYTE] (_PPI) */
+
+ Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
+ break;
+
+ case 4: /* DebounceTimeout [WORD] (_DBT) */
+
+ Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
+ break;
+
+ case 5: /* ResSource [Optional Field - STRING] */
+
+ if (ResSourceLength)
+ {
+ /* Copy string to the descriptor */
+
+ strcpy (ResourceSource,
+ InitializerOp->Asl.Value.String);
+ }
+ break;
+
+ case 6: /* Resource Index */
+
+ if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
+ {
+ Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
+ }
+ break;
+
+ case 7: /* Resource Usage (consumer/producer) */
+
+ RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
+ break;
+
+ case 8: /* ResourceTag (Descriptor Name) */
+
+ UtAttachNamepathToOwner (Op, InitializerOp);
+ break;
+
+ case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
+
+ /*
+ * Always set the VendorOffset even if there is no Vendor Data.
+ * This field is required in order to calculate the length
+ * of the ResourceSource at runtime.
+ */
+ Descriptor->Gpio.VendorOffset = (UINT16)
+ ACPI_PTR_DIFF (VendorData, Descriptor);
+
+ if (RsGetVendorData (InitializerOp, VendorData,
+ (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
+ {
+ Descriptor->Gpio.VendorLength = VendorLength;
+ }
+ break;
+
+ default:
+ /*
+ * PINs come through here, repeatedly. Each PIN must be a DWORD.
+ * NOTE: there is no "length" field for this, so from ACPI spec:
+ * The number of pins in the table can be calculated from:
+ * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
+ * (implies resource source must immediately follow the pin list.)
+ * Name: _PIN
+ */
+ *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
+ InterruptList++;
+
+ /* Case 10: First interrupt number in list */
+
+ if (i == 10)
+ {
+ if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+ {
+ /* Must be at least one interrupt */
+
+ AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
+ InitializerOp, NULL);
+ }
+
+ /* Check now for duplicates in list */
+
+ RsCheckListForDuplicates (InitializerOp);
+
+ /* Create a named field at the start of the list */
+
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_PIN,
+ CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
+ }
+ break;
+ }
+
+ InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
+ }
+
+ return (Rnode);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsDoGpioIoDescriptor
+ *
+ * PARAMETERS: Op - Parent resource descriptor parse node
+ * CurrentByteOffset - Offset into the resource template AML
+ * buffer (to track references to the desc)
+ *
+ * RETURN: Completed resource node
+ *
+ * DESCRIPTION: Construct a long "GpioIo" descriptor
+ *
+ ******************************************************************************/
+
+ASL_RESOURCE_NODE *
+RsDoGpioIoDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset)
+{
+ AML_RESOURCE *Descriptor;
+ ACPI_PARSE_OBJECT *InitializerOp;
+ ASL_RESOURCE_NODE *Rnode;
+ char *ResourceSource = NULL;
+ UINT8 *VendorData = NULL;
+ UINT16 *InterruptList = NULL;
+ UINT16 ResSourceLength;
+ UINT16 VendorLength;
+ UINT16 InterruptLength;
+ UINT16 DescriptorSize;
+ UINT32 i;
+
+
+ InitializerOp = Op->Asl.Child;
+
+ /*
+ * Calculate lengths for fields that have variable length:
+ * 1) Resource Source string
+ * 2) Vendor Data buffer
+ * 3) PIN (interrupt) list
+ */
+ ResSourceLength = RsGetStringDataLength (InitializerOp);
+ VendorLength = RsGetBufferDataLength (InitializerOp);
+ InterruptLength = RsGetInterruptDataLength (InitializerOp);
+
+ DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
+ ResSourceLength + VendorLength + InterruptLength;
+
+ /* Allocate the local resource node and initialize */
+
+ Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
+
+ Descriptor = Rnode->Buffer;
+ Descriptor->Gpio.ResourceLength = DescriptorSize;
+ Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
+ Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
+ Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_IO;
+
+ /* Build pointers to optional areas */
+
+ InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO));
+ ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
+ VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
+
+ /* Setup offsets within the descriptor */
+
+ Descriptor->Gpio.PinTableOffset = (UINT16)
+ ACPI_PTR_DIFF (InterruptList, Descriptor);
+
+ Descriptor->Gpio.ResSourceOffset = (UINT16)
+ ACPI_PTR_DIFF (ResourceSource, Descriptor);
+
+ DbgPrint (ASL_DEBUG_OUTPUT,
+ "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, IntLen: %.2X\n",
+ "GpioIo", Descriptor->Gpio.ResourceLength, (UINT16) sizeof (AML_RESOURCE_GPIO),
+ ResSourceLength, VendorLength, InterruptLength);
+
+ /* Process all child initialization nodes */
+
+ for (i = 0; InitializerOp; i++)
+ {
+ switch (i)
+ {
+ case 0: /* Share Type [Flags] (_SHR) */
+
+ RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3);
+ break;
+
+ case 1: /* Pin Config [BYTE] (_PPI) */
+
+ Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
+ break;
+
+ case 2: /* DebounceTimeout [WORD] (_DBT) */
+
+ Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
+ break;
+
+ case 3: /* Drive Strength [WORD] (_DRS) */
+
+ Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength));
+ break;
+
+ case 4: /* I/O Restriction [Flag] (_IOR) */
+
+ RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2);
+ break;
+
+ case 5: /* ResSource [Optional Field - STRING] */
+
+ if (ResSourceLength)
+ {
+ /* Copy string to the descriptor */
+
+ strcpy (ResourceSource,
+ InitializerOp->Asl.Value.String);
+ }
+ break;
+
+ case 6: /* Resource Index */
+
+ if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
+ {
+ Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
+ }
+ break;
+
+ case 7: /* Resource Usage (consumer/producer) */
+
+ RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
+ break;
+
+ case 8: /* ResourceTag (Descriptor Name) */
+
+ UtAttachNamepathToOwner (Op, InitializerOp);
+ break;
+
+ case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
+
+ /*
+ * Always set the VendorOffset even if there is no Vendor Data.
+ * This field is required in order to calculate the length
+ * of the ResourceSource at runtime.
+ */
+ Descriptor->Gpio.VendorOffset = (UINT16)
+ ACPI_PTR_DIFF (VendorData, Descriptor);
+
+ if (RsGetVendorData (InitializerOp, VendorData,
+ (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
+ {
+ Descriptor->Gpio.VendorLength = VendorLength;
+ }
+ break;
+
+ default:
+ /*
+ * PINs come through here, repeatedly. Each PIN must be a DWORD.
+ * NOTE: there is no "length" field for this, so from ACPI spec:
+ * The number of pins in the table can be calculated from:
+ * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
+ * (implies resource source must immediately follow the pin list.)
+ * Name: _PIN
+ */
+ *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
+ InterruptList++;
+
+ /* Case 10: First interrupt number in list */
+
+ if (i == 10)
+ {
+ if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
+ {
+ /* Must be at least one interrupt */
+
+ AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
+ InitializerOp, NULL);
+ }
+
+ /* Check now for duplicates in list */
+
+ RsCheckListForDuplicates (InitializerOp);
+
+ /* Create a named field at the start of the list */
+
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_PIN,
+ CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
+ }
+ break;
+ }
+
+ InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
+ }
+
+ return (Rnode);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsDoI2cSerialBusDescriptor
+ *
+ * PARAMETERS: Op - Parent resource descriptor parse node
+ * CurrentByteOffset - Offset into the resource template AML
+ * buffer (to track references to the desc)
+ *
+ * RETURN: Completed resource node
+ *
+ * DESCRIPTION: Construct a long "I2cSerialBus" descriptor
+ *
+ ******************************************************************************/
+
+ASL_RESOURCE_NODE *
+RsDoI2cSerialBusDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset)
+{
+ AML_RESOURCE *Descriptor;
+ ACPI_PARSE_OBJECT *InitializerOp;
+ ASL_RESOURCE_NODE *Rnode;
+ char *ResourceSource = NULL;
+ UINT8 *VendorData = NULL;
+ UINT16 ResSourceLength;
+ UINT16 VendorLength;
+ UINT16 DescriptorSize;
+ UINT32 i;
+
+
+ InitializerOp = Op->Asl.Child;
+
+ /*
+ * Calculate lengths for fields that have variable length:
+ * 1) Resource Source string
+ * 2) Vendor Data buffer
+ */
+ ResSourceLength = RsGetStringDataLength (InitializerOp);
+ VendorLength = RsGetBufferDataLength (InitializerOp);
+
+ DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS) +
+ ResSourceLength + VendorLength;
+
+ /* Allocate the local resource node and initialize */
+
+ Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
+
+ Descriptor = Rnode->Buffer;
+ Descriptor->I2cSerialBus.ResourceLength = DescriptorSize;
+ Descriptor->I2cSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
+ Descriptor->I2cSerialBus.RevisionId = AML_RESOURCE_I2C_REVISION;
+ Descriptor->I2cSerialBus.TypeRevisionId = AML_RESOURCE_I2C_TYPE_REVISION;
+ Descriptor->I2cSerialBus.Type = AML_RESOURCE_I2C_SERIALBUSTYPE;
+ Descriptor->I2cSerialBus.TypeDataLength = AML_RESOURCE_I2C_MIN_DATA_LEN + VendorLength;
+
+ /* Build pointers to optional areas */
+
+ VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_I2C_SERIALBUS));
+ ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
+
+ DbgPrint (ASL_DEBUG_OUTPUT,
+ "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
+ "I2cSerialBus", Descriptor->I2cSerialBus.ResourceLength,
+ (UINT16) sizeof (AML_RESOURCE_I2C_SERIALBUS), ResSourceLength,
+ VendorLength, Descriptor->I2cSerialBus.TypeDataLength);
+
+ /* Process all child initialization nodes */
+
+ for (i = 0; InitializerOp; i++)
+ {
+ switch (i)
+ {
+ case 0: /* Slave Address [WORD] (_ADR) */
+
+ Descriptor->I2cSerialBus.SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.SlaveAddress));
+ break;
+
+ case 1: /* Slave Mode [Flag] (_SLV) */
+
+ RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 0, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.Flags), 0);
+ break;
+
+ case 2: /* ConnectionSpeed [DWORD] (_SPE) */
+
+ Descriptor->I2cSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.ConnectionSpeed));
+ break;
+
+ case 3: /* Addresssing Mode [Flag] (_MOD) */
+
+ RsSetFlagBits16 (&Descriptor->I2cSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.TypeSpecificFlags), 0);
+ break;
+
+ case 4: /* ResSource [Optional Field - STRING] */
+
+ if (ResSourceLength)
+ {
+ /* Copy string to the descriptor */
+
+ strcpy (ResourceSource,
+ InitializerOp->Asl.Value.String);
+ }
+ break;
+
+ case 5: /* Resource Index */
+
+ if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
+ {
+ Descriptor->I2cSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
+ }
+ break;
+
+ case 6: /* Resource Usage (consumer/producer) */
+
+ RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 1, 1);
+ break;
+
+ case 7: /* ResourceTag (Descriptor Name) */
+
+ UtAttachNamepathToOwner (Op, InitializerOp);
+ break;
+
+ case 8: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
+
+ RsGetVendorData (InitializerOp, VendorData,
+ CurrentByteOffset + sizeof (AML_RESOURCE_I2C_SERIALBUS));
+ break;
+
+ default: /* Ignore any extra nodes */
+ break;
+ }
+
+ InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
+ }
+
+ return (Rnode);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsDoSpiSerialBusDescriptor
+ *
+ * PARAMETERS: Op - Parent resource descriptor parse node
+ * CurrentByteOffset - Offset into the resource template AML
+ * buffer (to track references to the desc)
+ *
+ * RETURN: Completed resource node
+ *
+ * DESCRIPTION: Construct a long "SPI Serial Bus" descriptor
+ *
+ ******************************************************************************/
+
+ASL_RESOURCE_NODE *
+RsDoSpiSerialBusDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset)
+{
+ AML_RESOURCE *Descriptor;
+ ACPI_PARSE_OBJECT *InitializerOp;
+ ASL_RESOURCE_NODE *Rnode;
+ char *ResourceSource = NULL;
+ UINT8 *VendorData = NULL;
+ UINT16 ResSourceLength;
+ UINT16 VendorLength;
+ UINT16 DescriptorSize;
+ UINT32 i;
+
+
+ InitializerOp = Op->Asl.Child;
+
+ /*
+ * Calculate lengths for fields that have variable length:
+ * 1) Resource Source string
+ * 2) Vendor Data buffer
+ */
+ ResSourceLength = RsGetStringDataLength (InitializerOp);
+ VendorLength = RsGetBufferDataLength (InitializerOp);
+
+ DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS) +
+ ResSourceLength + VendorLength;
+
+ /* Allocate the local resource node and initialize */
+
+ Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
+
+ Descriptor = Rnode->Buffer;
+ Descriptor->SpiSerialBus.ResourceLength = DescriptorSize;
+ Descriptor->SpiSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
+ Descriptor->SpiSerialBus.RevisionId = AML_RESOURCE_SPI_REVISION;
+ Descriptor->SpiSerialBus.TypeRevisionId = AML_RESOURCE_SPI_TYPE_REVISION;
+ Descriptor->SpiSerialBus.Type = AML_RESOURCE_SPI_SERIALBUSTYPE;
+ Descriptor->SpiSerialBus.TypeDataLength = AML_RESOURCE_SPI_MIN_DATA_LEN + VendorLength;
+
+ /* Build pointers to optional areas */
+
+ VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_SPI_SERIALBUS));
+ ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
+
+ DbgPrint (ASL_DEBUG_OUTPUT,
+ "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
+ "SpiSerialBus", Descriptor->SpiSerialBus.ResourceLength,
+ (UINT16) sizeof (AML_RESOURCE_SPI_SERIALBUS), ResSourceLength,
+ VendorLength, Descriptor->SpiSerialBus.TypeDataLength);
+
+ /* Process all child initialization nodes */
+
+ for (i = 0; InitializerOp; i++)
+ {
+ switch (i)
+ {
+ case 0: /* Device Selection [WORD] (_ADR) */
+
+ Descriptor->SpiSerialBus.DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DeviceSelection));
+ break;
+
+ case 1: /* Device Polarity [Flag] (_DPL) */
+
+ RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 1, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_DEVICEPOLARITY,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 1);
+ break;
+
+ case 2: /* Wire Mode [Flag] (_MOD) */
+
+ RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 0);
+ break;
+
+ case 3: /* Device Bit Length [BYTE] (_LEN) */
+
+ Descriptor->SpiSerialBus.DataBitLength = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DataBitLength));
+ break;
+
+ case 4: /* Slave Mode [Flag] (_SLV) */
+
+ RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 0, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.Flags), 0);
+ break;
+
+ case 5: /* ConnectionSpeed [DWORD] (_SPE) */
+
+ Descriptor->SpiSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ConnectionSpeed));
+ break;
+
+ case 6: /* Clock Polarity [BYTE] (_POL) */
+
+ Descriptor->SpiSerialBus.ClockPolarity = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_POLARITY,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPolarity));
+ break;
+
+ case 7: /* Clock Phase [BYTE] (_PHA) */
+
+ Descriptor->SpiSerialBus.ClockPhase = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_PHASE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPhase));
+ break;
+
+ case 8: /* ResSource [Optional Field - STRING] */
+
+ if (ResSourceLength)
+ {
+ /* Copy string to the descriptor */
+
+ strcpy (ResourceSource,
+ InitializerOp->Asl.Value.String);
+ }
+ break;
+
+ case 9: /* Resource Index */
+
+ if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
+ {
+ Descriptor->SpiSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
+ }
+ break;
+
+ case 10: /* Resource Usage (consumer/producer) */
+
+ RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 1, 1);
+ break;
+
+ case 11: /* ResourceTag (Descriptor Name) */
+
+ UtAttachNamepathToOwner (Op, InitializerOp);
+ break;
+
+ case 12: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
+
+ RsGetVendorData (InitializerOp, VendorData,
+ CurrentByteOffset + sizeof (AML_RESOURCE_SPI_SERIALBUS));
+ break;
+
+ default: /* Ignore any extra nodes */
+ break;
+ }
+
+ InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
+ }
+
+ return (Rnode);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: RsDoUartSerialBusDescriptor
+ *
+ * PARAMETERS: Op - Parent resource descriptor parse node
+ * CurrentByteOffset - Offset into the resource template AML
+ * buffer (to track references to the desc)
+ *
+ * RETURN: Completed resource node
+ *
+ * DESCRIPTION: Construct a long "UART Serial Bus" descriptor
+ *
+ ******************************************************************************/
+
+ASL_RESOURCE_NODE *
+RsDoUartSerialBusDescriptor (
+ ACPI_PARSE_OBJECT *Op,
+ UINT32 CurrentByteOffset)
+{
+ AML_RESOURCE *Descriptor;
+ ACPI_PARSE_OBJECT *InitializerOp;
+ ASL_RESOURCE_NODE *Rnode;
+ char *ResourceSource = NULL;
+ UINT8 *VendorData = NULL;
+ UINT16 ResSourceLength;
+ UINT16 VendorLength;
+ UINT16 DescriptorSize;
+ UINT32 i;
+
+
+ InitializerOp = Op->Asl.Child;
+
+ /*
+ * Calculate lengths for fields that have variable length:
+ * 1) Resource Source string
+ * 2) Vendor Data buffer
+ */
+ ResSourceLength = RsGetStringDataLength (InitializerOp);
+ VendorLength = RsGetBufferDataLength (InitializerOp);
+
+ DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) +
+ ResSourceLength + VendorLength;
+
+ /* Allocate the local resource node and initialize */
+
+ Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
+
+ Descriptor = Rnode->Buffer;
+ Descriptor->UartSerialBus.ResourceLength = DescriptorSize;
+ Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
+ Descriptor->UartSerialBus.RevisionId = AML_RESOURCE_UART_REVISION;
+ Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION;
+ Descriptor->UartSerialBus.Type = AML_RESOURCE_UART_SERIALBUSTYPE;
+ Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength;
+
+ /* Build pointers to optional areas */
+
+ VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS));
+ ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
+
+ DbgPrint (ASL_DEBUG_OUTPUT,
+ "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
+ "UartSerialBus", Descriptor->UartSerialBus.ResourceLength,
+ (UINT16) sizeof (AML_RESOURCE_UART_SERIALBUS), ResSourceLength,
+ VendorLength, Descriptor->UartSerialBus.TypeDataLength);
+
+ /* Process all child initialization nodes */
+
+ for (i = 0; InitializerOp; i++)
+ {
+ switch (i)
+ {
+ case 0: /* ConnectionSpeed (Baud Rate) [DWORD] (_SPE) */
+
+ Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer;
+ RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate));
+ break;
+
+ case 1: /* Bits Per Byte [Flags] (_LEN) */
+
+ RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3);
+ break;
+
+ case 2: /* Stop Bits [Flags] (_STB) */
+
+ RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2);
+ break;
+
+ case 3: /* Lines In Use [BYTE] (_LIN) */
+
+ Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled));
+ break;
+
+ case 4: /* Endianness [Flag] (_END) */
+
+ RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0);
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7);
+ break;
+
+ case 5: /* Parity [BYTE] (_PAR) */
+
+ Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer;
+ RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity));
+ break;
+
+ case 6: /* Flow Control [Flags] (_FLC) */
+
+ RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2);
+ break;
+
+ case 7: /* Rx Buffer Size [WORD] (_RXL) */
+
+ Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize));
+ break;
+
+ case 8: /* Tx Buffer Size [WORD] (_TXL) */
+
+ Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize));
+ break;
+
+ case 9: /* ResSource [Optional Field - STRING] */
+
+ if (ResSourceLength)
+ {
+ /* Copy string to the descriptor */
+
+ strcpy (ResourceSource,
+ InitializerOp->Asl.Value.String);
+ }
+ break;
+
+ case 10: /* Resource Index */
+
+ if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
+ {
+ Descriptor->UartSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
+ }
+ break;
+
+ case 11: /* Resource Usage (consumer/producer) */
+
+ RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1);
+
+ /*
+ * Slave Mode [Flag] (_SLV)
+ *
+ * Note: There is no SlaveMode argument to the UartSerialBus macro, but
+ * we add this name anyway to allow the flag to be set by ASL in the
+ * rare case where there is a slave mode associated with the UART.
+ */
+ RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0);
+ break;
+
+ case 12: /* ResourceTag (Descriptor Name) */
+
+ UtAttachNamepathToOwner (Op, InitializerOp);
+ break;
+
+ case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
+
+ RsGetVendorData (InitializerOp, VendorData,
+ CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS));
+ break;
+
+ default: /* Ignore any extra nodes */
+ break;
+ }
+
+ InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
+ }
+
+ return (Rnode);
+}
diff --git a/sys/contrib/dev/acpica/compiler/aslrestype2w.c b/sys/contrib/dev/acpica/compiler/aslrestype2w.c
index 96928d9..05fcc39 100644
--- a/sys/contrib/dev/acpica/compiler/aslrestype2w.c
+++ b/sys/contrib/dev/acpica/compiler/aslrestype2w.c
@@ -144,14 +144,14 @@ RsDoWordIoDescriptor (
case 4: /* Range Type */
RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3);
- RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
- CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0);
+ RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
+ CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0, 2);
break;
case 5: /* Address Granularity */
Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
GranOp = InitializerOp;
break;
@@ -159,7 +159,7 @@ RsDoWordIoDescriptor (
case 6: /* Address Min */
Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
MinOp = InitializerOp;
break;
@@ -167,7 +167,7 @@ RsDoWordIoDescriptor (
case 7: /* Address Max */
Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
MaxOp = InitializerOp;
break;
@@ -175,14 +175,14 @@ RsDoWordIoDescriptor (
case 8: /* Translation Offset */
Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
break;
case 9: /* Address Length */
Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
LengthOp = InitializerOp;
break;
@@ -367,7 +367,7 @@ RsDoWordBusNumberDescriptor (
Descriptor->Address16.Granularity =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
GranOp = InitializerOp;
break;
@@ -376,7 +376,7 @@ RsDoWordBusNumberDescriptor (
Descriptor->Address16.Minimum =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
MinOp = InitializerOp;
break;
@@ -385,7 +385,7 @@ RsDoWordBusNumberDescriptor (
Descriptor->Address16.Maximum =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
MaxOp = InitializerOp;
break;
@@ -394,7 +394,7 @@ RsDoWordBusNumberDescriptor (
Descriptor->Address16.TranslationOffset =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
break;
@@ -402,7 +402,7 @@ RsDoWordBusNumberDescriptor (
Descriptor->Address16.AddressLength =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
LengthOp = InitializerOp;
break;
@@ -584,7 +584,7 @@ RsDoWordSpaceDescriptor (
Descriptor->Address16.Granularity =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
GranOp = InitializerOp;
break;
@@ -593,7 +593,7 @@ RsDoWordSpaceDescriptor (
Descriptor->Address16.Minimum =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
MinOp = InitializerOp;
break;
@@ -602,7 +602,7 @@ RsDoWordSpaceDescriptor (
Descriptor->Address16.Maximum =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
MaxOp = InitializerOp;
break;
@@ -611,7 +611,7 @@ RsDoWordSpaceDescriptor (
Descriptor->Address16.TranslationOffset =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
break;
@@ -619,7 +619,7 @@ RsDoWordSpaceDescriptor (
Descriptor->Address16.AddressLength =
(UINT16) InitializerOp->Asl.Value.Integer;
- RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
+ RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
LengthOp = InitializerOp;
break;
diff --git a/sys/contrib/dev/acpica/compiler/aslstubs.c b/sys/contrib/dev/acpica/compiler/aslstubs.c
index 5bc59aa..63d1402 100644
--- a/sys/contrib/dev/acpica/compiler/aslstubs.c
+++ b/sys/contrib/dev/acpica/compiler/aslstubs.c
@@ -232,3 +232,20 @@ AcpiTbFindTable (
return (AE_SUPPORT);
}
+/* OSL interfaces */
+
+ACPI_THREAD_ID
+AcpiOsGetThreadId (
+ void)
+{
+ return (0xFFFF);
+}
+
+ACPI_STATUS
+AcpiOsExecute (
+ ACPI_EXECUTE_TYPE Type,
+ ACPI_OSD_EXEC_CALLBACK Function,
+ void *Context)
+{
+ return (AE_SUPPORT);
+}
diff --git a/sys/contrib/dev/acpica/compiler/asltransform.c b/sys/contrib/dev/acpica/compiler/asltransform.c
index 2cf7cf7..b13d46e 100644
--- a/sys/contrib/dev/acpica/compiler/asltransform.c
+++ b/sys/contrib/dev/acpica/compiler/asltransform.c
@@ -398,6 +398,7 @@ TrDoSwitch (
ACPI_PARSE_OBJECT *MethodOp;
ACPI_PARSE_OBJECT *StoreOp;
ACPI_PARSE_OBJECT *BreakOp;
+ ACPI_PARSE_OBJECT *BufferOp;
char *PredicateValueName;
UINT16 Index;
UINT32 Btype;
@@ -647,6 +648,7 @@ TrDoSwitch (
Predicate = StartNode->Asl.Child;
NewOp = TrCreateLeafNode (PARSEOP_NAME);
+ TrAmlInitLineNumbers (NewOp, StartNode);
/* Find the parent method */
@@ -690,6 +692,7 @@ TrDoSwitch (
NewOp2 = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
(UINT64) ACPI_TO_INTEGER (PredicateValueName));
+ TrAmlInitLineNumbers (NewOp2, NewOp);
NewOp2->Asl.CompileFlags |= NODE_IS_NAME_DECLARATION;
NewOp->Asl.Child = NewOp2;
@@ -700,21 +703,27 @@ TrDoSwitch (
case ACPI_BTYPE_INTEGER:
NewOp2->Asl.Next = TrCreateValuedLeafNode (PARSEOP_ZERO,
(UINT64) 0);
+ TrAmlInitLineNumbers (NewOp2->Asl.Next, NewOp);
break;
case ACPI_BTYPE_STRING:
NewOp2->Asl.Next = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL,
(UINT64) ACPI_TO_INTEGER (""));
+ TrAmlInitLineNumbers (NewOp2->Asl.Next, NewOp);
break;
case ACPI_BTYPE_BUFFER:
(void) TrLinkPeerNode (NewOp2, TrCreateValuedLeafNode (PARSEOP_BUFFER,
(UINT64) 0));
Next = NewOp2->Asl.Next;
+ TrAmlInitLineNumbers (Next, NewOp2);
(void) TrLinkChildren (Next, 1, TrCreateValuedLeafNode (PARSEOP_ZERO,
(UINT64) 1));
- (void) TrLinkPeerNode (Next->Asl.Child,
- TrCreateValuedLeafNode (PARSEOP_DEFAULT_ARG, (UINT64) 0));
+ TrAmlInitLineNumbers (Next->Asl.Child, Next);
+
+ BufferOp = TrCreateValuedLeafNode (PARSEOP_DEFAULT_ARG, (UINT64) 0);
+ TrAmlInitLineNumbers (BufferOp, Next->Asl.Child);
+ (void) TrLinkPeerNode (Next->Asl.Child, BufferOp);
TrAmlSetSubtreeParent (Next->Asl.Child, Next);
break;
@@ -733,6 +742,7 @@ TrDoSwitch (
*/
TrAmlInitNode (StartNode, PARSEOP_WHILE);
NewOp = TrCreateLeafNode (PARSEOP_ONE);
+ TrAmlInitLineNumbers (NewOp, StartNode);
NewOp->Asl.Next = Predicate->Asl.Next;
NewOp->Asl.Parent = StartNode;
StartNode->Asl.Child = NewOp;
@@ -740,6 +750,7 @@ TrDoSwitch (
/* Create a Store() node */
StoreOp = TrCreateLeafNode (PARSEOP_STORE);
+ TrAmlInitLineNumbers (StoreOp, NewOp);
StoreOp->Asl.Parent = StartNode;
TrAmlInsertPeer (NewOp, StoreOp);
@@ -750,6 +761,7 @@ TrDoSwitch (
NewOp = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
(UINT64) ACPI_TO_INTEGER (PredicateValueName));
+ TrAmlInitLineNumbers (NewOp, StoreOp);
NewOp->Asl.Parent = StoreOp;
Predicate->Asl.Next = NewOp;
@@ -762,6 +774,7 @@ TrDoSwitch (
}
BreakOp = TrCreateLeafNode (PARSEOP_BREAK);
+ TrAmlInitLineNumbers (BreakOp, NewOp);
BreakOp->Asl.Parent = StartNode;
TrAmlInsertPeer (Conditional, BreakOp);
}
diff --git a/sys/contrib/dev/acpica/compiler/asltree.c b/sys/contrib/dev/acpica/compiler/asltree.c
index 151d3a8..7069891 100644
--- a/sys/contrib/dev/acpica/compiler/asltree.c
+++ b/sys/contrib/dev/acpica/compiler/asltree.c
@@ -45,6 +45,7 @@
#include <contrib/dev/acpica/compiler/aslcompiler.h>
#include "aslcompiler.y.h"
+#include <contrib/dev/acpica/include/acapps.h>
#include <time.h>
#define _COMPONENT ACPI_COMPILER
@@ -287,9 +288,6 @@ TrGetNodeFlagName (
case NODE_METHOD_TYPED:
return ("NODE_METHOD_TYPED");
- case NODE_IS_BIT_OFFSET:
- return ("NODE_IS_BIT_OFFSET");
-
case NODE_COMPILE_TIME_CONST:
return ("NODE_COMPILE_TIME_CONST");
@@ -428,6 +426,8 @@ TrCreateConstantLeafNode (
time_t CurrentTime;
char *StaticTimeString;
char *TimeString;
+ char *Path;
+ char *Filename;
switch (ParseOpcode)
@@ -437,7 +437,7 @@ TrCreateConstantLeafNode (
Op->Asl.Value.Integer = Op->Asl.LineNumber;
break;
- case PARSEOP___FILE__:
+ case PARSEOP___PATH__:
Op = TrAllocateNode (PARSEOP_STRING_LITERAL);
/* Op.Asl.Filename contains the full pathname to the file */
@@ -445,7 +445,17 @@ TrCreateConstantLeafNode (
Op->Asl.Value.String = Op->Asl.Filename;
break;
- case PARSEOP___DATE__:
+ case PARSEOP___FILE__:
+ Op = TrAllocateNode (PARSEOP_STRING_LITERAL);
+
+ /* Get the simple filename from the full path */
+
+ FlSplitInputPathname (Op->Asl.Filename, &Path, &Filename);
+ ACPI_FREE (Path);
+ Op->Asl.Value.String = Filename;
+ break;
+
+ case PARSEOP___DATE__:
Op = TrAllocateNode (PARSEOP_STRING_LITERAL);
/* Get a copy of the current time */
diff --git a/sys/contrib/dev/acpica/compiler/asltypes.h b/sys/contrib/dev/acpica/compiler/asltypes.h
index 8d9b9ed..11f4afd 100644
--- a/sys/contrib/dev/acpica/compiler/asltypes.h
+++ b/sys/contrib/dev/acpica/compiler/asltypes.h
@@ -68,7 +68,7 @@
#define NODE_METHOD_SOME_NO_RETVAL 0x00000200
#define NODE_RESULT_NOT_USED 0x00000400
#define NODE_METHOD_TYPED 0x00000800
-#define NODE_IS_BIT_OFFSET 0x00001000
+#define NODE_UNUSED_FLAG 0x00001000
#define NODE_COMPILE_TIME_CONST 0x00002000
#define NODE_IS_TERM_ARG 0x00004000
#define NODE_WAS_ONES_OP 0x00008000
@@ -144,8 +144,10 @@ typedef struct asl_file_status
} ASL_FILE_STATUS;
-/* File types */
-
+/*
+ * File types. Note: Any changes to this table must also be reflected
+ * in the AslFileTypeNames array.
+ */
typedef enum
{
ASL_FILE_STDOUT = 0,
diff --git a/sys/contrib/dev/acpica/compiler/aslutils.c b/sys/contrib/dev/acpica/compiler/aslutils.c
index b40a99f..1ae2336 100644
--- a/sys/contrib/dev/acpica/compiler/aslutils.c
+++ b/sys/contrib/dev/acpica/compiler/aslutils.c
@@ -53,11 +53,31 @@
#define _COMPONENT ACPI_COMPILER
ACPI_MODULE_NAME ("aslutils")
+
char AslHexLookup[] =
{
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
};
+/* Table below must match ASL_FILE_TYPES in asltypes.h */
+
+static const char *AslFileTypeNames [ASL_NUM_FILES] =
+{
+ "stdout: ",
+ "stderr: ",
+ "Table Input: ",
+ "Binary Output:",
+ "Source Output:",
+ "Listing File: ",
+ "Hex Dump: ",
+ "Namespace: ",
+ "Debug File: ",
+ "ASM Source: ",
+ "C Source: ",
+ "ASM Include: ",
+ "C Include: "
+};
+
/* Local prototypes */
@@ -451,35 +471,40 @@ void
UtDisplaySummary (
UINT32 FileId)
{
+ UINT32 i;
+
if (FileId != ASL_FILE_STDOUT)
{
/* Compiler name and version number */
- FlPrintFile (FileId, "%s version %X%s\n",
+ FlPrintFile (FileId, "%s version %X%s\n\n",
ASL_COMPILER_NAME, (UINT32) ACPI_CA_VERSION, ACPI_WIDTH);
}
+ /* Summary of main input and output files */
+
if (Gbl_FileType == ASL_INPUT_TYPE_ASCII_DATA)
{
FlPrintFile (FileId,
- "Table Input: %s - %u lines, %u bytes, %u fields\n",
+ "%-14s %s - %u lines, %u bytes, %u fields\n",
+ "Table Input:",
Gbl_Files[ASL_FILE_INPUT].Filename, Gbl_CurrentLineNumber,
Gbl_InputByteCount, Gbl_InputFieldCount);
if ((Gbl_ExceptionCount[ASL_ERROR] == 0) || (Gbl_IgnoreErrors))
{
FlPrintFile (FileId,
- "Binary Output: %s - %u bytes\n\n",
+ "%-14s %s - %u bytes\n",
+ "Binary Output:",
Gbl_Files[ASL_FILE_AML_OUTPUT].Filename, Gbl_TableLength);
}
}
else
{
- /* Input/Output summary */
-
FlPrintFile (FileId,
- "ASL Input: %s - %u lines, %u bytes, %u keywords\n",
+ "%-14s %s - %u lines, %u bytes, %u keywords\n",
+ "ASL Input:",
Gbl_Files[ASL_FILE_INPUT].Filename, Gbl_CurrentLineNumber,
Gbl_InputByteCount, TotalKeywords);
@@ -488,16 +513,38 @@ UtDisplaySummary (
if ((Gbl_ExceptionCount[ASL_ERROR] == 0) || (Gbl_IgnoreErrors))
{
FlPrintFile (FileId,
- "AML Output: %s - %u bytes, %u named objects, %u executable opcodes\n\n",
+ "%-14s %s - %u bytes, %u named objects, %u executable opcodes\n",
+ "AML Output:",
Gbl_Files[ASL_FILE_AML_OUTPUT].Filename, Gbl_TableLength,
TotalNamedObjects, TotalExecutableOpcodes);
}
}
+ /* Display summary of any optional files */
+
+ for (i = ASL_FILE_SOURCE_OUTPUT; i <= ASL_MAX_FILE_TYPE; i++)
+ {
+ if (!Gbl_Files[i].Filename || !Gbl_Files[i].Handle)
+ {
+ continue;
+ }
+
+ /* .SRC is a temp file unless specifically requested */
+
+ if ((i == ASL_FILE_SOURCE_OUTPUT) && (!Gbl_SourceOutputFlag))
+ {
+ continue;
+ }
+
+ FlPrintFile (FileId, "%14s %s - %u bytes\n",
+ AslFileTypeNames [i],
+ Gbl_Files[i].Filename, FlGetFileSize (i));
+ }
+
/* Error summary */
FlPrintFile (FileId,
- "Compilation complete. %u Errors, %u Warnings, %u Remarks",
+ "\nCompilation complete. %u Errors, %u Warnings, %u Remarks",
Gbl_ExceptionCount[ASL_ERROR],
Gbl_ExceptionCount[ASL_WARNING] +
Gbl_ExceptionCount[ASL_WARNING2] +
diff --git a/sys/contrib/dev/acpica/compiler/aslwalks.c b/sys/contrib/dev/acpica/compiler/aslwalks.c
index b60572d..c264501 100644
--- a/sys/contrib/dev/acpica/compiler/aslwalks.c
+++ b/sys/contrib/dev/acpica/compiler/aslwalks.c
@@ -1032,6 +1032,7 @@ AnOtherSemanticAnalysisWalkBegin (
ACPI_PARSE_OBJECT *ArgNode;
ACPI_PARSE_OBJECT *PrevArgNode = NULL;
const ACPI_OPCODE_INFO *OpInfo;
+ ACPI_NAMESPACE_NODE *Node;
OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
@@ -1156,6 +1157,78 @@ AnOtherSemanticAnalysisWalkBegin (
}
break;
+ case PARSEOP_CONNECTION:
+ /*
+ * Ensure that the referenced operation region has the correct SPACE_ID.
+ * From the grammar/parser, we know the parent is a FIELD definition.
+ */
+ ArgNode = Op->Asl.Parent; /* Field definition */
+ ArgNode = ArgNode->Asl.Child; /* First child is the OpRegion Name */
+ Node = ArgNode->Asl.Node; /* OpRegion namespace node */
+
+ ArgNode = Node->Op; /* OpRegion definition */
+ ArgNode = ArgNode->Asl.Child; /* First child is the OpRegion Name */
+ ArgNode = ArgNode->Asl.Next; /* Next peer is the SPACE_ID (what we want) */
+
+ /*
+ * The Connection() operator is only valid for the following operation
+ * region SpaceIds: GeneralPurposeIo and GenericSerialBus.
+ */
+ if ((ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GPIO) &&
+ (ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GSBUS))
+ {
+ AslError (ASL_ERROR, ASL_MSG_CONNECTION_INVALID, Op, NULL);
+ }
+ break;
+
+ case PARSEOP_FIELD:
+ /*
+ * Ensure that fields for GeneralPurposeIo and GenericSerialBus
+ * contain at least one Connection() operator
+ */
+ ArgNode = Op->Asl.Child; /* 1st child is the OpRegion Name */
+ Node = ArgNode->Asl.Node; /* OpRegion namespace node */
+ if (!Node)
+ {
+ break;
+ }
+
+ ArgNode = Node->Op; /* OpRegion definition */
+ ArgNode = ArgNode->Asl.Child; /* First child is the OpRegion Name */
+ ArgNode = ArgNode->Asl.Next; /* Next peer is the SPACE_ID (what we want) */
+
+ /* We are only interested in GeneralPurposeIo and GenericSerialBus */
+
+ if ((ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GPIO) &&
+ (ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GSBUS))
+ {
+ break;
+ }
+
+ ArgNode = Op->Asl.Child; /* 1st child is the OpRegion Name */
+ ArgNode = ArgNode->Asl.Next; /* AccessType */
+ ArgNode = ArgNode->Asl.Next; /* LockRule */
+ ArgNode = ArgNode->Asl.Next; /* UpdateRule */
+ ArgNode = ArgNode->Asl.Next; /* Start of FieldUnitList */
+
+ /* Walk the FieldUnitList */
+
+ while (ArgNode)
+ {
+ if (ArgNode->Asl.ParseOpcode == PARSEOP_CONNECTION)
+ {
+ break;
+ }
+ else if (ArgNode->Asl.ParseOpcode == PARSEOP_NAMESEG)
+ {
+ AslError (ASL_ERROR, ASL_MSG_CONNECTION_MISSING, ArgNode, NULL);
+ break;
+ }
+
+ ArgNode = ArgNode->Asl.Next;
+ }
+ break;
+
default:
break;
}
diff --git a/sys/contrib/dev/acpica/compiler/dtcompile.c b/sys/contrib/dev/acpica/compiler/dtcompile.c
index d119b8b..56d2083 100644
--- a/sys/contrib/dev/acpica/compiler/dtcompile.c
+++ b/sys/contrib/dev/acpica/compiler/dtcompile.c
@@ -310,6 +310,17 @@ DtCompileDataTable (
Status = DtCompileRsdp (FieldList);
return (Status);
}
+ else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_S3PT))
+ {
+ Status = DtCompileS3pt (FieldList);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ DtSetTableLength ();
+ return (Status);
+ }
/*
* All other tables must use the common ACPI table header. Insert the
@@ -329,7 +340,7 @@ DtCompileDataTable (
/* Validate the signature via the ACPI table list */
TableData = AcpiDmGetTableData (Signature);
- if (!TableData)
+ if (!TableData || Gbl_CompileGeneric)
{
DtCompileGeneric ((void **) FieldList);
goto Out;
@@ -411,6 +422,7 @@ DtCompileTable (
UINT8 FieldType;
UINT8 *Buffer;
UINT8 *FlagBuffer = NULL;
+ UINT32 CurrentFlagByteOffset = 0;
ACPI_STATUS Status;
@@ -442,6 +454,11 @@ DtCompileTable (
*/
for (; Info->Name; Info++)
{
+ if (Info->Opcode == ACPI_DMT_EXTRA_TEXT)
+ {
+ continue;
+ }
+
if (!LocalField)
{
sprintf (MsgBuffer, "Found NULL field - Field name \"%s\" needed",
@@ -472,6 +489,7 @@ DtCompileTable (
*Field = LocalField;
FlagBuffer = Buffer;
+ CurrentFlagByteOffset = Info->Offset;
break;
case DT_FIELD_TYPE_FLAG:
@@ -480,6 +498,14 @@ DtCompileTable (
if (FlagBuffer)
{
+ /*
+ * We must increment the FlagBuffer when we have crossed
+ * into the next flags byte within the flags field
+ * of type DT_FIELD_TYPE_FLAGS_INTEGER.
+ */
+ FlagBuffer += (Info->Offset - CurrentFlagByteOffset);
+ CurrentFlagByteOffset = Info->Offset;
+
DtCompileFlag (FlagBuffer, LocalField, Info);
}
else
diff --git a/sys/contrib/dev/acpica/compiler/dtcompiler.h b/sys/contrib/dev/acpica/compiler/dtcompiler.h
index 8bbd737..f60a21c 100644
--- a/sys/contrib/dev/acpica/compiler/dtcompiler.h
+++ b/sys/contrib/dev/acpica/compiler/dtcompiler.h
@@ -399,6 +399,10 @@ DtCompileFadt (
void **PFieldList);
ACPI_STATUS
+DtCompileFpdt (
+ void **PFieldList);
+
+ACPI_STATUS
DtCompileHest (
void **PFieldList);
@@ -415,14 +419,26 @@ DtCompileMcfg (
void **PFieldList);
ACPI_STATUS
+DtCompileMpst (
+ void **PFieldList);
+
+ACPI_STATUS
DtCompileMsct (
void **PFieldList);
ACPI_STATUS
+DtCompilePmtt (
+ void **PFieldList);
+
+ACPI_STATUS
DtCompileRsdt (
void **PFieldList);
ACPI_STATUS
+DtCompileS3pt (
+ DT_FIELD **PFieldList);
+
+ACPI_STATUS
DtCompileSlic (
void **PFieldList);
@@ -459,6 +475,7 @@ DtGetGenericTableInfo (
extern const unsigned char TemplateAsf[];
extern const unsigned char TemplateBoot[];
extern const unsigned char TemplateBert[];
+extern const unsigned char TemplateBgrt[];
extern const unsigned char TemplateCpep[];
extern const unsigned char TemplateDbgp[];
extern const unsigned char TemplateDmar[];
@@ -466,14 +483,19 @@ extern const unsigned char TemplateEcdt[];
extern const unsigned char TemplateEinj[];
extern const unsigned char TemplateErst[];
extern const unsigned char TemplateFadt[];
+extern const unsigned char TemplateFpdt[];
+extern const unsigned char TemplateGtdt[];
extern const unsigned char TemplateHest[];
extern const unsigned char TemplateHpet[];
extern const unsigned char TemplateIvrs[];
extern const unsigned char TemplateMadt[];
extern const unsigned char TemplateMcfg[];
extern const unsigned char TemplateMchi[];
+extern const unsigned char TemplateMpst[];
extern const unsigned char TemplateMsct[];
+extern const unsigned char TemplatePmtt[];
extern const unsigned char TemplateRsdt[];
+extern const unsigned char TemplateS3pt[];
extern const unsigned char TemplateSbst[];
extern const unsigned char TemplateSlic[];
extern const unsigned char TemplateSlit[];
diff --git a/sys/contrib/dev/acpica/compiler/dtfield.c b/sys/contrib/dev/acpica/compiler/dtfield.c
index 00d6043..3f26262 100644
--- a/sys/contrib/dev/acpica/compiler/dtfield.c
+++ b/sys/contrib/dev/acpica/compiler/dtfield.c
@@ -523,12 +523,25 @@ DtCompileFlag (
break;
+ case ACPI_DMT_FLAGS1:
+
+ BitPosition = 1;
+ BitLength = 2;
+ break;
+
+
case ACPI_DMT_FLAGS2:
BitPosition = 2;
BitLength = 2;
break;
+ case ACPI_DMT_FLAGS4:
+
+ BitPosition = 4;
+ BitLength = 2;
+ break;
+
default:
DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid flag opcode");
diff --git a/sys/contrib/dev/acpica/compiler/dtsubtable.c b/sys/contrib/dev/acpica/compiler/dtsubtable.c
index b3f24ab..70cd443 100644
--- a/sys/contrib/dev/acpica/compiler/dtsubtable.c
+++ b/sys/contrib/dev/acpica/compiler/dtsubtable.c
@@ -296,6 +296,11 @@ DtGetSubtableLength (
for (; Info->Name; Info++)
{
+ if (Info->Opcode == ACPI_DMT_EXTRA_TEXT)
+ {
+ continue;
+ }
+
if (!Field)
{
goto Error;
diff --git a/sys/contrib/dev/acpica/compiler/dttable.c b/sys/contrib/dev/acpica/compiler/dttable.c
index 393ac73..001239d 100644
--- a/sys/contrib/dev/acpica/compiler/dttable.c
+++ b/sys/contrib/dev/acpica/compiler/dttable.c
@@ -660,6 +660,90 @@ DtCompileFadt (
}
DtInsertSubtable (ParentTable, Subtable);
+
+ if (Revision >= 5)
+ {
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt5,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ DtInsertSubtable (ParentTable, Subtable);
+ }
+ }
+
+ return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtCompileFpdt
+ *
+ * PARAMETERS: List - Current field list pointer
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Compile FPDT.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+DtCompileFpdt (
+ void **List)
+{
+ ACPI_STATUS Status;
+ ACPI_FPDT_HEADER *FpdtHeader;
+ DT_SUBTABLE *Subtable;
+ DT_SUBTABLE *ParentTable;
+ ACPI_DMTABLE_INFO *InfoTable;
+ DT_FIELD **PFieldList = (DT_FIELD **) List;
+ DT_FIELD *SubtableStart;
+
+
+ while (*PFieldList)
+ {
+ SubtableStart = *PFieldList;
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoFpdtHdr,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPushSubtable (Subtable);
+
+ FpdtHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
+
+ switch (FpdtHeader->Type)
+ {
+ case ACPI_FPDT_TYPE_BOOT:
+ InfoTable = AcpiDmTableInfoFpdt0;
+ break;
+
+ case ACPI_FPDT_TYPE_S3PERF:
+ InfoTable = AcpiDmTableInfoFpdt1;
+ break;
+
+ default:
+ DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "FPDT");
+ return (AE_ERROR);
+ break;
+ }
+
+ Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPopSubtable ();
}
return (AE_OK);
@@ -1025,6 +1109,12 @@ DtCompileMadt (
case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
InfoTable = AcpiDmTableInfoMadt10;
break;
+ case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
+ InfoTable = AcpiDmTableInfoMadt11;
+ break;
+ case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
+ InfoTable = AcpiDmTableInfoMadt12;
+ break;
default:
DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT");
return (AE_ERROR);
@@ -1072,6 +1162,143 @@ DtCompileMcfg (
/******************************************************************************
*
+ * FUNCTION: DtCompileMpst
+ *
+ * PARAMETERS: List - Current field list pointer
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Compile MPST.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+DtCompileMpst (
+ void **List)
+{
+ ACPI_STATUS Status;
+ DT_SUBTABLE *Subtable;
+ DT_SUBTABLE *ParentTable;
+ DT_FIELD **PFieldList = (DT_FIELD **) List;
+ ACPI_MPST_CHANNEL *MpstChannelInfo;
+ ACPI_MPST_POWER_NODE *MpstPowerNode;
+ ACPI_MPST_DATA_HDR *MpstDataHeader;
+ UINT16 SubtableCount;
+ UINT8 PowerStateCount;
+ UINT8 ComponentCount;
+
+
+ /* Main table */
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPushSubtable (Subtable);
+
+ MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer);
+ SubtableCount = MpstChannelInfo->PowerNodeCount;
+
+ while (*PFieldList && SubtableCount)
+ {
+ /* Subtable: Memory Power Node(s) */
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPushSubtable (Subtable);
+
+ MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer);
+ PowerStateCount = MpstPowerNode->NumPowerStates;
+ ComponentCount = MpstPowerNode->NumPhysicalComponents;
+
+ ParentTable = DtPeekSubtable ();
+
+ /* Sub-subtables - Memory Power State Structure(s) */
+
+ while (*PFieldList && PowerStateCount)
+ {
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ DtInsertSubtable (ParentTable, Subtable);
+ PowerStateCount--;
+ }
+
+ /* Sub-subtables - Physical Component ID Structure(s) */
+
+ while (*PFieldList && ComponentCount)
+ {
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ DtInsertSubtable (ParentTable, Subtable);
+ ComponentCount--;
+ }
+
+ SubtableCount--;
+ DtPopSubtable ();
+ }
+
+ /* Subtable: Count of Memory Power State Characteristic structures */
+
+ DtPopSubtable ();
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPushSubtable (Subtable);
+
+ MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer);
+ SubtableCount = MpstDataHeader->CharacteristicsCount;
+
+ ParentTable = DtPeekSubtable ();
+
+ /* Subtable: Memory Power State Characteristics structure(s) */
+
+ while (*PFieldList && SubtableCount)
+ {
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ DtInsertSubtable (ParentTable, Subtable);
+ SubtableCount--;
+ }
+
+ DtPopSubtable ();
+ return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
* FUNCTION: DtCompileMsct
*
* PARAMETERS: List - Current field list pointer
@@ -1097,6 +1324,147 @@ DtCompileMsct (
/******************************************************************************
*
+ * FUNCTION: DtCompilePmtt
+ *
+ * PARAMETERS: List - Current field list pointer
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Compile PMTT.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+DtCompilePmtt (
+ void **List)
+{
+ ACPI_STATUS Status;
+ DT_SUBTABLE *Subtable;
+ DT_SUBTABLE *ParentTable;
+ DT_FIELD **PFieldList = (DT_FIELD **) List;
+ DT_FIELD *SubtableStart;
+ ACPI_PMTT_HEADER *PmttHeader;
+ ACPI_PMTT_CONTROLLER *PmttController;
+ UINT16 DomainCount;
+ UINT8 PrevType = ACPI_PMTT_TYPE_SOCKET;
+
+
+ /* Main table */
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPushSubtable (Subtable);
+
+ while (*PFieldList)
+ {
+ SubtableStart = *PFieldList;
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer);
+ while (PrevType >= PmttHeader->Type)
+ {
+ DtPopSubtable ();
+
+ if (PrevType == ACPI_PMTT_TYPE_SOCKET)
+ {
+ break;
+ }
+ PrevType--;
+ }
+ PrevType = PmttHeader->Type;
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPushSubtable (Subtable);
+
+ switch (PmttHeader->Type)
+ {
+ case ACPI_PMTT_TYPE_SOCKET:
+
+ /* Subtable: Socket Structure */
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ break;
+
+ case ACPI_PMTT_TYPE_CONTROLLER:
+
+ /* Subtable: Memory Controller Structure */
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+
+ PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER,
+ (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER)));
+ DomainCount = PmttController->DomainCount;
+
+ while (DomainCount)
+ {
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ DtInsertSubtable (ParentTable, Subtable);
+ DomainCount--;
+ }
+ break;
+
+ case ACPI_PMTT_TYPE_DIMM:
+
+ /* Subtable: Physical Component Structure */
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ break;
+
+ default:
+
+ DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT");
+ return (AE_ERROR);
+ }
+ }
+
+ return (Status);
+}
+
+
+/******************************************************************************
+ *
* FUNCTION: DtCompileRsdt
*
* PARAMETERS: List - Current field list pointer
@@ -1134,6 +1502,85 @@ DtCompileRsdt (
/******************************************************************************
*
+ * FUNCTION: DtCompileS3pt
+ *
+ * PARAMETERS: PFieldList - Current field list pointer
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Compile S3PT (Pointed to by FPDT)
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+DtCompileS3pt (
+ DT_FIELD **PFieldList)
+{
+ ACPI_STATUS Status;
+ ACPI_S3PT_HEADER *S3ptHeader;
+ DT_SUBTABLE *Subtable;
+ DT_SUBTABLE *ParentTable;
+ ACPI_DMTABLE_INFO *InfoTable;
+ DT_FIELD *SubtableStart;
+
+
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
+ &Gbl_RootTable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ DtPushSubtable (Gbl_RootTable);
+
+ while (*PFieldList)
+ {
+ SubtableStart = *PFieldList;
+ Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr,
+ &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPushSubtable (Subtable);
+
+ S3ptHeader = ACPI_CAST_PTR (ACPI_S3PT_HEADER, Subtable->Buffer);
+
+ switch (S3ptHeader->Type)
+ {
+ case ACPI_S3PT_TYPE_RESUME:
+ InfoTable = AcpiDmTableInfoS3pt0;
+ break;
+
+ case ACPI_S3PT_TYPE_SUSPEND:
+ InfoTable = AcpiDmTableInfoS3pt1;
+ break;
+
+ default:
+ DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT");
+ return (AE_ERROR);
+ }
+
+ Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
+ if (ACPI_FAILURE (Status))
+ {
+ return (Status);
+ }
+
+ ParentTable = DtPeekSubtable ();
+ DtInsertSubtable (ParentTable, Subtable);
+ DtPopSubtable ();
+ }
+
+ return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
* FUNCTION: DtCompileSlic
*
* PARAMETERS: List - Current field list pointer
diff --git a/sys/contrib/dev/acpica/compiler/dttemplate.h b/sys/contrib/dev/acpica/compiler/dttemplate.h
index 1954591..e330254 100644
--- a/sys/contrib/dev/acpica/compiler/dttemplate.h
+++ b/sys/contrib/dev/acpica/compiler/dttemplate.h
@@ -87,6 +87,17 @@ const unsigned char TemplateAsf[] =
0x01,0x00 /* 00000070 ".." */
};
+const unsigned char TemplateBgrt[] =
+{
+ 0x42,0x47,0x52,0x54,0x38,0x00,0x00,0x00, /* 00000000 "BGRT8..." */
+ 0x01,0x0D,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 "..INTEL " */
+ 0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45, /* 00000010 "TEMPLATE" */
+ 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
+ 0x23,0x06,0x11,0x20,0x01,0x00,0x00,0x00, /* 00000020 "#.. ...." */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000028 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 /* 00000030 "........" */
+};
+
const unsigned char TemplateBert[] =
{
0x42,0x45,0x52,0x54,0x30,0x00,0x00,0x00, /* 00000000 "BERT0..." */
@@ -326,6 +337,37 @@ const unsigned char TemplateFadt[] =
0x00,0x00,0x00,0x00 /* 000000F0 "...." */
};
+const unsigned char TemplateFpdt[] =
+{
+ 0x46,0x50,0x44,0x54,0x64,0x00,0x00,0x00, /* 00000000 "FPDTd..." */
+ 0x01,0xBD,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 "..INTEL " */
+ 0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45, /* 00000010 "TEMPLATE" */
+ 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
+ 0x04,0x08,0x11,0x20,0x00,0x00,0x30,0x01, /* 00000020 "... ..0." */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000028 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000030 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000038 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000040 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000048 "........" */
+ 0x00,0x00,0x00,0x00,0x01,0x00,0x10,0x01, /* 00000050 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000058 "........" */
+ 0x00,0x00,0x00,0x00 /* 00000060 "...." */
+};
+
+const unsigned char TemplateGtdt[] =
+{
+ 0x47,0x54,0x44,0x54,0x50,0x00,0x00,0x00, /* 00000000 "GTDTP..." */
+ 0x01,0xF1,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 "..INTEL " */
+ 0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45, /* 00000010 "TEMPLATE" */
+ 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
+ 0x23,0x06,0x11,0x20,0x00,0x00,0x00,0x00, /* 00000020 "#.. ...." */
+ 0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00, /* 00000028 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000030 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000038 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000040 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 /* 00000048 "........" */
+};
+
const unsigned char TemplateHest[] =
{
0x48,0x45,0x53,0x54,0xD4,0x01,0x00,0x00, /* 00000000 "HEST...." */
@@ -428,13 +470,15 @@ const unsigned char TemplateIvrs[] =
0x00,0x00,0x00,0x00 /* 000000B8 "...." */
};
+/* MADT with ACPI 5.0 subtables */
+
const unsigned char TemplateMadt[] =
{
- 0x41,0x50,0x49,0x43,0xB6,0x00,0x00,0x00, /* 00000000 "APIC...." */
- 0x01,0x45,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 ".EINTEL " */
+ 0x41,0x50,0x49,0x43,0xF6,0x00,0x00,0x00, /* 00000000 "APIC...." */
+ 0x01,0xB0,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 "..INTEL " */
0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45, /* 00000010 "TEMPLATE" */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
- 0x28,0x05,0x10,0x20,0x00,0x00,0x00,0x00, /* 00000020 "(.. ...." */
+ 0x23,0x06,0x11,0x20,0x00,0x00,0x00,0x00, /* 00000020 "#.. ...." */
0x01,0x00,0x00,0x00,0x00,0x08,0x00,0x00, /* 00000028 "........" */
0x01,0x00,0x00,0x00,0x01,0x0C,0x01,0x00, /* 00000030 "........" */
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000038 "........" */
@@ -452,7 +496,15 @@ const unsigned char TemplateMadt[] =
0x00,0x00,0x09,0x10,0x00,0x00,0x00,0x00, /* 00000098 "........" */
0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00, /* 000000A0 "........" */
0x00,0x00,0x0A,0x0C,0x05,0x00,0x00,0x00, /* 000000A8 "........" */
- 0x00,0x00,0x00,0x00,0x00,0x00 /* 000000B0 "......" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x28, /* 000000B0 ".......(" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 000000B8 "........" */
+ 0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00, /* 000000C0 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 000000C8 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 000000D0 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x18, /* 000000D8 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 000000E0 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 000000E8 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00 /* 000000F0 "......" */
};
const unsigned char TemplateMcfg[] =
@@ -480,6 +532,24 @@ const unsigned char TemplateMchi[] =
0x00,0x00,0x00,0x00,0x00 /* 00000040 "....." */
};
+const unsigned char TemplateMpst[] =
+{
+ 0x4D,0x50,0x53,0x54,0x6E,0x00,0x00,0x00, /* 00000000 "MPSTn..." */
+ 0x01,0x98,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 "..INTEL " */
+ 0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45, /* 00000010 "TEMPLATE" */
+ 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
+ 0x04,0x08,0x11,0x20,0x00,0x00,0x00,0x00, /* 00000020 "... ...." */
+ 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000028 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000030 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000038 "........" */
+ 0x00,0x00,0x02,0x03,0x00,0x00,0x00,0x00, /* 00000040 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000048 "........" */
+ 0x01,0x00,0x41,0x00,0x00,0x00,0x00,0x00, /* 00000050 "..A....." */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000058 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000060 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00 /* 00000068 "......" */
+};
+
const unsigned char TemplateMsct[] =
{
0x4D,0x53,0x43,0x54,0x90,0x00,0x00,0x00, /* 00000000 "MSCT...." */
@@ -502,6 +572,33 @@ const unsigned char TemplateMsct[] =
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 /* 00000088 "........" */
};
+const unsigned char TemplatePmtt[] =
+{
+ 0x50,0x4D,0x54,0x54,0xB4,0x00,0x00,0x00, /* 00000000 "PMTT...." */
+ 0x01,0x3A,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 ".:INTEL " */
+ 0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45, /* 00000010 "TEMPLATE" */
+ 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
+ 0x26,0x08,0x11,0x20,0x00,0x00,0x00,0x00, /* 00000020 "&.. ...." */
+ 0x00,0x00,0x80,0x00,0x01,0x00,0x00,0x00, /* 00000028 "........" */
+ 0x00,0x00,0x00,0x00,0x01,0x00,0x54,0x00, /* 00000030 "......T." */
+ 0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000038 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000040 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000048 "........" */
+ 0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00, /* 00000050 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000058 "........" */
+ 0x02,0x00,0x14,0x00,0x02,0x00,0x00,0x00, /* 00000060 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000068 "........" */
+ 0x00,0x00,0x00,0x00,0x02,0x00,0x14,0x00, /* 00000070 "........" */
+ 0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000078 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000080 "........" */
+ 0x01,0x00,0x20,0x00,0x01,0x00,0x00,0x00, /* 00000088 ".. ....." */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000090 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000098 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 000000A0 "........" */
+ 0x00,0x00,0x0C,0x00,0x01,0x00,0x00,0x00, /* 000000A8 "........" */
+ 0x00,0x00,0x00,0x00 /* 000000B0 "...." */
+};
+
const unsigned char TemplateRsdp[] =
{
0x52,0x53,0x44,0x20,0x50,0x54,0x52,0x20, /* 00000000 "RSD PTR " */
@@ -524,6 +621,17 @@ const unsigned char TemplateRsdt[] =
0x80,0x00,0x00,0x00 /* 00000040 "...." */
};
+const unsigned char TemplateS3pt[] =
+{
+ 0x53,0x33,0x50,0x54,0x34,0x00,0x00,0x00, /* 00000000 "S3PT4..." */
+ 0x00,0x00,0x18,0x01,0x00,0x00,0x00,0x00, /* 00000008 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000010 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000018 "........" */
+ 0x01,0x00,0x14,0x01,0x00,0x00,0x00,0x00, /* 00000020 "........" */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 00000028 "........" */
+ 0x00,0x00,0x00,0x00 /* 00000030 "...." */
+};
+
const unsigned char TemplateSbst[] =
{
0x53,0x42,0x53,0x54,0x30,0x00,0x00,0x00, /* 00000000 "SBST0..." */
diff --git a/sys/contrib/dev/acpica/compiler/dtutils.c b/sys/contrib/dev/acpica/compiler/dtutils.c
index da9b237..c0c92d0 100644
--- a/sys/contrib/dev/acpica/compiler/dtutils.c
+++ b/sys/contrib/dev/acpica/compiler/dtutils.c
@@ -384,7 +384,9 @@ DtGetFieldType (
case ACPI_DMT_FLAG6:
case ACPI_DMT_FLAG7:
case ACPI_DMT_FLAGS0:
+ case ACPI_DMT_FLAGS1:
case ACPI_DMT_FLAGS2:
+ case ACPI_DMT_FLAGS4:
Type = DT_FIELD_TYPE_FLAG;
break;
@@ -510,8 +512,11 @@ DtGetFieldLength (
case ACPI_DMT_FLAG6:
case ACPI_DMT_FLAG7:
case ACPI_DMT_FLAGS0:
+ case ACPI_DMT_FLAGS1:
case ACPI_DMT_FLAGS2:
+ case ACPI_DMT_FLAGS4:
case ACPI_DMT_LABEL:
+ case ACPI_DMT_EXTRA_TEXT:
ByteLength = 0;
break;
@@ -521,6 +526,7 @@ DtGetFieldLength (
case ACPI_DMT_ACCWIDTH:
case ACPI_DMT_IVRS:
case ACPI_DMT_MADT:
+ case ACPI_DMT_PMTT:
case ACPI_DMT_SRAT:
case ACPI_DMT_ASF:
case ACPI_DMT_HESTNTYP:
@@ -550,6 +556,11 @@ DtGetFieldLength (
ByteLength = 4;
break;
+ case ACPI_DMT_UINT40:
+ ByteLength = 5;
+ break;
+
+ case ACPI_DMT_UINT48:
case ACPI_DMT_NAME6:
ByteLength = 6;
break;
OpenPOWER on IntegriCloud