d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge ACPICA 20161117.

Browse Source
This commit is contained in:
Jung-uk Kim 2016-11-22 05:54:37 +00:00
commit 1cc50d6b6a
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=308953
53 changed files with 2194 additions and 1376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
sys/contrib/dev/acpica/changes.txt
View File

@ -1,3 +1,82 @@
----------------------------------------
17 November 2016. Summary of changes for version 20161117:
1) ACPICA kernel-resident subsystem:
Table Manager: Fixed a regression introduced in 20160729, "FADT support
cleanup". This was an attempt to remove all references in the source to
the FADT version 2, which never was a legal version number. It was
skipped because it was an early version of 64-bit support that was
eventually abandoned for the current 64-bit support.
Interpreter: Fixed a problem where runtime implicit conversion was
incorrectly disabled for the ASL operators below. This brings the
behavior into compliance with the ACPI specification:
FromBCD
ToBCD
ToDecimalString
ToHexString
ToInteger
ToBuffer
Table Manager: Added a new public interface, AcpiPutTable, used to
release and free an ACPI table returned by AcpiGetTable and related
interfaces. Lv Zheng.
Example Code and Data Size: These are the sizes for the OS-independent
acpica.lib produced by the Microsoft Visual C++ 9.0 32-bit compiler. The
debug version of the code includes the debug output trace mechanism and
has a much larger code and data size.
Current Release:
Non-Debug Version: 140.5K Code, 58.5K Data, 198.9K Total
Debug Version: 201.3K Code, 82.7K Data, 284.0K Total
Previous Release:
Non-Debug Version: 140.4K Code, 58.1K Data, 198.5K Total
Debug Version: 200.7K Code, 82.1K Data, 282.8K Total
2) iASL Compiler/Disassembler and Tools:
Disassembler: Fixed a regression for disassembly of Resource Template.
Detection of templates in the AML stream missed some types of templates.
iASL: Fixed a problem where an Access Size error was returned for the PCC
address space when the AccessSize of the GAS register is greater than a
DWORD. Hoan Tran.
iASL: Implemented several grammar changes for the operators below. These
changes are slated for the next version of the ACPI specification:
RefOf - Disallow method invocation as an operand
CondRefOf - Disallow method invocation as an operand
DerefOf - Disallow operands that use the result from operators
that
do not return a reference (Changed TermArg to
SuperName).
iASL: Control method invocations are now allowed for Target operands, as
per the ACPI specification. Removed error for using a control method
invocation as a Target operand.
Disassembler: Improved detection of Resource Templates, Unicode, and
Strings within Buffer objects. These subtypes do not contain a specific
opcode to indicate the originating ASL code, and they must be detected by
other means within the disassembler.
iASL: Implemented an optimization improvement for 32-bit ACPI tables
(DSDT/SSDT). For the 32-bit case only, compute the optimum integer opcode
only after 64-bit to 32-bit truncation. A truncation warning message is
still emitted, however.
AcpiXtract: Implemented handling for both types of line terminators (LF
or CR/LF) so that it can accept AcpiDump output files from any system.
Peter Wu.
AcpiBin: Added two new options for comparing AML files:
-a: compare and display ALL mismatches
-o: start compare at this offset into the second file
----------------------------------------
30 September 2016. Summary of changes for version 20160930:

24
sys/contrib/dev/acpica/common/acfileio.c
View File

@ -112,7 +112,7 @@ AcGetAllTablesFromFile (
if (FileSize == ACPI_UINT32_MAX)
{
Status = AE_ERROR;
goto ErrorExit;
goto Exit;
}
fprintf (stderr,
@ -124,7 +124,7 @@ AcGetAllTablesFromFile (
if (FileSize < sizeof (ACPI_TABLE_HEADER))
{
Status = AE_BAD_HEADER;
goto ErrorExit;
goto Exit;
}
/* Check for an non-binary file */
@ -134,7 +134,8 @@ AcGetAllTablesFromFile (
fprintf (stderr,
" %s: File does not appear to contain a valid AML table\n",
Filename);
return (AE_TYPE);
Status = AE_TYPE;
goto Exit;
}
/* Read all tables within the file */
@ -153,23 +154,31 @@ AcGetAllTablesFromFile (
}
else if (Status == AE_TYPE)
{
return (AE_OK);
Status = AE_OK;
goto Exit;
}
else if (ACPI_FAILURE (Status))
{
goto ErrorExit;
goto Exit;
}
/* Print table header for iASL/disassembler only */
#ifdef ACPI_ASL_COMPILER
AcpiTbPrintTableHeader (0, Table);
AcpiTbPrintTableHeader (0, Table);
#endif
/* Allocate and link a table descriptor */
TableDesc = AcpiOsAllocate (sizeof (ACPI_NEW_TABLE_DESC));
if (!TableDesc)
{
AcpiOsFree (Table);
Status = AE_NO_MEMORY;
goto Exit;
}
TableDesc->Table = Table;
TableDesc->Next = NULL;
@ -204,7 +213,7 @@ AcGetAllTablesFromFile (
*ReturnListHead = ListHead;
}
ErrorExit:
Exit:
fclose(File);
return (Status);
}
@ -262,7 +271,6 @@ AcGetOneTableFromFile (
return (Status);
}
if (GetOnlyAmlTables)
{
/*

194
sys/contrib/dev/acpica/common/dmtbdump.c
View File

@ -52,31 +52,12 @@
ACPI_MODULE_NAME ("dmtbdump")
/* Table of revision-dependent FADT sizes */
/* Local prototypes */
static const UINT32 FadtRevisionLength [ACPI_FADT_MAX_VERSION + 1] =
{
0, /* 0 - illegal */
ACPI_FADT_V1_SIZE, /* 1 - ACPI 1.0 */
0, /* 2 - illegal */
ACPI_FADT_V3_SIZE, /* 3 - ACPI 2.0 */
ACPI_FADT_V4_SIZE, /* 4 - ACPI 3.0 and ACPI 4.0 */
ACPI_FADT_V5_SIZE, /* 5 - ACPI 5.0 */
ACPI_FADT_V6_SIZE /* 6 - ACPI 6.0 */
};
/* Table of revision-dependent FADT info tables */
ACPI_DMTABLE_INFO *FadtRevisionInfo [ACPI_FADT_MAX_VERSION + 1] =
{
NULL, /* 0 - illegal */
AcpiDmTableInfoFadt1, /* 1 - ACPI 1.0 */
NULL, /* 2 - illegal */
AcpiDmTableInfoFadt3, /* 3 - ACPI 2.0 */
AcpiDmTableInfoFadt4, /* 4 - ACPI 3.0 and ACPI 4.0 */
AcpiDmTableInfoFadt5, /* 5 - ACPI 5.0 */
AcpiDmTableInfoFadt6 /* 6 - ACPI 6.0 */
};
static void
AcpiDmValidateFadtLength (
UINT32 Revision,
UINT32 Length);
/*******************************************************************************
@ -366,11 +347,6 @@ AcpiDmDumpXsdt (
*
* DESCRIPTION: Format the contents of a FADT
*
* Check the FADT revision against the expected table length for
* that revision. Issue a warning if the length is not what was
* expected. This seems to be such a common BIOS bug that the
* FADT revision has been rendered virtually meaningless.
*
* NOTE: We cannot depend on the FADT version to indicate the actual
* contents of the FADT because of BIOS bugs. The table length
* is the only reliable indicator.
@ -382,72 +358,142 @@ AcpiDmDumpFadt (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status;
UINT8 FadtRevision;
UINT32 ExpectedLength;
UINT32 i;
FadtRevision = Table->Revision;
/* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
/* FADT revision/length validation */
if ((FadtRevision == 0) ||
(FadtRevision == 2))
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
AcpiDmTableInfoFadt1);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf (
"// ACPI Warning: Invalid or unsupported FADT revision: %u\n",
FadtRevision);
return;
}
if (FadtRevision > ACPI_FADT_MAX_VERSION)
{
AcpiOsPrintf ("// ACPI Warning: Revision %u is not fully supported, "
"disassembling known fields (up to revision %u)\n\n",
FadtRevision, ACPI_FADT_MAX_VERSION);
}
else
{
ExpectedLength = FadtRevisionLength[FadtRevision];
if (Table->Length != ExpectedLength)
{
AcpiOsPrintf (
"// ACPI Warning: Input FADT revision %X does not match "
"expected length: found 0x%X expected 0x%X\n",
FadtRevision, Table->Length, ExpectedLength);
}
}
/* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
/*
* Dump the input table on a per-version basis, but is actually
* based upon the length of the table. Table length must
* be larger than the required length of the previous version.
*/
for (i = 1; i <= ACPI_FADT_MAX_VERSION; i++)
if ((Table->Length > ACPI_FADT_V1_SIZE) &&
(Table->Length <= ACPI_FADT_V2_SIZE))
{
if (!FadtRevisionLength[i]) /* Skip any empty slots */
{
continue;
}
/* Dump the fields specific to FADT revision[i] */
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
FadtRevisionInfo[i]);
AcpiDmTableInfoFadt2);
if (ACPI_FAILURE (Status))
{
return;
}
}
/* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */
else if (Table->Length > ACPI_FADT_V2_SIZE)
{
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
AcpiDmTableInfoFadt3);
if (ACPI_FAILURE (Status))
{
return;
}
if (Table->Length <= FadtRevisionLength[i])
/* Check for FADT revision 5 fields and up (ACPI 5.0+) */
if (Table->Length > ACPI_FADT_V3_SIZE)
{
break; /* End of table */
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
AcpiDmTableInfoFadt5);
if (ACPI_FAILURE (Status))
{
return;
}
}
/* Check for FADT revision 6 fields and up (ACPI 6.0+) */
if (Table->Length > ACPI_FADT_V3_SIZE)
{
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
AcpiDmTableInfoFadt6);
if (ACPI_FAILURE (Status))
{
return;
}
}
}
/* Build a local FADT to test some FADT values */
/* Validate various fields in the FADT, including length */
AcpiTbCreateLocalFadt (Table, Table->Length);
/* Validate FADT length against the revision */
AcpiDmValidateFadtLength (Table->Revision, Table->Length);
}
/*******************************************************************************
*
* FUNCTION: AcpiDmValidateFadtLength
*
* PARAMETERS: Revision - FADT revision (Header->Revision)
* Length - FADT length (Header->Length
*
* RETURN: None
*
* DESCRIPTION: Check the FADT revision against the expected table length for
* that revision. Issue a warning if the length is not what was
* expected. This seems to be such a common BIOS bug that the
* FADT revision has been rendered virtually meaningless.
*
******************************************************************************/
static void
AcpiDmValidateFadtLength (
UINT32 Revision,
UINT32 Length)
{
UINT32 ExpectedLength;
switch (Revision)
{
case 0:
AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
return;
case 1:
ExpectedLength = ACPI_FADT_V1_SIZE;
break;
case 2:
ExpectedLength = ACPI_FADT_V2_SIZE;
break;
case 3:
case 4:
ExpectedLength = ACPI_FADT_V3_SIZE;
break;
case 5:
ExpectedLength = ACPI_FADT_V5_SIZE;
break;
default:
return;
}
if (Length == ExpectedLength)
{
return;
}
AcpiOsPrintf (
"\n// ACPI Warning: FADT revision %X does not match length: "
"found %X expected %X\n",
Revision, Length, ExpectedLength);
}

28
sys/contrib/dev/acpica/common/dmtbinfo.c
View File

@ -400,7 +400,7 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoFacs[] =
*
******************************************************************************/
/* FADT version 1 (ACPI 1.0) */
/* ACPI 1.0 FADT (Version 1) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt1[] =
{
@ -486,7 +486,18 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoFadt1[] =
ACPI_DMT_TERMINATOR
};
/* FADT version 3 (ACPI 2.0) */
/* ACPI 1.0 MS Extensions (FADT version 2) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt2[] =
{
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (ResetRegister), "Reset Register", 0},
{ACPI_DMT_UINT8, ACPI_FADT_OFFSET (ResetValue), "Value to cause reset", 0},
{ACPI_DMT_UINT16, ACPI_FADT_OFFSET (ArmBootFlags), "Reserved", 0},
{ACPI_DMT_UINT8, ACPI_FADT_OFFSET (MinorRevision), "Reserved", 0},
ACPI_DMT_TERMINATOR
};
/* ACPI 2.0+ Extensions (FADT version 3, 4, and 5) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt3[] =
{
@ -510,23 +521,16 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoFadt3[] =
ACPI_DMT_TERMINATOR
};
/* FADT version 4 (ACPI 3.0 and ACPI 4.0) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt4[] =
{
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (SleepControl), "Sleep Control Register", 0},
ACPI_DMT_TERMINATOR
};
/* FADT version 5 (ACPI 5.0) */
/* ACPI 5.0 Extensions (FADT version 5) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt5[] =
{
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (SleepControl), "Sleep Control Register", 0},
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (SleepStatus), "Sleep Status Register", 0},
ACPI_DMT_TERMINATOR
};
/* FADT version 6 (ACPI 6.0) */
/* ACPI 6.0 Extensions (FADT version 6) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt6[] =
{

1
sys/contrib/dev/acpica/compiler/aslbtypes.c
View File

@ -151,7 +151,6 @@ AnMapArgTypeToBtype (
return (ACPI_BTYPE_DATA | ACPI_BTYPE_DEBUG_OBJECT |
ACPI_BTYPE_REFERENCE_OBJECT);
case ARGI_FIXED_TARGET:
case ARGI_SIMPLE_TARGET:
return (ACPI_BTYPE_OBJECTS_AND_REFS);

16
sys/contrib/dev/acpica/compiler/aslcompiler.l
View File

@ -156,8 +156,14 @@ NamePathTail [.]{NameSeg}
"^=" { count (3); return (PARSEOP_EXP_XOR_EQ); }
"|=" { count (3); return (PARSEOP_EXP_OR_EQ); }
"[" { count (3); return(PARSEOP_EXP_INDEX_LEFT); }
"]" { count (0); return(PARSEOP_EXP_INDEX_RIGHT); }
"[" { count (3); return (PARSEOP_EXP_INDEX_LEFT); }
"]" { count (0); return (PARSEOP_EXP_INDEX_RIGHT); }
"(" { count (0); return (PARSEOP_OPEN_PAREN); }
")" { count (0); return (PARSEOP_CLOSE_PAREN); }
"{" { count (0); return ('{'); }
"}" { count (0); return ('}'); }
"," { count (0); return (','); }
/*
@ -691,12 +697,6 @@ NamePathTail [.]{NameSeg}
"__PATH__" { count (0); return (PARSEOP___PATH__); }
"{" { count (0); return('{'); }
"}" { count (0); return('}'); }
"," { count (0); return(','); }
"(" { count (0); return('('); }
")" { count (0); return(')'); }
{NameSeg} { char *s;
count (0);
s=UtStringCacheCalloc (ACPI_NAME_SIZE + 1);

42
sys/contrib/dev/acpica/compiler/aslcstyle.y
View File

@ -149,21 +149,30 @@ Expression
/* Parentheses */
| '(' TermArg ')' { $$ = $2;}
| PARSEOP_OPEN_PAREN
Expression
PARSEOP_CLOSE_PAREN {$$ = $2;}
/* Index term -- "= BUF1[5]" on right-hand side of an equals (source) */
| SuperName PARSEOP_EXP_INDEX_LEFT
TermArg PARSEOP_EXP_INDEX_RIGHT {$$ = TrCreateLeafNode (PARSEOP_INDEX);
TrLinkChildren ($$,3,$1,$3,TrCreateNullTarget ());}
| IndexExpTerm
;
/* Index term -- "BUF1[5] = " on left-hand side of an equals (target) */
/*
* Index term -- "BUF1[5] = " or " = BUF1[5] on either the left side
* of an equals (target) or the right side (source)
* Currently used in these terms:
* Expression
* ObjectTypeSource
* DerefOfSource
* Type6Opcode
*/
IndexExpTerm
: SuperName PARSEOP_EXP_INDEX_LEFT
TermArg PARSEOP_EXP_INDEX_RIGHT {$$ = TrCreateLeafNode (PARSEOP_INDEX);
: SuperName
PARSEOP_EXP_INDEX_LEFT
TermArg
PARSEOP_EXP_INDEX_RIGHT {$$ = TrCreateLeafNode (PARSEOP_INDEX);
TrLinkChildren ($$,3,$1,$3,TrCreateNullTarget ());}
;
@ -177,11 +186,26 @@ IndexExpTerm
EqualsTerm
/* Allow parens anywhere */
: PARSEOP_OPEN_PAREN
EqualsTerm
PARSEOP_CLOSE_PAREN {$$ = $2;}
/* Simple Store() operation */
: SuperName PARSEOP_EXP_EQUALS
| SuperName
PARSEOP_EXP_EQUALS
TermArg {$$ = TrCreateAssignmentNode ($1, $3);}
/* Chained equals: (a=RefOf)=b, a=b=c=d etc. */
| PARSEOP_OPEN_PAREN
EqualsTerm
PARSEOP_CLOSE_PAREN
PARSEOP_EXP_EQUALS
TermArg {$$ = TrCreateAssignmentNode ($2, $5);}
/* Compound assignments -- Add (operand, operand, target) */
| TermArg PARSEOP_EXP_ADD_EQ {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);}

15
sys/contrib/dev/acpica/compiler/aslexternal.c
View File

@ -325,6 +325,7 @@ ExMoveExternals (
ACPI_PARSE_OBJECT *NextOp;
ACPI_PARSE_OBJECT *Prev;
ACPI_PARSE_OBJECT *Next;
char *ExternalName;
ACPI_OBJECT_TYPE ObjType;
UINT32 i;
@ -345,6 +346,12 @@ ExMoveExternals (
*/
ExternalOp = NextOp->Asl.Child;
/* Get/set the fully qualified name */
ExternalName = AcpiNsGetNormalizedPathname (ExternalOp->Asl.Node, TRUE);
ExternalOp->Asl.ExternalName = ExternalName;
ExternalOp->Asl.Namepath = ExternalName;
/* Set line numbers (for listings, etc.) */
ExternalOp->Asl.LineNumber = 0;
@ -354,6 +361,14 @@ ExMoveExternals (
Next->Asl.LineNumber = 0;
Next->Asl.LogicalLineNumber = 0;
if (Next->Asl.ParseOpcode == PARSEOP_NAMESEG)
{
Next->Asl.ParseOpcode = PARSEOP_NAMESTRING;
}
Next->Asl.ExternalName = ExternalName;
UtInternalizeName (ExternalName, &Next->Asl.Value.String);
Next->Asl.AmlLength = strlen (Next->Asl.Value.String);
Next = Next->Asl.Next;
Next->Asl.LineNumber = 0;
Next->Asl.LogicalLineNumber = 0;

15
sys/contrib/dev/acpica/compiler/aslkeywords.y
View File

@ -58,15 +58,18 @@ AccessAttribKeyword
| 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);}
| PARSEOP_ACCESSATTRIB_MULTIBYTE
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_MULTIBYTE);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_BYTES '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_BYTES);}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_BYTES
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_BYTES);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_PROCESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_PROCESS);}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_PROCESS
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_PROCESS);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,1,$4);}
;
AccessTypeKeyword

10
sys/contrib/dev/acpica/compiler/aslopcodes.c
View File

@ -289,7 +289,7 @@ OpcSetOptimalIntegerSize (
Op->Asl.AmlOpcode = AML_DWORD_OP;
return (4);
}
else
else /* 64-bit integer */
{
if (AcpiGbl_IntegerByteWidth == 4)
{
@ -299,8 +299,12 @@ OpcSetOptimalIntegerSize (
if (!Gbl_IgnoreErrors)
{
/* Truncate the integer to 32-bit */
Op->Asl.AmlOpcode = AML_DWORD_OP;
return (4);
Op->Asl.Value.Integer &= ACPI_UINT32_MAX;
/* Now set the optimal integer size */
return (OpcSetOptimalIntegerSize (Op));
}
}

1021
sys/contrib/dev/acpica/compiler/aslprimaries.y
View File

File diff suppressed because it is too large Load Diff

365
sys/contrib/dev/acpica/compiler/aslresources.y
View File

@ -56,7 +56,8 @@ NoEcho('
* Also, insert the EndTag at the end of the template.
*/
ResourceTemplateTerm
: PARSEOP_RESOURCETEMPLATE OptionalParentheses
: PARSEOP_RESOURCETEMPLATE
OptionalParentheses
'{'
ResourceMacroList '}' {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,4,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
@ -67,7 +68,8 @@ ResourceTemplateTerm
OptionalParentheses
: {$$ = NULL;}
| '(' ')' {$$ = NULL;}
| PARSEOP_OPEN_PAREN
PARSEOP_CLOSE_PAREN {$$ = NULL;}
;
ResourceMacroList
@ -116,19 +118,22 @@ ResourceMacroTerm
;
DMATerm
: PARSEOP_DMA '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DMA);}
: PARSEOP_DMA
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_DMA);}
DMATypeKeyword
OptionalBusMasterKeyword
',' XferTypeKeyword
OptionalNameString_Last
')' '{'
PARSEOP_CLOSE_PAREN '{'
ByteList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$5,$7,$8,$11);}
| PARSEOP_DMA '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_DMA
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
DWordIOTerm
: PARSEOP_DWORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDIO);}
: PARSEOP_DWORDIO
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDIO);}
OptionalResourceType_First
OptionalMinType
OptionalMaxType
@ -144,14 +149,16 @@ DWordIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,15,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
| PARSEOP_DWORDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_DWORDIO
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
DWordMemoryTerm
: PARSEOP_DWORDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDMEMORY);}
: PARSEOP_DWORDMEMORY
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDMEMORY);}
OptionalResourceType_First
OptionalDecodeType
OptionalMinType
@ -168,14 +175,16 @@ DWordMemoryTerm
OptionalNameString
OptionalAddressRange
OptionalType_Last
')' {$$ = TrLinkChildren ($<n>3,16,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,16,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
| PARSEOP_DWORDMEMORY '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_DWORDMEMORY
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
DWordSpaceTerm
: PARSEOP_DWORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDSPACE);}
: PARSEOP_DWORDSPACE
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDSPACE);}
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
OptionalResourceType
OptionalDecodeType
@ -190,21 +199,25 @@ DWordSpaceTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,14,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,14,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
| PARSEOP_DWORDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_DWORDSPACE
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
EndDependentFnTerm
: PARSEOP_ENDDEPENDENTFN '('
')' {$$ = TrCreateLeafNode (PARSEOP_ENDDEPENDENTFN);}
| PARSEOP_ENDDEPENDENTFN '('
error ')' {$$ = AslDoError(); yyclearin;}
: PARSEOP_ENDDEPENDENTFN
PARSEOP_OPEN_PAREN
PARSEOP_CLOSE_PAREN {$$ = TrCreateLeafNode (PARSEOP_ENDDEPENDENTFN);}
| PARSEOP_ENDDEPENDENTFN
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
ExtendedIOTerm
: PARSEOP_EXTENDEDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDIO);}
: PARSEOP_EXTENDEDIO
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDIO);}
OptionalResourceType_First
OptionalMinType
OptionalMaxType
@ -219,14 +232,16 @@ ExtendedIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,14,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,14,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);}
| PARSEOP_EXTENDEDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_EXTENDEDIO
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
ExtendedMemoryTerm
: PARSEOP_EXTENDEDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDMEMORY);}
: PARSEOP_EXTENDEDMEMORY
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDMEMORY);}
OptionalResourceType_First
OptionalDecodeType
OptionalMinType
@ -242,14 +257,15 @@ ExtendedMemoryTerm
OptionalNameString
OptionalAddressRange
OptionalType_Last
')' {$$ = TrLinkChildren ($<n>3,15,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);}
| PARSEOP_EXTENDEDMEMORY '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_EXTENDEDMEMORY
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
ExtendedSpaceTerm
: PARSEOP_EXTENDEDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDSPACE);}
: PARSEOP_EXTENDEDSPACE PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDSPACE);}
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
OptionalResourceType
OptionalDecodeType
@ -263,35 +279,41 @@ ExtendedSpaceTerm
',' QWordConstExpr
OptionalQWordConstExpr
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,13,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,13,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);}
| PARSEOP_EXTENDEDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_EXTENDEDSPACE
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
FixedDmaTerm
: PARSEOP_FIXEDDMA '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDDMA);}
: PARSEOP_FIXEDDMA
PARSEOP_OPEN_PAREN {$<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;}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,4,$4,$6,$7,$8);}
| PARSEOP_FIXEDDMA
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
FixedIOTerm
: PARSEOP_FIXEDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDIO);}
: PARSEOP_FIXEDIO
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDIO);}
WordConstExpr
',' ByteConstExpr
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
| PARSEOP_FIXEDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
| PARSEOP_FIXEDIO
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
GpioIntTerm
: PARSEOP_GPIO_INT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_INT);}
: PARSEOP_GPIO_INT
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_INT);}
InterruptTypeKeyword /* 04: InterruptType */
',' InterruptLevel /* 06: InterruptLevel */
OptionalShareType /* 07: SharedType */
@ -302,15 +324,17 @@ GpioIntTerm
OptionalResourceType /* 14: ResourceType */
OptionalNameString /* 15: DescriptorName */
OptionalBuffer_Last /* 16: VendorData */
')' '{'
PARSEOP_CLOSE_PAREN '{'
DWordConstExpr '}' {$$ = TrLinkChildren ($<n>3,11,
$4,$6,$7,$9,$10,$12,$13,$14,$15,$16,$19);}
| PARSEOP_GPIO_INT '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_GPIO_INT
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
GpioIoTerm
: PARSEOP_GPIO_IO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_IO);}
: PARSEOP_GPIO_IO
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_IO);}
OptionalShareType_First /* 04: SharedType */
',' PinConfigByte /* 06: PinConfig */
OptionalWordConstExpr /* 07: DebounceTimeout */
@ -321,15 +345,17 @@ GpioIoTerm
OptionalResourceType /* 13: ResourceType */
OptionalNameString /* 14: DescriptorName */
OptionalBuffer_Last /* 15: VendorData */
')' '{'
PARSEOP_CLOSE_PAREN '{'
DWordList '}' {$$ = TrLinkChildren ($<n>3,11,
$4,$6,$7,$8,$9,$11,$12,$13,$14,$15,$18);}
| PARSEOP_GPIO_IO '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_GPIO_IO
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
I2cSerialBusTerm
: PARSEOP_I2C_SERIALBUS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_I2C_SERIALBUS);}
: PARSEOP_I2C_SERIALBUS
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_I2C_SERIALBUS);}
WordConstExpr /* 04: SlaveAddress */
OptionalSlaveMode /* 05: SlaveMode */
',' DWordConstExpr /* 07: ConnectionSpeed */
@ -339,15 +365,17 @@ I2cSerialBusTerm
OptionalResourceType /* 12: ResourceType */
OptionalNameString /* 13: DescriptorName */
OptionalBuffer_Last /* 14: VendorData */
')' {$$ = TrLinkChildren ($<n>3,10,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,10,
$4,$5,$7,$8,$10,$11,$12,$13,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$14);}
| PARSEOP_I2C_SERIALBUS '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_I2C_SERIALBUS
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
I2cSerialBusTermV2
: PARSEOP_I2C_SERIALBUS_V2 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_I2C_SERIALBUS_V2);}
: PARSEOP_I2C_SERIALBUS_V2
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_I2C_SERIALBUS_V2);}
WordConstExpr /* 04: SlaveAddress */
OptionalSlaveMode /* 05: SlaveMode */
',' DWordConstExpr /* 07: ConnectionSpeed */
@ -358,14 +386,16 @@ I2cSerialBusTermV2
OptionalNameString /* 13: DescriptorName */
OptionalShareType /* 14: Share */
OptionalBuffer_Last /* 15: VendorData */
')' {$$ = TrLinkChildren ($<n>3,10,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,10,
$4,$5,$7,$8,$10,$11,$12,$13,$14,$15);}
| PARSEOP_I2C_SERIALBUS_V2 '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_I2C_SERIALBUS_V2
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
InterruptTerm
: PARSEOP_INTERRUPT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INTERRUPT);}
: PARSEOP_INTERRUPT
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_INTERRUPT);}
OptionalResourceType_First
',' InterruptTypeKeyword
',' InterruptLevel
@ -373,86 +403,100 @@ InterruptTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' '{'
PARSEOP_CLOSE_PAREN '{'
DWordList '}' {$$ = TrLinkChildren ($<n>3,8,
$4,$6,$8,$9,$10,$11,$12,$15);}
| PARSEOP_INTERRUPT '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_INTERRUPT
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
IOTerm
: PARSEOP_IO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IO);}
: PARSEOP_IO
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_IO);}
IODecodeKeyword
',' WordConstExpr
',' WordConstExpr
',' ByteConstExpr
',' ByteConstExpr
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
| PARSEOP_IO '('
error ')' {$$ = AslDoError(); yyclearin;}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
| PARSEOP_IO
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
IRQNoFlagsTerm
: PARSEOP_IRQNOFLAGS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IRQNOFLAGS);}
: PARSEOP_IRQNOFLAGS
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_IRQNOFLAGS);}
OptionalNameString_First
')' '{'
PARSEOP_CLOSE_PAREN '{'
ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_IRQNOFLAGS '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_IRQNOFLAGS
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
IRQTerm
: PARSEOP_IRQ '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IRQ);}
: PARSEOP_IRQ
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_IRQ);}
InterruptTypeKeyword
',' InterruptLevel
OptionalShareType
OptionalNameString_Last
')' '{'
PARSEOP_CLOSE_PAREN '{'
ByteList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$6,$7,$8,$11);}
| PARSEOP_IRQ '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_IRQ
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
Memory24Term
: PARSEOP_MEMORY24 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY24);}
: PARSEOP_MEMORY24
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY24);}
OptionalReadWriteKeyword
',' WordConstExpr
',' WordConstExpr
',' WordConstExpr
',' WordConstExpr
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
| PARSEOP_MEMORY24 '('
error ')' {$$ = AslDoError(); yyclearin;}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
| PARSEOP_MEMORY24
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
Memory32FixedTerm
: PARSEOP_MEMORY32FIXED '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32FIXED);}
: PARSEOP_MEMORY32FIXED
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32FIXED);}
OptionalReadWriteKeyword
',' DWordConstExpr
',' DWordConstExpr
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$9);}
| PARSEOP_MEMORY32FIXED '('
error ')' {$$ = AslDoError(); yyclearin;}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$9);}
| PARSEOP_MEMORY32FIXED
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
Memory32Term
: PARSEOP_MEMORY32 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32);}
: PARSEOP_MEMORY32
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32);}
OptionalReadWriteKeyword
',' DWordConstExpr
',' DWordConstExpr
',' DWordConstExpr
',' DWordConstExpr
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
| PARSEOP_MEMORY32 '('
error ')' {$$ = AslDoError(); yyclearin;}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
| PARSEOP_MEMORY32
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
QWordIOTerm
: PARSEOP_QWORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDIO);}
: PARSEOP_QWORDIO
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDIO);}
OptionalResourceType_First
OptionalMinType
OptionalMaxType
@ -468,14 +512,16 @@ QWordIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,15,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
| PARSEOP_QWORDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_QWORDIO
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
QWordMemoryTerm
: PARSEOP_QWORDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDMEMORY);}
: PARSEOP_QWORDMEMORY
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDMEMORY);}
OptionalResourceType_First
OptionalDecodeType
OptionalMinType
@ -492,14 +538,16 @@ QWordMemoryTerm
OptionalNameString
OptionalAddressRange
OptionalType_Last
')' {$$ = TrLinkChildren ($<n>3,16,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,16,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
| PARSEOP_QWORDMEMORY '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_QWORDMEMORY
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
QWordSpaceTerm
: PARSEOP_QWORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDSPACE);}
: PARSEOP_QWORDSPACE
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDSPACE);}
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
OptionalResourceType
OptionalDecodeType
@ -514,27 +562,31 @@ QWordSpaceTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,14,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,14,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
| PARSEOP_QWORDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_QWORDSPACE
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
RegisterTerm
: PARSEOP_REGISTER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REGISTER);}
: PARSEOP_REGISTER
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_REGISTER);}
AddressSpaceKeyword
',' ByteConstExpr
',' ByteConstExpr
',' QWordConstExpr
OptionalAccessSize
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$11,$12);}
| PARSEOP_REGISTER '('
error ')' {$$ = AslDoError(); yyclearin;}
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$11,$12);}
| PARSEOP_REGISTER
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
SpiSerialBusTerm
: PARSEOP_SPI_SERIALBUS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SPI_SERIALBUS);}
: PARSEOP_SPI_SERIALBUS
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_SPI_SERIALBUS);}
WordConstExpr /* 04: DeviceSelection */
OptionalDevicePolarity /* 05: DevicePolarity */
OptionalWireMode /* 06: WireMode */
@ -548,15 +600,17 @@ SpiSerialBusTerm
OptionalResourceType /* 19: ResourceType */
OptionalNameString /* 20: DescriptorName */
OptionalBuffer_Last /* 21: VendorData */
')' {$$ = TrLinkChildren ($<n>3,14,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,14,
$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$21);}
| PARSEOP_SPI_SERIALBUS '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_SPI_SERIALBUS
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
SpiSerialBusTermV2
: PARSEOP_SPI_SERIALBUS_V2 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SPI_SERIALBUS_V2);}
: PARSEOP_SPI_SERIALBUS_V2
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_SPI_SERIALBUS_V2);}
WordConstExpr /* 04: DeviceSelection */
OptionalDevicePolarity /* 05: DevicePolarity */
OptionalWireMode /* 06: WireMode */
@ -571,32 +625,38 @@ SpiSerialBusTermV2
OptionalNameString /* 20: DescriptorName */
OptionalShareType /* 21: Share */
OptionalBuffer_Last /* 22: VendorData */
')' {$$ = TrLinkChildren ($<n>3,14,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,14,
$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,$21,$22);}
| PARSEOP_SPI_SERIALBUS_V2 '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_SPI_SERIALBUS_V2
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
StartDependentFnNoPriTerm
: PARSEOP_STARTDEPENDENTFN_NOPRI '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);}
')' '{'
: PARSEOP_STARTDEPENDENTFN_NOPRI
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);}
PARSEOP_CLOSE_PAREN '{'
ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,1,$6);}
| PARSEOP_STARTDEPENDENTFN_NOPRI '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_STARTDEPENDENTFN_NOPRI
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
StartDependentFnTerm
: PARSEOP_STARTDEPENDENTFN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);}
: PARSEOP_STARTDEPENDENTFN
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);}
ByteConstExpr
',' ByteConstExpr
')' '{'
PARSEOP_CLOSE_PAREN '{'
ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$9);}
| PARSEOP_STARTDEPENDENTFN '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_STARTDEPENDENTFN
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
UartSerialBusTerm
: PARSEOP_UART_SERIALBUS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UART_SERIALBUS);}
: PARSEOP_UART_SERIALBUS
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_UART_SERIALBUS);}
DWordConstExpr /* 04: ConnectionSpeed */
OptionalBitsPerByte /* 05: BitsPerByte */
OptionalStopBits /* 06: StopBits */
@ -611,15 +671,17 @@ UartSerialBusTerm
OptionalResourceType /* 19: ResourceType */
OptionalNameString /* 20: DescriptorName */
OptionalBuffer_Last /* 21: VendorData */
')' {$$ = TrLinkChildren ($<n>3,15,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$21);}
| PARSEOP_UART_SERIALBUS '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_UART_SERIALBUS
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
UartSerialBusTermV2
: PARSEOP_UART_SERIALBUS_V2 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UART_SERIALBUS_V2);}
: PARSEOP_UART_SERIALBUS_V2
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_UART_SERIALBUS_V2);}
DWordConstExpr /* 04: ConnectionSpeed */
OptionalBitsPerByte /* 05: BitsPerByte */
OptionalStopBits /* 06: StopBits */
@ -635,32 +697,38 @@ UartSerialBusTermV2
OptionalNameString /* 20: DescriptorName */
OptionalShareType /* 21: Share */
OptionalBuffer_Last /* 22: VendorData */
')' {$$ = TrLinkChildren ($<n>3,15,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,$21,$22);}
| PARSEOP_UART_SERIALBUS_V2 '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_UART_SERIALBUS_V2
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
VendorLongTerm
: PARSEOP_VENDORLONG '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORLONG);}
: PARSEOP_VENDORLONG
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORLONG);}
OptionalNameString_First
')' '{'
PARSEOP_CLOSE_PAREN '{'
ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_VENDORLONG '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_VENDORLONG
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
VendorShortTerm
: PARSEOP_VENDORSHORT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORSHORT);}
: PARSEOP_VENDORSHORT
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORSHORT);}
OptionalNameString_First
')' '{'
PARSEOP_CLOSE_PAREN '{'
ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_VENDORSHORT '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_VENDORSHORT
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
WordBusNumberTerm
: PARSEOP_WORDBUSNUMBER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDBUSNUMBER);}
: PARSEOP_WORDBUSNUMBER
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_WORDBUSNUMBER);}
OptionalResourceType_First
OptionalMinType
OptionalMaxType
@ -673,14 +741,16 @@ WordBusNumberTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,12,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,12,
$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);}
| PARSEOP_WORDBUSNUMBER '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_WORDBUSNUMBER
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
WordIOTerm
: PARSEOP_WORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDIO);}
: PARSEOP_WORDIO
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_WORDIO);}
OptionalResourceType_First
OptionalMinType
OptionalMaxType
@ -696,14 +766,16 @@ WordIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,15,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
| PARSEOP_WORDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_WORDIO
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;
WordSpaceTerm
: PARSEOP_WORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDSPACE);}
: PARSEOP_WORDSPACE
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_WORDSPACE);}
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
OptionalResourceType
OptionalDecodeType
@ -718,8 +790,9 @@ WordSpaceTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,14,
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildren ($<n>3,14,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
| PARSEOP_WORDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_WORDSPACE
PARSEOP_OPEN_PAREN
error PARSEOP_CLOSE_PAREN {$$ = AslDoError(); yyclearin;}
;

5
sys/contrib/dev/acpica/compiler/aslrestype2.c
View File

@ -127,6 +127,11 @@ RsDoGeneralRegisterDescriptor (
RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE,
CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize));
if (Descriptor->GenericReg.AddressSpaceId == ACPI_ADR_SPACE_PLATFORM_COMM)
{
break;
}
if (Descriptor->GenericReg.AccessSize > AML_FIELD_ACCESS_QWORD)
{
AslError (ASL_ERROR, ASL_MSG_INVALID_ACCESS_SIZE,

161
sys/contrib/dev/acpica/compiler/aslrules.y
View File

@ -81,14 +81,15 @@ AslCode
* The ObjectList term is obsolete and has been removed.
*/
DefinitionBlockTerm
: PARSEOP_DEFINITION_BLOCK '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITION_BLOCK);}
: PARSEOP_DEFINITION_BLOCK
PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITION_BLOCK);}
String ','
String ','
ByteConst ','
String ','
String ','
DWordConst
')' {TrSetEndLineNumber ($<n>3);}
PARSEOP_CLOSE_PAREN {TrSetEndLineNumber ($<n>3);}
'{' TermList '}' {$$ = TrLinkChildren ($<n>3,7,
$4,$6,$8,$10,$12,$14,$18);}
;
@ -99,6 +100,9 @@ DefinitionBlockList
DefinitionBlockList {$$ = TrLinkPeerNodes (2, $1,$2);}
;
/******* Basic ASCII identifiers **************************************************/
/* Allow IO, DMA, IRQ Resource macro and FOR macro names to also be used as identifiers */
NameString
@ -112,20 +116,31 @@ NameString
/*
NameSeg
: PARSEOP_NAMESEG {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG, (ACPI_NATIVE_INT)
TrNormalizeNameSeg ($1));}
TrNormalizeNameSeg ($1));}
;
*/
NameSeg
: PARSEOP_NAMESEG {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
(ACPI_NATIVE_INT) AslCompilerlval.s);}
(ACPI_NATIVE_INT) AslCompilerlval.s);}
;
/******* Fundamental argument/statement types ***********************************/
Term
: Object {}
| Type1Opcode {}
| Type2Opcode {}
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2BufferOpcode {}
| Type2BufferOrStringOpcode {}
| error {$$ = AslDoError(); yyclearin;}
;
SuperName
: NameString {}
| ArgTerm {}
| LocalTerm {}
: SimpleName {}
| DebugTerm {}
| Type6Opcode {}
;
@ -136,14 +151,19 @@ Target
| ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
;
RequiredTarget
: ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
;
TermArg
: Type2Opcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
: SimpleName {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| Type2Opcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| DataObject {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| NameString {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| ArgTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| LocalTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
/*
| PARSEOP_OPEN_PAREN
TermArg
PARSEOP_CLOSE_PAREN {}
*/
;
/*
@ -156,8 +176,10 @@ TermArg
*/
MethodInvocationTerm
: NameString '(' {TrUpdateNode (PARSEOP_METHODCALL, $1);}
ArgList ')' {$$ = TrLinkChildNode ($1,$4);}
: NameString
PARSEOP_OPEN_PAREN {TrUpdateNode (PARSEOP_METHODCALL, $1);}
ArgList
PARSEOP_CLOSE_PAREN {$$ = TrLinkChildNode ($1,$4);}
;
/* OptionalCount must appear before ByteList or an incorrect reduction will result */
@ -176,23 +198,44 @@ OptionalDataCount
/* Legacy ASL */
: {$$ = NULL;}
| '(' TermArg ')' {$$ = $2;}
| '(' ')' {$$ = NULL;}
| PARSEOP_OPEN_PAREN
TermArg
PARSEOP_CLOSE_PAREN {$$ = $2;}
| PARSEOP_OPEN_PAREN
PARSEOP_CLOSE_PAREN {$$ = NULL;}
/* C-style (ASL+) -- adds equals term */
| PARSEOP_EXP_EQUALS {$$ = NULL;}
| '(' TermArg ')'
| PARSEOP_OPEN_PAREN
TermArg
PARSEOP_CLOSE_PAREN
PARSEOP_EXP_EQUALS {$$ = $2;}
| '(' ')' String
| PARSEOP_OPEN_PAREN
PARSEOP_CLOSE_PAREN
String
PARSEOP_EXP_EQUALS {$$ = NULL;}
;
/******* List Terms **************************************************/
/* ACPI 3.0 -- allow semicolons between terms */
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);}
;
ArgList
: {$$ = NULL;}
| TermArg
@ -299,38 +342,13 @@ OptionalParameterTypesPackage
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
;
/* ACPI 3.0 -- allow semicolons between terms */
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
: Object {}
| Type1Opcode {}
| Type2Opcode {}
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2BufferOpcode {}
| Type2BufferOrStringOpcode {}
| error {$$ = AslDoError(); yyclearin;}
;
/*
* Case-Default list; allow only one Default term and unlimited Case terms
*/
CaseDefaultTermList
: {$$ = NULL;}
| CaseTerm {}
| DefaultTerm {}
| CaseTerm {}
| DefaultTerm {}
| CaseDefaultTermList
CaseTerm {$$ = TrLinkPeerNode ($1,$2);}
| CaseDefaultTermList
@ -520,32 +538,59 @@ NameSpaceModifier
| ScopeTerm {}
;
/* For ObjectType: SuperName except for MethodInvocationTerm */
ObjectTypeName
SimpleName
: NameString {}
| ArgTerm {}
| LocalTerm {}
| ArgTerm {}
;
/* For ObjectType(), SuperName except for MethodInvocationTerm */
ObjectTypeSource
: SimpleName {}
| DebugTerm {}
| RefOfTerm {}
| DerefOfTerm {}
| IndexTerm {}
| IndexExpTerm {}
/* | MethodInvocationTerm {} */ /* Caused reduce/reduce with Type6Opcode->MethodInvocationTerm */
;
RequiredTarget
: ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
/* For DeRefOf(), SuperName except for DerefOf and Debug */
DerefOfSource
: SimpleName {}
| RefOfTerm {}
| DerefOfTerm {}
| IndexTerm {}
| IndexExpTerm {}
| StoreTerm {}
| EqualsTerm {}
| MethodInvocationTerm {}
;
SimpleTarget
: NameString {}
| LocalTerm {}
| ArgTerm {}
/* For RefOf(), SuperName except for RefOf and MethodInvocationTerm */
RefOfSource
: SimpleName {}
| DebugTerm {}
| DerefOfTerm {}
| IndexTerm {}
| IndexExpTerm {}
;
/* Opcode types */
/* For CondRefOf(), SuperName except for RefOf and MethodInvocationTerm */
CondRefOfSource
: SimpleName {}
| DebugTerm {}
| DerefOfTerm {}
| IndexTerm {}
| IndexExpTerm {}
;
/*
* Opcode types, as defined in the ACPI specification
*/
Type1Opcode
: BreakTerm {}
| BreakPointTerm {}

3
sys/contrib/dev/acpica/compiler/aslstubs.c
View File

@ -188,8 +188,7 @@ AcpiEvReleaseGlobalLock (
ACPI_STATUS
AcpiEvInitializeRegion (
ACPI_OPERAND_OBJECT *RegionObj,
BOOLEAN AcpiNsLocked)
ACPI_OPERAND_OBJECT *RegionObj)
{
return (AE_OK);
}

3
sys/contrib/dev/acpica/compiler/asltokens.y
View File

@ -465,6 +465,9 @@ NoEcho('
%left <i> PARSEOP_EXP_INCREMENT
PARSEOP_EXP_DECREMENT
%left <i> PARSEOP_OPEN_PAREN
PARSEOP_CLOSE_PAREN
/* Brackets for Index() support */
%left <i> PARSEOP_EXP_INDEX_LEFT

7
sys/contrib/dev/acpica/compiler/asltypes.y
View File

@ -68,7 +68,7 @@ NoEcho('
%type <n> ParameterTypesPackage
%type <n> ParameterTypesPackageList
%type <n> RequiredTarget
%type <n> SimpleTarget
%type <n> SimpleName
%type <n> StringData
%type <n> Target
%type <n> Term
@ -252,7 +252,10 @@ NoEcho('
/* Types */
%type <n> SuperName
%type <n> ObjectTypeName
%type <n> ObjectTypeSource
%type <n> DerefOfSource
%type <n> RefOfSource
%type <n> CondRefOfSource
%type <n> ArgTerm
%type <n> LocalTerm
%type <n> DebugTerm

13
sys/contrib/dev/acpica/compiler/aslwalks.c
View File

@ -862,21 +862,10 @@ AnAnalyzeStoreOperator (
case PARSEOP_DEREFOF:
case PARSEOP_REFOF:
case PARSEOP_INDEX:
case PARSEOP_STORE:
return;
case PARSEOP_METHODCALL:
/*
* A target is not allowed to be a method call.
* It is not supported by the ACPICA interpreter, nor is it
* supported by the MS ASL compiler or the MS interpreter.
* Although legal syntax up until ACPI 6.1, support for this
* will be removed for ACPI 6.2 (02/2016)
*/
AslError (ASL_ERROR, ASL_MSG_SYNTAX,
TargetOperandOp, "Illegal method invocation as a target operand");
return;
default:
break;
}

76
sys/contrib/dev/acpica/compiler/dttable.c
View File

@ -129,12 +129,9 @@ DtCompileFadt (
DT_SUBTABLE *ParentTable;
DT_FIELD **PFieldList = (DT_FIELD **) List;
ACPI_TABLE_HEADER *Table;
UINT8 FadtRevision;
UINT32 i;
UINT8 Revision;
/* Minimum table is the FADT version 1 (ACPI 1.0) */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt1,
&Subtable, TRUE);
if (ACPI_FAILURE (Status))
@ -146,41 +143,11 @@ DtCompileFadt (
DtInsertSubtable (ParentTable, Subtable);
Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer);
FadtRevision = Table->Revision;
Revision = Table->Revision;
/* Revision 0 and 2 are illegal */
if ((FadtRevision == 0) ||
(FadtRevision == 2))
if (Revision == 2)
{
DtError (ASL_ERROR, 0, NULL,
"Invalid value for FADT revision");
return (AE_BAD_VALUE);
}
/* Revision out of supported range? */
if (FadtRevision > ACPI_FADT_MAX_VERSION)
{
DtError (ASL_ERROR, 0, NULL,
"Unknown or unsupported value for FADT revision");
return (AE_BAD_VALUE);
}
/* Compile individual sub-parts of the FADT, per-revision */
for (i = 3; i <= ACPI_FADT_MAX_VERSION; i++)
{
if (i > FadtRevision)
{
break;
}
/* Compile the fields specific to this FADT revision */
Status = DtCompileTable (PFieldList, FadtRevisionInfo[i],
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt2,
&Subtable, TRUE);
if (ACPI_FAILURE (Status))
{
@ -189,6 +156,41 @@ DtCompileFadt (
DtInsertSubtable (ParentTable, Subtable);
}
else if (Revision >= 2)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt3,
&Subtable, TRUE);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtInsertSubtable (ParentTable, Subtable);
if (Revision >= 5)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt5,
&Subtable, TRUE);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtInsertSubtable (ParentTable, Subtable);
}
if (Revision >= 6)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt6,
&Subtable, TRUE);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtInsertSubtable (ParentTable, Subtable);
}
}
return (AE_OK);
}

27
sys/contrib/dev/acpica/components/disassembler/dmbuffer.c
View File

@ -439,12 +439,16 @@ AcpiDmIsUnicodeBuffer (
return (FALSE);
}
/* For each word, 1st byte must be ascii (1-0x7F), 2nd byte must be zero */
/*
* For each word, 1st byte must be printable ascii, and the
* 2nd byte must be zero. This does not allow for escape
* sequences, but it is the most secure way to detect a
* unicode string.
*/
for (i = 0; i < (ByteCount - 2); i += 2)
{
if ((ByteData[i] == 0) ||
(ByteData[i] > 0x7F) ||
!(isprint (ByteData[i])) ||
(ByteData[(ACPI_SIZE) i + 1] != 0))
{
return (FALSE);
@ -507,12 +511,27 @@ AcpiDmIsStringBuffer (
return (FALSE);
}
/*
* Check for a possible standalone resource EndTag, ignore it
* here. However, this sequence is also the string "Y", but
* this seems rare enough to be acceptable.
*/
if ((ByteCount == 2) && (ByteData[0] == 0x79))
{
return (FALSE);
}
/* Check all bytes for ASCII */
for (i = 0; i < (ByteCount - 1); i++)
{
/* TBD: allow some escapes (non-ascii chars).
/*
* TBD: allow some escapes (non-ascii chars).
* they will be handled in the string output routine
*/
/* Not a string if not printable ascii */
if (!isprint (ByteData[i]))
{
return (FALSE);

352
sys/contrib/dev/acpica/components/disassembler/dmcstyle.c
View File

@ -73,6 +73,11 @@ AcpiDmIsTargetAnOperand (
ACPI_PARSE_OBJECT *Operand,
BOOLEAN TopLevel);
static BOOLEAN
AcpiDmIsOptimizationIgnored (
ACPI_PARSE_OBJECT *StoreOp,
ACPI_PARSE_OBJECT *StoreArgument);
/*******************************************************************************
*
@ -95,12 +100,10 @@ AcpiDmCheckForSymbolicOpcode (
ACPI_OP_WALK_INFO *Info)
{
char *OperatorSymbol = NULL;
ACPI_PARSE_OBJECT *Child1;
ACPI_PARSE_OBJECT *Child2;
ACPI_PARSE_OBJECT *Argument1;
ACPI_PARSE_OBJECT *Argument2;
ACPI_PARSE_OBJECT *Target;
ACPI_PARSE_OBJECT *GrandChild1;
ACPI_PARSE_OBJECT *GrandChild2;
ACPI_PARSE_OBJECT *GrandTarget = NULL;
ACPI_PARSE_OBJECT *Target2;
/* Exit immediately if ASL+ not enabled */
@ -110,25 +113,17 @@ AcpiDmCheckForSymbolicOpcode (
return (FALSE);
}
/* Check for a non-ASL+ statement, propagate the flag */
if (Op->Common.Parent->Common.DisasmFlags & ACPI_PARSEOP_LEGACY_ASL_ONLY)
{
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
/* Get the first operand */
Child1 = AcpiPsGetArg (Op, 0);
if (!Child1)
Argument1 = AcpiPsGetArg (Op, 0);
if (!Argument1)
{
return (FALSE);
}
/* Get the second operand */
Child2 = Child1->Common.Next;
Argument2 = Argument1->Common.Next;
/* Setup the operator string for this opcode */
@ -202,7 +197,7 @@ AcpiDmCheckForSymbolicOpcode (
* LNotEqual, LLessEqual, and LGreaterEqual. There are
* no actual AML opcodes for these operators.
*/
switch (Child1->Common.AmlOpcode)
switch (Argument1->Common.AmlOpcode)
{
case AML_LEQUAL_OP:
OperatorSymbol = " != ";
@ -224,19 +219,18 @@ AcpiDmCheckForSymbolicOpcode (
return (TRUE);
}
Child1->Common.DisasmOpcode = ACPI_DASM_LNOT_SUFFIX;
Argument1->Common.DisasmOpcode = ACPI_DASM_LNOT_SUFFIX;
Op->Common.DisasmOpcode = ACPI_DASM_LNOT_PREFIX;
Op->Common.DisasmFlags |= ACPI_PARSEOP_COMPOUND_ASSIGNMENT;
/* Save symbol string in the next child (not peer) */
Child2 = AcpiPsGetArg (Child1, 0);
if (!Child2)
Argument2 = AcpiPsGetArg (Argument1, 0);
if (!Argument2)
{
return (FALSE);
}
Child2->Common.OperatorSymbol = OperatorSymbol;
Argument2->Common.OperatorSymbol = OperatorSymbol;
return (TRUE);
case AML_INDEX_OP:
@ -246,10 +240,10 @@ AcpiDmCheckForSymbolicOpcode (
* the symbolic operators for Index(). It doesn't make sense to
* use Index() with a constant anyway.
*/
if ((Child1->Common.AmlOpcode == AML_STRING_OP) ||
(Child1->Common.AmlOpcode == AML_BUFFER_OP) ||
(Child1->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Child1->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
if ((Argument1->Common.AmlOpcode == AML_STRING_OP) ||
(Argument1->Common.AmlOpcode == AML_BUFFER_OP) ||
(Argument1->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Argument1->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
{
Op->Common.DisasmFlags |= ACPI_PARSEOP_CLOSING_PAREN;
return (FALSE);
@ -257,8 +251,8 @@ AcpiDmCheckForSymbolicOpcode (
/* Index operator is [] */
Child1->Common.OperatorSymbol = " [";
Child2->Common.OperatorSymbol = "]";
Argument1->Common.OperatorSymbol = " [";
Argument2->Common.OperatorSymbol = "]";
break;
/* Unary operators */
@ -280,7 +274,7 @@ AcpiDmCheckForSymbolicOpcode (
return (FALSE);
}
if (Child1->Common.DisasmOpcode == ACPI_DASM_LNOT_SUFFIX)
if (Argument1->Common.DisasmOpcode == ACPI_DASM_LNOT_SUFFIX)
{
return (TRUE);
}
@ -291,9 +285,9 @@ AcpiDmCheckForSymbolicOpcode (
* deferring symbol output until after the first operand has been
* emitted.
*/
if (!Child1->Common.OperatorSymbol)
if (!Argument1->Common.OperatorSymbol)
{
Child1->Common.OperatorSymbol = OperatorSymbol;
Argument1->Common.OperatorSymbol = OperatorSymbol;
}
/*
@ -323,23 +317,58 @@ AcpiDmCheckForSymbolicOpcode (
/* Target is 3rd operand */
Target = Child2->Common.Next;
Target = Argument2->Common.Next;
if (Op->Common.AmlOpcode == AML_DIVIDE_OP)
{
Target2 = Target->Common.Next;
/*
* Divide has an extra target operand (Remainder).
* If this extra target is specified, it cannot be converted
* to a C-style operator
* Default behavior is to simply ignore ASL+ conversion
* if the remainder target (modulo) is specified.
*/
if (AcpiDmIsValidTarget (Target))
if (!AcpiGbl_DoDisassemblerOptimizations)
{
Child1->Common.OperatorSymbol = NULL;
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
if (AcpiDmIsValidTarget (Target))
{
Argument1->Common.OperatorSymbol = NULL;
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
Target->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
Target = Target->Common.Next;
Target->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
Target = Target2;
}
else
{
/*
* Divide has an extra target operand (Remainder).
* If both targets are specified, it cannot be converted
* to a C-style operator.
*/
if (AcpiDmIsValidTarget (Target) &&
AcpiDmIsValidTarget (Target2))
{
Argument1->Common.OperatorSymbol = NULL;
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
if (AcpiDmIsValidTarget (Target)) /* Only first Target is valid (remainder) */
{
/* Convert the Divide to Modulo */
Op->Common.AmlOpcode = AML_MOD_OP;
Argument1->Common.OperatorSymbol = " % ";
Target2->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
}
else /* Only second Target (quotient) is valid */
{
Target->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
Target = Target2;
}
}
}
/* Parser should ensure there is at least a placeholder target */
@ -351,13 +380,6 @@ AcpiDmCheckForSymbolicOpcode (
if (!AcpiDmIsValidTarget (Target))
{
if (Op->Common.Parent->Common.AmlOpcode == AML_STORE_OP)
{
Op->Common.DisasmFlags = 0;
Child1->Common.OperatorSymbol = NULL;
return (FALSE);
}
/* Not a valid target (placeholder only, from parser) */
break;
}
@ -390,8 +412,8 @@ AcpiDmCheckForSymbolicOpcode (
* Add (B, A, A) --> A += B
* Add (B, C, A) --> A = (B + C)
*/
if ((AcpiDmIsTargetAnOperand (Target, Child1, TRUE)) ||
(AcpiDmIsTargetAnOperand (Target, Child2, TRUE)))
if ((AcpiDmIsTargetAnOperand (Target, Argument1, TRUE)) ||
(AcpiDmIsTargetAnOperand (Target, Argument2, TRUE)))
{
Target->Common.OperatorSymbol =
AcpiDmGetCompoundSymbol (Op->Common.AmlOpcode);
@ -399,7 +421,7 @@ AcpiDmCheckForSymbolicOpcode (
/* Convert operator to compound assignment */
Op->Common.DisasmFlags |= ACPI_PARSEOP_COMPOUND_ASSIGNMENT;
Child1->Common.OperatorSymbol = NULL;
Argument1->Common.OperatorSymbol = NULL;
return (TRUE);
}
break;
@ -419,7 +441,7 @@ AcpiDmCheckForSymbolicOpcode (
* Subtract (A, B, A) --> A -= B
* Subtract (B, A, A) --> A = (B - A)
*/
if ((AcpiDmIsTargetAnOperand (Target, Child1, TRUE)))
if ((AcpiDmIsTargetAnOperand (Target, Argument1, TRUE)))
{
Target->Common.OperatorSymbol =
AcpiDmGetCompoundSymbol (Op->Common.AmlOpcode);
@ -427,7 +449,7 @@ AcpiDmCheckForSymbolicOpcode (
/* Convert operator to compound assignment */
Op->Common.DisasmFlags |= ACPI_PARSEOP_COMPOUND_ASSIGNMENT;
Child1->Common.OperatorSymbol = NULL;
Argument1->Common.OperatorSymbol = NULL;
return (TRUE);
}
break;
@ -481,7 +503,7 @@ AcpiDmCheckForSymbolicOpcode (
/* Target is optional, 3rd operand */
Target = Child2->Common.Next;
Target = Argument2->Common.Next;
if (AcpiDmIsValidTarget (Target))
{
AcpiDmPromoteTarget (Op, Target);
@ -495,75 +517,23 @@ AcpiDmCheckForSymbolicOpcode (
case AML_STORE_OP:
/*
* Target is the 2nd operand.
* We know the target is valid, it is not optional.
* For Store, the Target is the 2nd operand. We know the target
* is valid, because it is not optional.
*
* The following block implements "Ignore conversion if a store
* is followed by a math/bit operator that has no target". Used
* only for the ASL test suite.
* Ignore any optimizations/folding if flag is set.
* Used for iASL/disassembler test suite only.
*/
if (!AcpiGbl_DoDisassemblerOptimizations)
if (AcpiDmIsOptimizationIgnored (Op, Argument1))
{
switch (Child1->Common.AmlOpcode)
{
/* This operator has two operands and two targets */
case AML_DIVIDE_OP:
GrandChild1 = Child1->Common.Value.Arg;
GrandChild2 = GrandChild1->Common.Next;
GrandTarget = GrandChild2->Common.Next;
if (GrandTarget && !AcpiDmIsValidTarget (GrandTarget))
{
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
GrandTarget = GrandTarget->Common.Next;
break;
case AML_ADD_OP:
case AML_SUBTRACT_OP:
case AML_MULTIPLY_OP:
case AML_MOD_OP:
case AML_SHIFT_LEFT_OP:
case AML_SHIFT_RIGHT_OP:
case AML_BIT_AND_OP:
case AML_BIT_OR_OP:
case AML_BIT_XOR_OP:
case AML_INDEX_OP:
/* These operators have two operands and a target */
GrandChild1 = Child1->Common.Value.Arg;
GrandChild2 = GrandChild1->Common.Next;
GrandTarget = GrandChild2->Common.Next;
break;
case AML_BIT_NOT_OP:
/* This operator has one operand and a target */
GrandChild1 = Child1->Common.Value.Arg;
GrandTarget = GrandChild1->Common.Next;
break;
default:
break;
}
if (GrandTarget && !AcpiDmIsValidTarget (GrandTarget))
{
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
return (FALSE);
}
/*
* Perform conversion.
* In the parse tree, simply swap the target with the
* source so that the target is processed first.
*/
Target = Child1->Common.Next;
Target = Argument1->Common.Next;
if (!Target)
{
return (FALSE);
@ -580,7 +550,7 @@ AcpiDmCheckForSymbolicOpcode (
/* Target is optional, 2nd operand */
Target = Child1->Common.Next;
Target = Argument1->Common.Next;
if (!Target)
{
return (FALSE);
@ -605,19 +575,6 @@ AcpiDmCheckForSymbolicOpcode (
break;
}
/*
* Nodes marked with ACPI_PARSEOP_PARAMLIST don't need a parens
* output here. We also need to check the parent to see if this op
* is part of a compound test (!=, >=, <=).
*/
if ((Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST) ||
((Op->Common.Parent->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST) &&
(Op->Common.DisasmOpcode == ACPI_DASM_LNOT_SUFFIX)))
{
/* Do Nothing. Paren already generated */
return (TRUE);
}
/* All other operators, emit an open paren */
AcpiOsPrintf ("(");
@ -625,6 +582,125 @@ AcpiDmCheckForSymbolicOpcode (
}
/*******************************************************************************
*
* FUNCTION: AcpiDmIsOptimizationIgnored
*
* PARAMETERS: StoreOp - Store operator parse object
* StoreArgument - Target associate with the Op
*
* RETURN: TRUE if this Store operator should not be converted/removed.
*
* DESCRIPTION: The following function implements "Do not optimize if a
* store is immediately followed by a math/bit operator that
* has no target".
*
* Function is ignored if DoDisassemblerOptimizations is TRUE.
* This is the default, ignore this function.
*
* Disables these types of optimizations, and simply emits
* legacy ASL code:
* Store (Add (INT1, 4), INT2) --> Add (INT1, 4, INT2)
* --> INT2 = INT1 + 4
*
* Store (Not (INT1), INT2) --> Not (INT1, INT2)
* --> INT2 = ~INT1
*
* Used only for the ASL test suite. For the test suite, we
* don't want to perform some optimizations to ensure binary
* compatibility with the generation of the legacy ASL->AML.
* In other words, for all test modules we want exactly:
* (ASL+ -> AML) == (ASL- -> AML)
*
******************************************************************************/
static BOOLEAN
AcpiDmIsOptimizationIgnored (
ACPI_PARSE_OBJECT *StoreOp,
ACPI_PARSE_OBJECT *StoreArgument)
{
ACPI_PARSE_OBJECT *Argument1;
ACPI_PARSE_OBJECT *Argument2;
ACPI_PARSE_OBJECT *Target;
/* No optimizations/folding for the typical case */
if (AcpiGbl_DoDisassemblerOptimizations)
{
return (FALSE);
}
/*
* Only a small subset of ASL/AML operators can be optimized.
* Can only optimize/fold if there is no target (or targets)
* specified for the operator. And of course, the operator
* is surrrounded by a Store() operator.
*/
switch (StoreArgument->Common.AmlOpcode)
{
case AML_ADD_OP:
case AML_SUBTRACT_OP:
case AML_MULTIPLY_OP:
case AML_MOD_OP:
case AML_SHIFT_LEFT_OP:
case AML_SHIFT_RIGHT_OP:
case AML_BIT_AND_OP:
case AML_BIT_OR_OP:
case AML_BIT_XOR_OP:
case AML_INDEX_OP:
/* These operators have two arguments and one target */
Argument1 = StoreArgument->Common.Value.Arg;
Argument2 = Argument1->Common.Next;
Target = Argument2->Common.Next;
if (!AcpiDmIsValidTarget (Target))
{
StoreOp->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (TRUE);
}
break;
case AML_DIVIDE_OP:
/* This operator has two arguments and two targets */
Argument1 = StoreArgument->Common.Value.Arg;
Argument2 = Argument1->Common.Next;
Target = Argument2->Common.Next;
if (!AcpiDmIsValidTarget (Target) ||
!AcpiDmIsValidTarget (Target->Common.Next))
{
StoreOp->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (TRUE);
}
break;
case AML_BIT_NOT_OP:
/* This operator has one operand and one target */
Argument1 = StoreArgument->Common.Value.Arg;
Target = Argument1->Common.Next;
if (!AcpiDmIsValidTarget (Target))
{
StoreOp->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (TRUE);
}
break;
default:
break;
}
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: AcpiDmCloseOperator
@ -643,8 +719,6 @@ void
AcpiDmCloseOperator (
ACPI_PARSE_OBJECT *Op)
{
BOOLEAN IsCStyleOp = FALSE;
/* Always emit paren if ASL+ disassembly disabled */
@ -654,8 +728,6 @@ AcpiDmCloseOperator (
return;
}
/* Check for a non-ASL+ statement */
if (Op->Common.DisasmFlags & ACPI_PARSEOP_LEGACY_ASL_ONLY)
{
AcpiOsPrintf (")");
@ -695,8 +767,6 @@ AcpiDmCloseOperator (
{
AcpiOsPrintf (")");
}
IsCStyleOp = TRUE;
break;
case AML_INDEX_OP:
@ -724,21 +794,7 @@ AcpiDmCloseOperator (
break;
}
/*
* Nodes marked with ACPI_PARSEOP_PARAMLIST don't need a parens
* output here. We also need to check the parent to see if this op
* is part of a compound test (!=, >=, <=).
*/
if (IsCStyleOp &&
((Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST) ||
((Op->Common.Parent->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST) &&
(Op->Common.DisasmOpcode == ACPI_DASM_LNOT_SUFFIX))))
{
return;
}
AcpiOsPrintf (")");
return;
}

30
sys/contrib/dev/acpica/components/disassembler/dmresrc.c
View File

@ -392,7 +392,8 @@ AcpiDmIsResourceTemplate (
ACPI_PARSE_OBJECT *NextOp;
UINT8 *Aml;
UINT8 *EndAml;
ACPI_SIZE Length;
UINT32 BufferLength;
UINT32 DeclaredBufferLength;
/* This op must be a buffer */
@ -402,8 +403,10 @@ AcpiDmIsResourceTemplate (
return (AE_TYPE);
}
/* Get the ByteData list and length */
/*
* Get the declared length of the buffer.
* This is the nn in "Buffer (nn)"
*/
NextOp = Op->Common.Value.Arg;
if (!NextOp)
{
@ -411,6 +414,10 @@ AcpiDmIsResourceTemplate (
return (AE_TYPE);
}
DeclaredBufferLength = NextOp->Common.Value.Size;
/* Get the length of the raw initialization byte list */
NextOp = NextOp->Common.Next;
if (!NextOp)
{
@ -418,11 +425,22 @@ AcpiDmIsResourceTemplate (
}
Aml = NextOp->Named.Data;
Length = (ACPI_SIZE) NextOp->Common.Value.Integer;
BufferLength = NextOp->Common.Value.Size;
/*
* Not a template if declared buffer length != actual length of the
* intialization byte list. Because the resource macros will create
* a buffer of the exact required length (buffer length will be equal
* to the actual length).
*/
if (DeclaredBufferLength != BufferLength)
{
return (AE_TYPE);
}
/* Walk the byte list, abort on any invalid descriptor type or length */
Status = AcpiUtWalkAmlResources (WalkState, Aml, Length,
Status = AcpiUtWalkAmlResources (WalkState, Aml, BufferLength,
NULL, ACPI_CAST_INDIRECT_PTR (void, &EndAml));
if (ACPI_FAILURE (Status))
{
@ -435,7 +453,7 @@ AcpiDmIsResourceTemplate (
* of a ResourceTemplate, the buffer must not have any extra data after
* the EndTag.)
*/
if ((Aml + Length - sizeof (AML_RESOURCE_END_TAG)) != EndAml)
if ((Aml + BufferLength - sizeof (AML_RESOURCE_END_TAG)) != EndAml)
{
return (AE_AML_NO_RESOURCE_END_TAG);
}

10
sys/contrib/dev/acpica/components/dispatcher/dsinit.c
View File

@ -46,6 +46,7 @@
#include <contrib/dev/acpica/include/acdispat.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/actables.h>
#include <contrib/dev/acpica/include/acinterp.h>
#define _COMPONENT ACPI_DISPATCHER
ACPI_MODULE_NAME ("dsinit")
@ -231,23 +232,16 @@ AcpiDsInitializeObjects (
/* Walk entire namespace from the supplied root */
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/*
* We don't use AcpiWalkNamespace since we do not want to acquire
* the namespace reader lock.
*/
Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, StartNode, ACPI_UINT32_MAX,
ACPI_NS_WALK_UNLOCK, AcpiDsInitOneObject, NULL, &Info, NULL);
ACPI_NS_WALK_NO_UNLOCK, AcpiDsInitOneObject, NULL, &Info, NULL);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During WalkNamespace"));
}
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
Status = AcpiGetTableByIndex (TableIndex, &Table);
if (ACPI_FAILURE (Status))

50
sys/contrib/dev/acpica/components/dispatcher/dsmethod.c
View File

@ -107,15 +107,12 @@ AcpiDsAutoSerializeMethod (
"Method auto-serialization parse [%4.4s] %p\n",
AcpiUtGetNodeName (Node), Node));
AcpiExEnterInterpreter ();
/* Create/Init a root op for the method parse tree */
Op = AcpiPsAllocOp (AML_METHOD_OP, ObjDesc->Method.AmlStart);
if (!Op)
{
Status = AE_NO_MEMORY;
goto Unlock;
return_ACPI_STATUS (AE_NO_MEMORY);
}
AcpiPsSetName (Op, Node->Name.Integer);
@ -127,8 +124,7 @@ AcpiDsAutoSerializeMethod (
if (!WalkState)
{
AcpiPsFreeOp (Op);
Status = AE_NO_MEMORY;
goto Unlock;
return_ACPI_STATUS (AE_NO_MEMORY);
}
Status = AcpiDsInitAmlWalk (WalkState, Op, Node,
@ -147,8 +143,6 @@ AcpiDsAutoSerializeMethod (
Status = AcpiPsParseAml (WalkState);
AcpiPsDeleteParseTree (Op);
Unlock:
AcpiExExitInterpreter ();
return_ACPI_STATUS (Status);
}
@ -783,26 +777,6 @@ AcpiDsTerminateControlMethod (
AcpiDsMethodDataDeleteAll (WalkState);
/*
* If method is serialized, release the mutex and restore the
* current sync level for this thread
*/
if (MethodDesc->Method.Mutex)
{
/* Acquisition Depth handles recursive calls */
MethodDesc->Method.Mutex->Mutex.AcquisitionDepth--;
if (!MethodDesc->Method.Mutex->Mutex.AcquisitionDepth)
{
WalkState->Thread->CurrentSyncLevel =
MethodDesc->Method.Mutex->Mutex.OriginalSyncLevel;
AcpiOsReleaseMutex (
MethodDesc->Method.Mutex->Mutex.OsMutex);
MethodDesc->Method.Mutex->Mutex.ThreadId = 0;
}
}
/*
* Delete any namespace objects created anywhere within the
* namespace by the execution of this method. Unless:
@ -836,6 +810,26 @@ AcpiDsTerminateControlMethod (
~ACPI_METHOD_MODIFIED_NAMESPACE;
}
}
/*
* If method is serialized, release the mutex and restore the
* current sync level for this thread
*/
if (MethodDesc->Method.Mutex)
{
/* Acquisition Depth handles recursive calls */
MethodDesc->Method.Mutex->Mutex.AcquisitionDepth--;
if (!MethodDesc->Method.Mutex->Mutex.AcquisitionDepth)
{
WalkState->Thread->CurrentSyncLevel =
MethodDesc->Method.Mutex->Mutex.OriginalSyncLevel;
AcpiOsReleaseMutex (
MethodDesc->Method.Mutex->Mutex.OsMutex);
MethodDesc->Method.Mutex->Mutex.ThreadId = 0;
}
}
}
/* Decrement the thread count on the method */

2
sys/contrib/dev/acpica/components/dispatcher/dsopcode.c
View File

@ -90,7 +90,7 @@ AcpiDsInitializeRegion (
/* Namespace is NOT locked */
Status = AcpiEvInitializeRegion (ObjDesc, FALSE);
Status = AcpiEvInitializeRegion (ObjDesc);
return (Status);
}

17
sys/contrib/dev/acpica/components/dispatcher/dswload2.c
View File

@ -626,23 +626,8 @@ AcpiDsLoad2EndOp (
}
}
AcpiExExitInterpreter ();
Status = AcpiEvInitializeRegion (
AcpiNsGetAttachedObject (Node), FALSE);
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
{
/*
* If AE_NOT_EXIST is returned, it is not fatal
* because many regions get created before a handler
* is installed for said region.
*/
if (AE_NOT_EXIST == Status)
{
Status = AE_OK;
}
}
AcpiNsGetAttachedObject (Node));
break;
case AML_NAME_OP:

57
sys/contrib/dev/acpica/components/events/evrgnini.c
View File

@ -45,6 +45,7 @@
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acevents.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/acinterp.h>
#define _COMPONENT ACPI_EVENTS
ACPI_MODULE_NAME ("evrgnini")
@ -537,7 +538,6 @@ AcpiEvDefaultRegionSetup (
* FUNCTION: AcpiEvInitializeRegion
*
* PARAMETERS: RegionObj - Region we are initializing
* AcpiNsLocked - Is namespace locked?
*
* RETURN: Status
*
@ -555,21 +555,33 @@ AcpiEvDefaultRegionSetup (
* MUTEX: Interpreter should be unlocked, because we may run the _REG
* method for this region.
*
* NOTE: Possible incompliance:
* There is a behavior conflict in automatic _REG execution:
* 1. When the interpreter is evaluating a method, we can only
* automatically run _REG for the following case:
* Method(_REG, 2) {}
* OperationRegion (OPR1, 0x80, 0x1000010, 0x4)
* 2. When the interpreter is loading a table, we can also
* automatically run _REG for the following case:
* OperationRegion (OPR1, 0x80, 0x1000010, 0x4)
* Method(_REG, 2) {}
* Though this may not be compliant to the de-facto standard, the
* logic is kept in order not to trigger regressions. And keeping
* this logic should be taken care by the caller of this function.
*
******************************************************************************/
ACPI_STATUS
AcpiEvInitializeRegion (
ACPI_OPERAND_OBJECT *RegionObj,
BOOLEAN AcpiNsLocked)
ACPI_OPERAND_OBJECT *RegionObj)
{
ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_ADR_SPACE_TYPE SpaceId;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE_U32 (EvInitializeRegion, AcpiNsLocked);
ACPI_FUNCTION_TRACE (EvInitializeRegion);
if (!RegionObj)
@ -641,33 +653,15 @@ AcpiEvInitializeRegion (
"Found handler %p for region %p in obj %p\n",
HandlerObj, RegionObj, ObjDesc));
Status = AcpiEvAttachRegion (HandlerObj, RegionObj,
AcpiNsLocked);
(void) AcpiEvAttachRegion (HandlerObj, RegionObj, FALSE);
/*
* Tell all users that this region is usable by
* running the _REG method
*/
if (AcpiNsLocked)
{
Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
Status = AcpiEvExecuteRegMethod (RegionObj, ACPI_REG_CONNECT);
if (AcpiNsLocked)
{
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
AcpiExExitInterpreter ();
(void) AcpiEvExecuteRegMethod (RegionObj, ACPI_REG_CONNECT);
AcpiExEnterInterpreter ();
return_ACPI_STATUS (AE_OK);
}
}
@ -677,11 +671,14 @@ AcpiEvInitializeRegion (
Node = Node->Parent;
}
/* If we get here, there is no handler for this region */
/*
* If we get here, there is no handler for this region. This is not
* fatal because many regions get created before a handler is installed
* for said region.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"No handler for RegionType %s(%X) (RegionObj %p)\n",
AcpiUtGetRegionName (SpaceId), SpaceId, RegionObj));
return_ACPI_STATUS (AE_NOT_EXIST);
return_ACPI_STATUS (AE_OK);
}

40
sys/contrib/dev/acpica/components/executer/exconfig.c
View File

@ -480,7 +480,7 @@ AcpiExLoadOp (
ACPI_INFO (("Dynamic OEM Table Load:"));
AcpiExExitInterpreter ();
Status = AcpiTbInstallAndLoadTable (Table, ACPI_PTR_TO_PHYSADDR (Table),
Status = AcpiTbInstallAndLoadTable (ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, TRUE, &TableIndex);
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
@ -545,7 +545,6 @@ AcpiExUnloadTable (
ACPI_STATUS Status = AE_OK;
ACPI_OPERAND_OBJECT *TableDesc = DdbHandle;
UINT32 TableIndex;
ACPI_TABLE_HEADER *Table;
ACPI_FUNCTION_TRACE (ExUnloadTable);
@ -586,42 +585,7 @@ AcpiExUnloadTable (
* strict order requirement against it.
*/
AcpiExExitInterpreter ();
/* Ensure the table is still loaded */
if (!AcpiTbIsTableLoaded (TableIndex))
{
Status = AE_NOT_EXIST;
goto LockAndExit;
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
Status = AcpiGetTableByIndex (TableIndex, &Table);
if (ACPI_SUCCESS (Status))
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_UNLOAD, Table,
AcpiGbl_TableHandlerContext);
}
}
/* Delete the portion of the namespace owned by this table */
Status = AcpiTbDeleteNamespaceByOwner (TableIndex);
if (ACPI_FAILURE (Status))
{
goto LockAndExit;
}
(void) AcpiTbReleaseOwnerId (TableIndex);
AcpiTbSetTableLoadedFlag (TableIndex, FALSE);
LockAndExit:
/* Re-acquire the interpreter lock */
Status = AcpiTbUnloadTable (TableIndex);
AcpiExEnterInterpreter ();
/*

1
sys/contrib/dev/acpica/components/executer/exconvrt.c
View File

@ -645,7 +645,6 @@ AcpiExConvertToTargetType (
switch (GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs))
{
case ARGI_SIMPLE_TARGET:
case ARGI_FIXED_TARGET:
case ARGI_INTEGER_REF: /* Handles Increment, Decrement cases */
switch (DestinationType)

1
sys/contrib/dev/acpica/components/executer/exresop.c
View File

@ -321,7 +321,6 @@ AcpiExResolveOperands (
case ARGI_OBJECT_REF:
case ARGI_DEVICE_REF:
case ARGI_TARGETREF: /* Allows implicit conversion rules before store */
case ARGI_FIXED_TARGET: /* No implicit conversion before store to target */
case ARGI_SIMPLE_TARGET: /* Name, Local, or Arg - no implicit conversion */
case ARGI_STORE_TARGET:

2
sys/contrib/dev/acpica/components/namespace/nsload.c
View File

@ -154,7 +154,9 @@ AcpiNsLoadTable (
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"**** Begin Table Object Initialization\n"));
AcpiExEnterInterpreter ();
Status = AcpiDsInitializeObjects (TableIndex, Node);
AcpiExExitInterpreter ();
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"**** Completed Table Object Initialization\n"));

52
sys/contrib/dev/acpica/components/namespace/nsnames.c
View File

@ -108,6 +108,58 @@ AcpiNsGetPathnameLength (
}
/*******************************************************************************
*
* FUNCTION: AcpiNsHandleToName
*
* PARAMETERS: TargetHandle - Handle of named object whose name is
* to be found
* Buffer - Where the name is returned
*
* RETURN: Status, Buffer is filled with name if status is AE_OK
*
* DESCRIPTION: Build and return a full namespace name
*
******************************************************************************/
ACPI_STATUS
AcpiNsHandleToName (
ACPI_HANDLE TargetHandle,
ACPI_BUFFER *Buffer)
{
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *Node;
const char *NodeName;
ACPI_FUNCTION_TRACE_PTR (NsHandleToName, TargetHandle);
Node = AcpiNsValidateHandle (TargetHandle);
if (!Node)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* Validate/Allocate/Clear caller buffer */
Status = AcpiUtInitializeBuffer (Buffer, ACPI_PATH_SEGMENT_LENGTH);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Just copy the ACPI name from the Node and zero terminate it */
NodeName = AcpiUtGetNodeName (Node);
ACPI_MOVE_NAME (Buffer->Pointer, NodeName);
((char *) Buffer->Pointer) [ACPI_NAME_SIZE] = 0;
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%4.4s\n", (char *) Buffer->Pointer));
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiNsHandleToPathname

42
sys/contrib/dev/acpica/components/namespace/nsxfname.c
View File

@ -176,8 +176,6 @@ AcpiGetName (
ACPI_BUFFER *Buffer)
{
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *Node;
const char *NodeName;
/* Parameter validation */
@ -193,16 +191,6 @@ AcpiGetName (
return (Status);
}
if (NameType == ACPI_FULL_PATHNAME ||
NameType == ACPI_FULL_PATHNAME_NO_TRAILING)
{
/* Get the full pathname (From the namespace root) */
Status = AcpiNsHandleToPathname (Handle, Buffer,
NameType == ACPI_FULL_PATHNAME ? FALSE : TRUE);
return (Status);
}
/*
* Wants the single segment ACPI name.
* Validate handle and convert to a namespace Node
@ -213,31 +201,21 @@ AcpiGetName (
return (Status);
}
Node = AcpiNsValidateHandle (Handle);
if (!Node)
if (NameType == ACPI_FULL_PATHNAME ||
NameType == ACPI_FULL_PATHNAME_NO_TRAILING)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
/* Get the full pathname (From the namespace root) */
Status = AcpiNsHandleToPathname (Handle, Buffer,
NameType == ACPI_FULL_PATHNAME ? FALSE : TRUE);
}
/* Validate/Allocate/Clear caller buffer */
Status = AcpiUtInitializeBuffer (Buffer, ACPI_PATH_SEGMENT_LENGTH);
if (ACPI_FAILURE (Status))
else
{
goto UnlockAndExit;
/* Get the single name */
Status = AcpiNsHandleToName (Handle, Buffer);
}
/* Just copy the ACPI name from the Node and zero terminate it */
NodeName = AcpiUtGetNodeName (Node);
ACPI_MOVE_NAME (Buffer->Pointer, NodeName);
((char *) Buffer->Pointer) [ACPI_NAME_SIZE] = 0;
Status = AE_OK;
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
return (Status);
}

75
sys/contrib/dev/acpica/components/parser/psargs.c
View File

@ -298,23 +298,12 @@ AcpiPsGetNextNamepath (
PossibleMethodCall &&
(Node->Type == ACPI_TYPE_METHOD))
{
if (WalkState->Opcode == AML_UNLOAD_OP)
{
/*
* AcpiPsGetNextNamestring has increased the AML pointer,
* so we need to restore the saved AML pointer for method call.
*/
WalkState->ParserState.Aml = Start;
WalkState->ArgCount = 1;
AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
return_ACPI_STATUS (AE_OK);
}
/* This name is actually a control method invocation */
MethodDesc = AcpiNsGetAttachedObject (Node);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Control Method - %p Desc %p Path=%p\n", Node, MethodDesc, Path));
"Control Method invocation %4.4s - %p Desc %p Path=%p\n",
Node->Name.Ascii, Node, MethodDesc, Path));
NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Start);
if (!NameOp)
@ -771,6 +760,10 @@ AcpiPsGetNextArg (
ACPI_FUNCTION_TRACE_PTR (PsGetNextArg, ParserState);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Expected argument type ARGP: %s (%2.2X)\n",
AcpiUtGetArgumentTypeName (ArgType), ArgType));
switch (ArgType)
{
case ARGP_BYTEDATA:
@ -854,11 +847,13 @@ AcpiPsGetNextArg (
}
break;
case ARGP_TARGET:
case ARGP_SUPERNAME:
case ARGP_SIMPLENAME:
case ARGP_NAME_OR_REF:
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"**** SimpleName/NameOrRef: %s (%2.2X)\n",
AcpiUtGetArgumentTypeName (ArgType), ArgType));
Subop = AcpiPsPeekOpcode (ParserState);
if (Subop == 0 ||
AcpiPsIsLeadingChar (Subop) ||
@ -873,28 +868,37 @@ AcpiPsGetNextArg (
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* To support SuperName arg of Unload */
Status = AcpiPsGetNextNamepath (WalkState, ParserState,
Arg, ACPI_NOT_METHOD_CALL);
}
else
{
/* Single complex argument, nothing returned */
if (WalkState->Opcode == AML_UNLOAD_OP)
{
Status = AcpiPsGetNextNamepath (WalkState, ParserState,
Arg, ACPI_POSSIBLE_METHOD_CALL);
WalkState->ArgCount = 1;
}
break;
/*
* If the SuperName argument is a method call, we have
* already restored the AML pointer, just free this Arg
*/
if (Arg->Common.AmlOpcode == AML_INT_METHODCALL_OP)
{
AcpiPsFreeOp (Arg);
Arg = NULL;
}
}
else
case ARGP_TARGET:
case ARGP_SUPERNAME:
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"**** Target/Supername: %s (%2.2X)\n",
AcpiUtGetArgumentTypeName (ArgType), ArgType));
Subop = AcpiPsPeekOpcode (ParserState);
if (Subop == 0)
{
/* NULL target (zero). Convert to a NULL namepath */
Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
if (!Arg)
{
Status = AcpiPsGetNextNamepath (WalkState, ParserState,
Arg, ACPI_NOT_METHOD_CALL);
return_ACPI_STATUS (AE_NO_MEMORY);
}
Status = AcpiPsGetNextNamepath (WalkState, ParserState,
Arg, ACPI_POSSIBLE_METHOD_CALL);
}
else
{
@ -907,6 +911,11 @@ AcpiPsGetNextArg (
case ARGP_DATAOBJ:
case ARGP_TERMARG:
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"**** TermArg/DataObj: %s (%2.2X)\n",
AcpiUtGetArgumentTypeName (ArgType), ArgType));
/* Single complex argument, nothing returned */
WalkState->ArgCount = 1;

3
sys/contrib/dev/acpica/components/parser/psloop.c
View File

@ -104,6 +104,9 @@ AcpiPsGetArguments (
ACPI_FUNCTION_TRACE_PTR (PsGetArguments, WalkState);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Get arguments for opcode [%s]\n", Op->Common.AmlOpName));
switch (Op->Common.AmlOpcode)
{
case AML_BYTE_OP: /* AML_BYTEDATA_ARG */

8
sys/contrib/dev/acpica/components/parser/psobject.c
View File

@ -373,7 +373,13 @@ AcpiPsCreateOp (
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
else if (ParentScope->Common.AmlOpcode == AML_INCREMENT_OP)
/*
* Special case for both Increment() and Decrement(), where
* the lone argument is both a source and a target.
*/
else if ((ParentScope->Common.AmlOpcode == AML_INCREMENT_OP) ||
(ParentScope->Common.AmlOpcode == AML_DECREMENT_OP))
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}

10
sys/contrib/dev/acpica/components/parser/pstree.c
View File

@ -142,12 +142,12 @@ AcpiPsAppendArg (
const ACPI_OPCODE_INFO *OpInfo;
ACPI_FUNCTION_ENTRY ();
ACPI_FUNCTION_TRACE ("PsAppendArg");
if (!Op)
{
return;
return_VOID;
}
/* Get the info structure for this opcode */
@ -159,7 +159,7 @@ AcpiPsAppendArg (
ACPI_ERROR ((AE_INFO, "Invalid AML Opcode: 0x%2.2X",
Op->Common.AmlOpcode));
return;
return_VOID;
}
/* Check if this opcode requires argument sub-objects */
@ -168,7 +168,7 @@ AcpiPsAppendArg (
{
/* Has no linked argument objects */
return;
return_VOID;
}
/* Append the argument to the linked argument list */
@ -200,6 +200,8 @@ AcpiPsAppendArg (
Op->Common.ArgListLength++;
}
return_VOID;
}

102
sys/contrib/dev/acpica/components/tables/tbdata.c
View File

@ -937,9 +937,9 @@ AcpiTbLoadTable (
*
* FUNCTION: AcpiTbInstallAndLoadTable
*
* PARAMETERS: Table - Pointer to the table
* Address - Physical address of the table
* PARAMETERS: Address - Physical address of the table
* Flags - Allocation flags of the table
* Override - Whether override should be performed
* TableIndex - Where table index is returned
*
* RETURN: Status
@ -950,7 +950,6 @@ AcpiTbLoadTable (
ACPI_STATUS
AcpiTbInstallAndLoadTable (
ACPI_TABLE_HEADER *Table,
ACPI_PHYSICAL_ADDRESS Address,
UINT8 Flags,
BOOLEAN Override,
@ -958,10 +957,9 @@ AcpiTbInstallAndLoadTable (
{
ACPI_STATUS Status;
UINT32 i;
ACPI_OWNER_ID OwnerId;
ACPI_FUNCTION_TRACE (AcpiLoadTable);
ACPI_FUNCTION_TRACE (TbInstallAndLoadTable);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
@ -975,44 +973,8 @@ AcpiTbInstallAndLoadTable (
goto UnlockAndExit;
}
/*
* Note: Now table is "INSTALLED", it must be validated before
* using.
*/
Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[i]);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
Status = AcpiNsLoadTable (i, AcpiGbl_RootNode);
/* Execute any module-level code that was found in the table */
if (!AcpiGbl_ParseTableAsTermList && AcpiGbl_GroupModuleLevelCode)
{
AcpiNsExecModuleCodeList ();
}
/*
* Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
* responsible for discovering any new wake GPEs by running _PRW methods
* that may have been loaded by this table.
*/
Status = AcpiTbGetOwnerId (i, &OwnerId);
if (ACPI_SUCCESS (Status))
{
AcpiEvUpdateGpes (OwnerId);
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
AcpiGbl_TableHandlerContext);
}
Status = AcpiTbLoadTable (i, AcpiGbl_RootNode);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
UnlockAndExit:
@ -1020,3 +982,59 @@ AcpiTbInstallAndLoadTable (
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiTbUnloadTable
*
* PARAMETERS: TableIndex - Table index
*
* RETURN: Status
*
* DESCRIPTION: Unload an ACPI table
*
******************************************************************************/
ACPI_STATUS
AcpiTbUnloadTable (
UINT32 TableIndex)
{
ACPI_STATUS Status = AE_OK;
ACPI_TABLE_HEADER *Table;
ACPI_FUNCTION_TRACE (TbUnloadTable);
/* Ensure the table is still loaded */
if (!AcpiTbIsTableLoaded (TableIndex))
{
return_ACPI_STATUS (AE_NOT_EXIST);
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
Status = AcpiGetTableByIndex (TableIndex, &Table);
if (ACPI_SUCCESS (Status))
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_UNLOAD, Table,
AcpiGbl_TableHandlerContext);
}
}
/* Delete the portion of the namespace owned by this table */
Status = AcpiTbDeleteNamespaceByOwner (TableIndex);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
(void) AcpiTbReleaseOwnerId (TableIndex);
AcpiTbSetTableLoadedFlag (TableIndex, FALSE);
return_ACPI_STATUS (Status);
}

23
sys/contrib/dev/acpica/components/tables/tbfadt.c
View File

@ -341,6 +341,8 @@ AcpiTbParseFadt (
{
UINT32 Length;
ACPI_TABLE_HEADER *Table;
ACPI_TABLE_DESC *FadtDesc;
ACPI_STATUS Status;
/*
@ -350,14 +352,13 @@ AcpiTbParseFadt (
* Get a local copy of the FADT and convert it to a common format
* Map entire FADT, assumed to be smaller than one page.
*/
Length = AcpiGbl_RootTableList.Tables[AcpiGbl_FadtIndex].Length;
Table = AcpiOsMapMemory (
AcpiGbl_RootTableList.Tables[AcpiGbl_FadtIndex].Address, Length);
if (!Table)
FadtDesc = &AcpiGbl_RootTableList.Tables[AcpiGbl_FadtIndex];
Status = AcpiTbGetTable (FadtDesc, &Table);
if (ACPI_FAILURE (Status))
{
return;
}
Length = FadtDesc->Length;
/*
* Validate the FADT checksum before we copy the table. Ignore
@ -371,7 +372,7 @@ AcpiTbParseFadt (
/* All done with the real FADT, unmap it */
AcpiOsUnmapMemory (Table, Length);
AcpiTbPutTable (FadtDesc);
/* Obtain the DSDT and FACS tables via their addresses within the FADT */
@ -522,19 +523,17 @@ AcpiTbConvertFadt (
/*
* For ACPI 1.0 FADTs (revision 1), ensure that reserved fields which
* For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
* should be zero are indeed zero. This will workaround BIOSs that
* inadvertently place values in these fields.
*
* The ACPI 1.0 reserved fields that will be zeroed are the bytes located
* at offset 45, 55, 95, and the word located at offset 109, 110.
*
* Note: The FADT revision value is unreliable because of BIOS errors.
* The table length is instead used as the final word on the version.
*
* Note: FADT revision 3 is the ACPI 2.0 version of the FADT.
* Note: The FADT revision value is unreliable. Only the length can be
* trusted.
*/
if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V3_SIZE)
if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V2_SIZE)
{
AcpiGbl_FADT.PreferredProfile = 0;
AcpiGbl_FADT.PstateControl = 0;

96
sys/contrib/dev/acpica/components/tables/tbutils.c
View File

@ -411,3 +411,99 @@ AcpiTbParseRootTable (
AcpiOsUnmapMemory (Table, Length);
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiTbGetTable
*
* PARAMETERS: TableDesc - Table descriptor
* OutTable - Where the pointer to the table is returned
*
* RETURN: Status and pointer to the requested table
*
* DESCRIPTION: Increase a reference to a table descriptor and return the
* validated table pointer.
* If the table descriptor is an entry of the root table list,
* this API must be invoked with ACPI_MTX_TABLES acquired.
*
******************************************************************************/
ACPI_STATUS
AcpiTbGetTable (
ACPI_TABLE_DESC *TableDesc,
ACPI_TABLE_HEADER **OutTable)
{
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (AcpiTbGetTable);
if (TableDesc->ValidationCount == 0)
{
/* Table need to be "VALIDATED" */
Status = AcpiTbValidateTable (TableDesc);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
TableDesc->ValidationCount++;
if (TableDesc->ValidationCount == 0)
{
ACPI_ERROR ((AE_INFO,
"Table %p, Validation count is zero after increment\n",
TableDesc));
TableDesc->ValidationCount--;
return_ACPI_STATUS (AE_LIMIT);
}
*OutTable = TableDesc->Pointer;
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiTbPutTable
*
* PARAMETERS: TableDesc - Table descriptor
*
* RETURN: None
*
* DESCRIPTION: Decrease a reference to a table descriptor and release the
* validated table pointer if no references.
* If the table descriptor is an entry of the root table list,
* this API must be invoked with ACPI_MTX_TABLES acquired.
*
******************************************************************************/
void
AcpiTbPutTable (
ACPI_TABLE_DESC *TableDesc)
{
ACPI_FUNCTION_TRACE (AcpiTbPutTable);
if (TableDesc->ValidationCount == 0)
{
ACPI_WARNING ((AE_INFO,
"Table %p, Validation count is zero before decrement\n",
TableDesc));
return_VOID;
}
TableDesc->ValidationCount--;
if (TableDesc->ValidationCount == 0)
{
/* Table need to be "INVALIDATED" */
AcpiTbInvalidateTable (TableDesc);
}
return_VOID;
}

137
sys/contrib/dev/acpica/components/tables/tbxface.c
View File

@ -184,6 +184,7 @@ AcpiReallocateRootTable (
void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_FUNCTION_TRACE (AcpiReallocateRootTable);
@ -198,6 +199,22 @@ AcpiReallocateRootTable (
return_ACPI_STATUS (AE_SUPPORT);
}
/*
* Ensure OS early boot logic, which is required by some hosts. If the
* table state is reported to be wrong, developers should fix the
* issue by invoking AcpiPutTable() for the reported table during the
* early stage.
*/
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
{
if (AcpiGbl_RootTableList.Tables[i].Pointer)
{
ACPI_ERROR ((AE_INFO,
"Table [%4.4s] is not invalidated during early boot stage",
AcpiGbl_RootTableList.Tables[i].Signature.Ascii));
}
}
AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
Status = AcpiTbResizeRootTableList ();
@ -307,6 +324,11 @@ ACPI_EXPORT_SYMBOL (AcpiGetTableHeader)
*
* DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
* RSDT/XSDT.
* Note that an early stage AcpiGetTable() call must be paired
* with an early stage AcpiPutTable() call. otherwise the table
* pointer mapped by the early stage mapping implementation may be
* erroneously unmapped by the late stage unmapping implementation
* in an AcpiPutTable() invoked during the late stage.
*
******************************************************************************/
@ -318,7 +340,8 @@ AcpiGetTable (
{
UINT32 i;
UINT32 j;
ACPI_STATUS Status;
ACPI_STATUS Status = AE_NOT_FOUND;
ACPI_TABLE_DESC *TableDesc;
/* Parameter validation */
@ -328,12 +351,22 @@ AcpiGetTable (
return (AE_BAD_PARAMETER);
}
/*
* Note that the following line is required by some OSPMs, they only
* check if the returned table is NULL instead of the returned status
* to determined if this function is succeeded.
*/
*OutTable = NULL;
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
/* Walk the root table list */
for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
{
if (!ACPI_COMPARE_NAME (
&(AcpiGbl_RootTableList.Tables[i].Signature), Signature))
TableDesc = &AcpiGbl_RootTableList.Tables[i];
if (!ACPI_COMPARE_NAME (&TableDesc->Signature, Signature))
{
continue;
}
@ -343,27 +376,74 @@ AcpiGetTable (
continue;
}
Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[i]);
if (ACPI_SUCCESS (Status))
{
*OutTable = AcpiGbl_RootTableList.Tables[i].Pointer;
}
return (Status);
Status = AcpiTbGetTable (TableDesc, OutTable);
break;
}
return (AE_NOT_FOUND);
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return (Status);
}
ACPI_EXPORT_SYMBOL (AcpiGetTable)
/*******************************************************************************
*
* FUNCTION: AcpiPutTable
*
* PARAMETERS: Table - The pointer to the table
*
* RETURN: None
*
* DESCRIPTION: Release a table returned by AcpiGetTable() and its clones.
* Note that it is not safe if this function was invoked after an
* uninstallation happened to the original table descriptor.
* Currently there is no OSPMs' requirement to handle such
* situations.
*
******************************************************************************/
void
AcpiPutTable (
ACPI_TABLE_HEADER *Table)
{
UINT32 i;
ACPI_TABLE_DESC *TableDesc;
ACPI_FUNCTION_TRACE (AcpiPutTable);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
/* Walk the root table list */
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
{
TableDesc = &AcpiGbl_RootTableList.Tables[i];
if (TableDesc->Pointer != Table)
{
continue;
}
AcpiTbPutTable (TableDesc);
break;
}
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_VOID;
}
ACPI_EXPORT_SYMBOL (AcpiPutTable)
/*******************************************************************************
*
* FUNCTION: AcpiGetTableByIndex
*
* PARAMETERS: TableIndex - Table index
* Table - Where the pointer to the table is returned
* OutTable - Where the pointer to the table is returned
*
* RETURN: Status and pointer to the requested table
*
@ -375,7 +455,7 @@ ACPI_EXPORT_SYMBOL (AcpiGetTable)
ACPI_STATUS
AcpiGetTableByIndex (
UINT32 TableIndex,
ACPI_TABLE_HEADER **Table)
ACPI_TABLE_HEADER **OutTable)
{
ACPI_STATUS Status;
@ -385,37 +465,34 @@ AcpiGetTableByIndex (
/* Parameter validation */
if (!Table)
if (!OutTable)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/*
* Note that the following line is required by some OSPMs, they only
* check if the returned table is NULL instead of the returned status
* to determined if this function is succeeded.
*/
*OutTable = NULL;
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
/* Validate index */
if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
{
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (AE_BAD_PARAMETER);
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
if (!AcpiGbl_RootTableList.Tables[TableIndex].Pointer)
{
/* Table is not mapped, map it */
Status = AcpiTbGetTable (
&AcpiGbl_RootTableList.Tables[TableIndex], OutTable);
Status = AcpiTbValidateTable (
&AcpiGbl_RootTableList.Tables[TableIndex]);
if (ACPI_FAILURE (Status))
{
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
}
}
*Table = AcpiGbl_RootTableList.Tables[TableIndex].Pointer;
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS (Status);
}
ACPI_EXPORT_SYMBOL (AcpiGetTableByIndex)

35
sys/contrib/dev/acpica/components/tables/tbxfload.c
View File

@ -372,7 +372,7 @@ AcpiLoadTable (
/* Install the table and load it into the namespace */
ACPI_INFO (("Host-directed Dynamic ACPI Table Load:"));
Status = AcpiTbInstallAndLoadTable (Table, ACPI_PTR_TO_PHYSADDR (Table),
Status = AcpiTbInstallAndLoadTable (ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL, FALSE, &TableIndex);
return_ACPI_STATUS (Status);
}
@ -459,39 +459,8 @@ AcpiUnloadParentTable (
break;
}
/* Ensure the table is actually loaded */
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
if (!AcpiTbIsTableLoaded (i))
{
Status = AE_NOT_EXIST;
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
break;
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_UNLOAD,
AcpiGbl_RootTableList.Tables[i].Pointer,
AcpiGbl_TableHandlerContext);
}
/*
* Delete all namespace objects owned by this table. Note that
* these objects can appear anywhere in the namespace by virtue
* of the AML "Scope" operator. Thus, we need to track ownership
* by an ID, not simply a position within the hierarchy.
*/
Status = AcpiTbDeleteNamespaceByOwner (i);
if (ACPI_FAILURE (Status))
{
break;
}
Status = AcpiTbReleaseOwnerId (i);
AcpiTbSetTableLoadedFlag (i, FALSE);
Status = AcpiTbUnloadTable (i);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
break;
}

54
sys/contrib/dev/acpica/components/utilities/utdecode.c
View File

@ -44,6 +44,7 @@
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/amlcode.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utdecode")
@ -604,6 +605,59 @@ AcpiUtGetNotifyName (
return ("Hardware-Specific");
}
/*******************************************************************************
*
* FUNCTION: AcpiUtGetArgumentTypeName
*
* PARAMETERS: ArgType - an ARGP_* parser argument type
*
* RETURN: Decoded ARGP_* type
*
* DESCRIPTION: Decode an ARGP_* parser type, as defined in the amlcode.h file,
* and used in the acopcode.h file. For example, ARGP_TERMARG.
* Used for debug only.
*
******************************************************************************/
static const char *AcpiGbl_ArgumentType[20] =
{
/* 00 */ "Unknown ARGP",
/* 01 */ "ByteData",
/* 02 */ "ByteList",
/* 03 */ "CharList",
/* 04 */ "DataObject",
/* 05 */ "DataObjectList",
/* 06 */ "DWordData",
/* 07 */ "FieldList",
/* 08 */ "Name",
/* 09 */ "NameString",
/* 0A */ "ObjectList",
/* 0B */ "PackageLength",
/* 0C */ "SuperName",
/* 0D */ "Target",
/* 0E */ "TermArg",
/* 0F */ "TermList",
/* 10 */ "WordData",
/* 11 */ "QWordData",
/* 12 */ "SimpleName",
/* 13 */ "NameOrRef"
};
const char *
AcpiUtGetArgumentTypeName (
UINT32 ArgType)
{
if (ArgType > ARGP_MAX)
{
return ("Unknown ARGP");
}
return (AcpiGbl_ArgumentType[ArgType]);
}
#endif

19
sys/contrib/dev/acpica/components/utilities/utresrc.c
View File

@ -468,9 +468,11 @@ AcpiUtWalkAmlResources (
ACPI_FUNCTION_TRACE (UtWalkAmlResources);
/* The absolute minimum resource template is one EndTag descriptor */
if (AmlLength < sizeof (AML_RESOURCE_END_TAG))
/*
* The absolute minimum resource template is one EndTag descriptor.
* However, we will treat a lone EndTag as just a simple buffer.
*/
if (AmlLength <= sizeof (AML_RESOURCE_END_TAG))
{
return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
}
@ -503,8 +505,8 @@ AcpiUtWalkAmlResources (
if (UserFunction)
{
Status = UserFunction (
Aml, Length, Offset, ResourceIndex, Context);
Status = UserFunction (Aml, Length, Offset,
ResourceIndex, Context);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -531,6 +533,13 @@ AcpiUtWalkAmlResources (
*Context = Aml;
}
/* Check if buffer is defined to be longer than the resource length */
if (AmlLength > (Offset + Length))
{
return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
}
/* Normal exit */
return_ACPI_STATUS (AE_OK);

5
sys/contrib/dev/acpica/include/acdisasm.h
View File

@ -280,8 +280,8 @@ extern ACPI_DMTABLE_INFO AcpiDmTableInfoErst[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoErst0[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFacs[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt1[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt2[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt3[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt4[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt5[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt6[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFpdt[];
@ -425,9 +425,6 @@ extern ACPI_DMTABLE_INFO AcpiDmTableInfoXenv[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoGeneric[][2];
extern ACPI_DMTABLE_INFO *FadtRevisionInfo [ACPI_FADT_MAX_VERSION + 1];
/*
* dmtable and ahtable
*/

3
sys/contrib/dev/acpica/include/acevents.h
View File

@ -336,8 +336,7 @@ AcpiEvDefaultRegionSetup (
ACPI_STATUS
AcpiEvInitializeRegion (
ACPI_OPERAND_OBJECT *RegionObj,
BOOLEAN AcpiNsLocked);
ACPI_OPERAND_OBJECT *RegionObj);
/*

5
sys/contrib/dev/acpica/include/acnamesp.h
View File

@ -384,6 +384,11 @@ char *
AcpiNsNameOfCurrentScope (
ACPI_WALK_STATE *WalkState);
ACPI_STATUS
AcpiNsHandleToName (
ACPI_HANDLE TargetHandle,
ACPI_BUFFER *Buffer);
ACPI_STATUS
AcpiNsHandleToPathname (
ACPI_HANDLE TargetHandle,

22
sys/contrib/dev/acpica/include/acopcode.h
View File

@ -93,7 +93,7 @@
#define ARGP_BYTELIST_OP ARGP_LIST1 (ARGP_NAMESTRING)
#define ARGP_CONCAT_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET)
#define ARGP_CONCAT_RES_OP ARGP_LIST3 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET)
#define ARGP_COND_REF_OF_OP ARGP_LIST2 (ARGP_NAME_OR_REF,ARGP_TARGET)
#define ARGP_COND_REF_OF_OP ARGP_LIST2 (ARGP_SIMPLENAME, ARGP_TARGET)
#define ARGP_CONNECTFIELD_OP ARGP_LIST1 (ARGP_NAMESTRING)
#define ARGP_CONTINUE_OP ARG_NONE
#define ARGP_COPY_OP ARGP_LIST2 (ARGP_TERMARG, ARGP_SIMPLENAME)
@ -106,7 +106,7 @@
#define ARGP_DATA_REGION_OP ARGP_LIST4 (ARGP_NAME, ARGP_TERMARG, ARGP_TERMARG, ARGP_TERMARG)
#define ARGP_DEBUG_OP ARG_NONE
#define ARGP_DECREMENT_OP ARGP_LIST1 (ARGP_SUPERNAME)
#define ARGP_DEREF_OF_OP ARGP_LIST1 (ARGP_TERMARG)
#define ARGP_DEREF_OF_OP ARGP_LIST1 (ARGP_SUPERNAME)
#define ARGP_DEVICE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_OBJLIST)
#define ARGP_DIVIDE_OP ARGP_LIST4 (ARGP_TERMARG, ARGP_TERMARG, ARGP_TARGET, ARGP_TARGET)
#define ARGP_DWORD_OP ARGP_LIST1 (ARGP_DWORDDATA)
@ -153,14 +153,14 @@
#define ARGP_NAMEPATH_OP ARGP_LIST1 (ARGP_NAMESTRING)
#define ARGP_NOOP_OP ARG_NONE
#define ARGP_NOTIFY_OP ARGP_LIST2 (ARGP_SUPERNAME, ARGP_TERMARG)
#define ARGP_OBJECT_TYPE_OP ARGP_LIST1 (ARGP_NAME_OR_REF)
#define ARGP_OBJECT_TYPE_OP ARGP_LIST1 (ARGP_SIMPLENAME)
#define ARGP_ONE_OP ARG_NONE
#define ARGP_ONES_OP ARG_NONE
#define ARGP_PACKAGE_OP ARGP_LIST3 (ARGP_PKGLENGTH, ARGP_BYTEDATA, ARGP_DATAOBJLIST)
#define ARGP_POWER_RES_OP ARGP_LIST5 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_BYTEDATA, ARGP_WORDDATA, ARGP_OBJLIST)
#define ARGP_PROCESSOR_OP ARGP_LIST6 (ARGP_PKGLENGTH, ARGP_NAME, ARGP_BYTEDATA, ARGP_DWORDDATA, ARGP_BYTEDATA, ARGP_OBJLIST)
#define ARGP_QWORD_OP ARGP_LIST1 (ARGP_QWORDDATA)
#define ARGP_REF_OF_OP ARGP_LIST1 (ARGP_NAME_OR_REF)
#define ARGP_REF_OF_OP ARGP_LIST1 (ARGP_SIMPLENAME)
#define ARGP_REGION_OP ARGP_LIST4 (ARGP_NAME, ARGP_BYTEDATA, ARGP_TERMARG, ARGP_TERMARG)
#define ARGP_RELEASE_OP ARGP_LIST1 (ARGP_SUPERNAME)
#define ARGP_RESERVEDFIELD_OP ARGP_LIST1 (ARGP_NAMESTRING)
@ -251,7 +251,7 @@
#define ARGI_FIELD_OP ARGI_INVALID_OPCODE
#define ARGI_FIND_SET_LEFT_BIT_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_FIND_SET_RIGHT_BIT_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_FROM_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_FIXED_TARGET)
#define ARGI_FROM_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_IF_OP ARGI_INVALID_OPCODE
#define ARGI_INCREMENT_OP ARGI_LIST1 (ARGI_TARGETREF)
#define ARGI_INDEX_FIELD_OP ARGI_INVALID_OPCODE
@ -315,12 +315,12 @@
#define ARGI_SUBTRACT_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_THERMAL_ZONE_OP ARGI_INVALID_OPCODE
#define ARGI_TIMER_OP ARG_NONE
#define ARGI_TO_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_FIXED_TARGET)
#define ARGI_TO_BUFFER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_DEC_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_HEX_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_INTEGER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_STRING_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_FIXED_TARGET)
#define ARGI_TO_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_TO_BUFFER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_DEC_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_HEX_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_INTEGER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_STRING_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_UNLOAD_OP ARGI_LIST1 (ARGI_DDBHANDLE)
#define ARGI_VAR_PACKAGE_OP ARGI_LIST1 (ARGI_INTEGER)
#define ARGI_WAIT_OP ARGI_LIST2 (ARGI_EVENT, ARGI_INTEGER)

7
sys/contrib/dev/acpica/include/acpixf.h
View File

@ -46,7 +46,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20160930
#define ACPI_CA_VERSION 0x20161117
#include <contrib/dev/acpica/include/acconfig.h>
#include <contrib/dev/acpica/include/actypes.h>
@ -582,6 +582,11 @@ AcpiGetTable (
UINT32 Instance,
ACPI_TABLE_HEADER **OutTable))
ACPI_EXTERNAL_RETURN_VOID (
void
AcpiPutTable (
ACPI_TABLE_HEADER *Table))
ACPI_EXTERNAL_RETURN_STATUS (
ACPI_STATUS
AcpiGetTableByIndex (

14
sys/contrib/dev/acpica/include/actables.h
View File

@ -185,12 +185,15 @@ AcpiTbLoadTable (
ACPI_STATUS
AcpiTbInstallAndLoadTable (
ACPI_TABLE_HEADER *Table,
ACPI_PHYSICAL_ADDRESS Address,
UINT8 Flags,
BOOLEAN Override,
UINT32 *TableIndex);
ACPI_STATUS
AcpiTbUnloadTable (
UINT32 TableIndex);
void
AcpiTbTerminate (
void);
@ -253,6 +256,15 @@ ACPI_STATUS
AcpiTbParseRootTable (
ACPI_PHYSICAL_ADDRESS RsdpAddress);
ACPI_STATUS
AcpiTbGetTable (
ACPI_TABLE_DESC *TableDesc,
ACPI_TABLE_HEADER **OutTable);
void
AcpiTbPutTable (
ACPI_TABLE_DESC *TableDesc);
/*
* tbxfload

165
sys/contrib/dev/acpica/include/actbl.h
View File

@ -256,72 +256,62 @@ typedef struct acpi_table_facs
typedef struct acpi_table_fadt
{
ACPI_TABLE_HEADER Header; /* [V1] Common ACPI table header */
UINT32 Facs; /* [V1] 32-bit physical address of FACS */
UINT32 Dsdt; /* [V1] 32-bit physical address of DSDT */
UINT8 Model; /* [V1] System Interrupt Model (ACPI 1.0) - not used in ACPI 2.0+ */
UINT8 PreferredProfile; /* [V1] Conveys preferred power management profile to OSPM. */
UINT16 SciInterrupt; /* [V1] System vector of SCI interrupt */
UINT32 SmiCommand; /* [V1] 32-bit Port address of SMI command port */
UINT8 AcpiEnable; /* [V1] Value to write to SMI_CMD to enable ACPI */
UINT8 AcpiDisable; /* [V1] Value to write to SMI_CMD to disable ACPI */
UINT8 S4BiosRequest; /* [V1] Value to write to SMI_CMD to enter S4BIOS state */
UINT8 PstateControl; /* [V1] Processor performance state control*/
UINT32 Pm1aEventBlock; /* [V1] 32-bit port address of Power Mgt 1a Event Reg Blk */
UINT32 Pm1bEventBlock; /* [V1] 32-bit port address of Power Mgt 1b Event Reg Blk */
UINT32 Pm1aControlBlock; /* [V1] 32-bit port address of Power Mgt 1a Control Reg Blk */
UINT32 Pm1bControlBlock; /* [V1] 32-bit port address of Power Mgt 1b Control Reg Blk */
UINT32 Pm2ControlBlock; /* [V1] 32-bit port address of Power Mgt 2 Control Reg Blk */
UINT32 PmTimerBlock; /* [V1] 32-bit port address of Power Mgt Timer Ctrl Reg Blk */
UINT32 Gpe0Block; /* [V1] 32-bit port address of General Purpose Event 0 Reg Blk */
UINT32 Gpe1Block; /* [V1] 32-bit port address of General Purpose Event 1 Reg Blk */
UINT8 Pm1EventLength; /* [V1] Byte Length of ports at Pm1xEventBlock */
UINT8 Pm1ControlLength; /* [V1] Byte Length of ports at Pm1xControlBlock */
UINT8 Pm2ControlLength; /* [V1] Byte Length of ports at Pm2ControlBlock */
UINT8 PmTimerLength; /* [V1] Byte Length of ports at PmTimerBlock */
UINT8 Gpe0BlockLength; /* [V1] Byte Length of ports at Gpe0Block */
UINT8 Gpe1BlockLength; /* [V1] Byte Length of ports at Gpe1Block */
UINT8 Gpe1Base; /* [V1] Offset in GPE number space where GPE1 events start */
UINT8 CstControl; /* [V1] Support for the _CST object and C-States change notification */
UINT16 C2Latency; /* [V1] Worst case HW latency to enter/exit C2 state */
UINT16 C3Latency; /* [V1] Worst case HW latency to enter/exit C3 state */
UINT16 FlushSize; /* [V1] Processor memory cache line width, in bytes */
UINT16 FlushStride; /* [V1] Number of flush strides that need to be read */
UINT8 DutyOffset; /* [V1] Processor duty cycle index in processor P_CNT reg */
UINT8 DutyWidth; /* [V1] Processor duty cycle value bit width in P_CNT register */
UINT8 DayAlarm; /* [V1] Index to day-of-month alarm in RTC CMOS RAM */
UINT8 MonthAlarm; /* [V1] Index to month-of-year alarm in RTC CMOS RAM */
UINT8 Century; /* [V1] Index to century in RTC CMOS RAM */
UINT16 BootFlags; /* [V3] IA-PC Boot Architecture Flags (see below for individual flags) */
UINT8 Reserved; /* [V1] Reserved, must be zero */
UINT32 Flags; /* [V1] Miscellaneous flag bits (see below for individual flags) */
/* End of Version 1 FADT fields (ACPI 1.0) */
ACPI_GENERIC_ADDRESS ResetRegister; /* [V3] 64-bit address of the Reset register */
UINT8 ResetValue; /* [V3] Value to write to the ResetRegister port to reset the system */
UINT16 ArmBootFlags; /* [V5] ARM-Specific Boot Flags (see below for individual flags) (ACPI 5.1) */
UINT8 MinorRevision; /* [V5] FADT Minor Revision (ACPI 5.1) */
UINT64 XFacs; /* [V3] 64-bit physical address of FACS */
UINT64 XDsdt; /* [V3] 64-bit physical address of DSDT */
ACPI_GENERIC_ADDRESS XPm1aEventBlock; /* [V3] 64-bit Extended Power Mgt 1a Event Reg Blk address */
ACPI_GENERIC_ADDRESS XPm1bEventBlock; /* [V3] 64-bit Extended Power Mgt 1b Event Reg Blk address */
ACPI_GENERIC_ADDRESS XPm1aControlBlock; /* [V3] 64-bit Extended Power Mgt 1a Control Reg Blk address */
ACPI_GENERIC_ADDRESS XPm1bControlBlock; /* [V3] 64-bit Extended Power Mgt 1b Control Reg Blk address */
ACPI_GENERIC_ADDRESS XPm2ControlBlock; /* [V3] 64-bit Extended Power Mgt 2 Control Reg Blk address */
ACPI_GENERIC_ADDRESS XPmTimerBlock; /* [V3] 64-bit Extended Power Mgt Timer Ctrl Reg Blk address */
ACPI_GENERIC_ADDRESS XGpe0Block; /* [V3] 64-bit Extended General Purpose Event 0 Reg Blk address */
ACPI_GENERIC_ADDRESS XGpe1Block; /* [V3] 64-bit Extended General Purpose Event 1 Reg Blk address */
/* End of Version 3 FADT fields (ACPI 2.0) */
ACPI_GENERIC_ADDRESS SleepControl; /* [V4] 64-bit Sleep Control register (ACPI 5.0) */
/* End of Version 4 FADT fields (ACPI 3.0 and ACPI 4.0) (Field was originally reserved in ACPI 3.0) */
ACPI_GENERIC_ADDRESS SleepStatus; /* [V5] 64-bit Sleep Status register (ACPI 5.0) */
/* End of Version 5 FADT fields (ACPI 5.0) */
UINT64 HypervisorId; /* [V6] Hypervisor Vendor ID (ACPI 6.0) */
/* End of Version 6 FADT fields (ACPI 6.0) */
ACPI_TABLE_HEADER Header; /* Common ACPI table header */
UINT32 Facs; /* 32-bit physical address of FACS */
UINT32 Dsdt; /* 32-bit physical address of DSDT */
UINT8 Model; /* System Interrupt Model (ACPI 1.0) - not used in ACPI 2.0+ */
UINT8 PreferredProfile; /* Conveys preferred power management profile to OSPM. */
UINT16 SciInterrupt; /* System vector of SCI interrupt */
UINT32 SmiCommand; /* 32-bit Port address of SMI command port */
UINT8 AcpiEnable; /* Value to write to SMI_CMD to enable ACPI */
UINT8 AcpiDisable; /* Value to write to SMI_CMD to disable ACPI */
UINT8 S4BiosRequest; /* Value to write to SMI_CMD to enter S4BIOS state */
UINT8 PstateControl; /* Processor performance state control*/
UINT32 Pm1aEventBlock; /* 32-bit port address of Power Mgt 1a Event Reg Blk */
UINT32 Pm1bEventBlock; /* 32-bit port address of Power Mgt 1b Event Reg Blk */
UINT32 Pm1aControlBlock; /* 32-bit port address of Power Mgt 1a Control Reg Blk */
UINT32 Pm1bControlBlock; /* 32-bit port address of Power Mgt 1b Control Reg Blk */
UINT32 Pm2ControlBlock; /* 32-bit port address of Power Mgt 2 Control Reg Blk */
UINT32 PmTimerBlock; /* 32-bit port address of Power Mgt Timer Ctrl Reg Blk */
UINT32 Gpe0Block; /* 32-bit port address of General Purpose Event 0 Reg Blk */
UINT32 Gpe1Block; /* 32-bit port address of General Purpose Event 1 Reg Blk */
UINT8 Pm1EventLength; /* Byte Length of ports at Pm1xEventBlock */
UINT8 Pm1ControlLength; /* Byte Length of ports at Pm1xControlBlock */
UINT8 Pm2ControlLength; /* Byte Length of ports at Pm2ControlBlock */
UINT8 PmTimerLength; /* Byte Length of ports at PmTimerBlock */
UINT8 Gpe0BlockLength; /* Byte Length of ports at Gpe0Block */
UINT8 Gpe1BlockLength; /* Byte Length of ports at Gpe1Block */
UINT8 Gpe1Base; /* Offset in GPE number space where GPE1 events start */
UINT8 CstControl; /* Support for the _CST object and C-States change notification */
UINT16 C2Latency; /* Worst case HW latency to enter/exit C2 state */
UINT16 C3Latency; /* Worst case HW latency to enter/exit C3 state */
UINT16 FlushSize; /* Processor memory cache line width, in bytes */
UINT16 FlushStride; /* Number of flush strides that need to be read */
UINT8 DutyOffset; /* Processor duty cycle index in processor P_CNT reg */
UINT8 DutyWidth; /* Processor duty cycle value bit width in P_CNT register */
UINT8 DayAlarm; /* Index to day-of-month alarm in RTC CMOS RAM */
UINT8 MonthAlarm; /* Index to month-of-year alarm in RTC CMOS RAM */
UINT8 Century; /* Index to century in RTC CMOS RAM */
UINT16 BootFlags; /* IA-PC Boot Architecture Flags (see below for individual flags) */
UINT8 Reserved; /* Reserved, must be zero */
UINT32 Flags; /* Miscellaneous flag bits (see below for individual flags) */
ACPI_GENERIC_ADDRESS ResetRegister; /* 64-bit address of the Reset register */
UINT8 ResetValue; /* Value to write to the ResetRegister port to reset the system */
UINT16 ArmBootFlags; /* ARM-Specific Boot Flags (see below for individual flags) (ACPI 5.1) */
UINT8 MinorRevision; /* FADT Minor Revision (ACPI 5.1) */
UINT64 XFacs; /* 64-bit physical address of FACS */
UINT64 XDsdt; /* 64-bit physical address of DSDT */
ACPI_GENERIC_ADDRESS XPm1aEventBlock; /* 64-bit Extended Power Mgt 1a Event Reg Blk address */
ACPI_GENERIC_ADDRESS XPm1bEventBlock; /* 64-bit Extended Power Mgt 1b Event Reg Blk address */
ACPI_GENERIC_ADDRESS XPm1aControlBlock; /* 64-bit Extended Power Mgt 1a Control Reg Blk address */
ACPI_GENERIC_ADDRESS XPm1bControlBlock; /* 64-bit Extended Power Mgt 1b Control Reg Blk address */
ACPI_GENERIC_ADDRESS XPm2ControlBlock; /* 64-bit Extended Power Mgt 2 Control Reg Blk address */
ACPI_GENERIC_ADDRESS XPmTimerBlock; /* 64-bit Extended Power Mgt Timer Ctrl Reg Blk address */
ACPI_GENERIC_ADDRESS XGpe0Block; /* 64-bit Extended General Purpose Event 0 Reg Blk address */
ACPI_GENERIC_ADDRESS XGpe1Block; /* 64-bit Extended General Purpose Event 1 Reg Blk address */
ACPI_GENERIC_ADDRESS SleepControl; /* 64-bit Sleep Control register (ACPI 5.0) */
ACPI_GENERIC_ADDRESS SleepStatus; /* 64-bit Sleep Status register (ACPI 5.0) */
UINT64 HypervisorId; /* Hypervisor Vendor ID (ACPI 6.0) */
} ACPI_TABLE_FADT;
@ -337,8 +327,8 @@ typedef struct acpi_table_fadt
/* Masks for FADT ARM Boot Architecture Flags (arm_boot_flags) ACPI 5.1 */
#define ACPI_FADT_PSCI_COMPLIANT (1) /* 00: [V5] PSCI 0.2+ is implemented */
#define ACPI_FADT_PSCI_USE_HVC (1<<1) /* 01: [V5] HVC must be used instead of SMC as the PSCI conduit */
#define ACPI_FADT_PSCI_COMPLIANT (1) /* 00: [V5+] PSCI 0.2+ is implemented */
#define ACPI_FADT_PSCI_USE_HVC (1<<1) /* 01: [V5+] HVC must be used instead of SMC as the PSCI conduit */
/* Masks for FADT flags */
@ -415,6 +405,7 @@ typedef struct acpi_table_desc
ACPI_NAME_UNION Signature;
ACPI_OWNER_ID OwnerId;
UINT8 Flags;
UINT16 ValidationCount;
} ACPI_TABLE_DESC;
@ -445,34 +436,20 @@ typedef struct acpi_table_desc
* match the expected length. In other words, the length of the
* FADT is the bottom line as to what the version really is.
*
* NOTE: There is no officialy released V2 of the FADT. This
* version was used only for prototyping and testing during the
* 32-bit to 64-bit transition. V3 was the first official 64-bit
* version of the FADT.
*
* Update this list of defines when a new version of the FADT is
* added to the ACPI specification. Note that the FADT version is
* only incremented when new fields are appended to the existing
* version. Therefore, the FADT version is competely independent
* from the version of the ACPI specification where it is
* defined.
*
* For reference, the various FADT lengths are as follows:
* FADT V1 size: 0x074 ACPI 1.0
* FADT V3 size: 0x0F4 ACPI 2.0
* FADT V4 size: 0x100 ACPI 3.0 and ACPI 4.0
* FADT V5 size: 0x10C ACPI 5.0
* FADT V6 size: 0x114 ACPI 6.0
* For reference, the values below are as follows:
* FADT V1 size: 0x074
* FADT V2 size: 0x084
* FADT V3 size: 0x0F4
* FADT V4 size: 0x0F4
* FADT V5 size: 0x10C
* FADT V6 size: 0x114
*/
#define ACPI_FADT_V1_SIZE (UINT32) (ACPI_FADT_OFFSET (Flags) + 4) /* ACPI 1.0 */
#define ACPI_FADT_V3_SIZE (UINT32) (ACPI_FADT_OFFSET (SleepControl)) /* ACPI 2.0 */
#define ACPI_FADT_V4_SIZE (UINT32) (ACPI_FADT_OFFSET (SleepStatus)) /* ACPI 3.0 and ACPI 4.0 */
#define ACPI_FADT_V5_SIZE (UINT32) (ACPI_FADT_OFFSET (HypervisorId)) /* ACPI 5.0 */
#define ACPI_FADT_V6_SIZE (UINT32) (sizeof (ACPI_TABLE_FADT)) /* ACPI 6.0 */
#define ACPI_FADT_V1_SIZE (UINT32) (ACPI_FADT_OFFSET (Flags) + 4)
#define ACPI_FADT_V2_SIZE (UINT32) (ACPI_FADT_OFFSET (MinorRevision) + 1)
#define ACPI_FADT_V3_SIZE (UINT32) (ACPI_FADT_OFFSET (SleepControl))
#define ACPI_FADT_V5_SIZE (UINT32) (ACPI_FADT_OFFSET (HypervisorId))
#define ACPI_FADT_V6_SIZE (UINT32) (sizeof (ACPI_TABLE_FADT))
/* Update these when new FADT versions are added */
#define ACPI_FADT_MAX_VERSION 6
#define ACPI_FADT_CONFORMANCE "ACPI 6.1 (FADT version 6)"
#endif /* __ACTBL_H__ */

4
sys/contrib/dev/acpica/include/acutils.h
View File

@ -283,6 +283,10 @@ const char *
AcpiUtGetEventName (
UINT32 EventId);
const char *
AcpiUtGetArgumentTypeName (
UINT32 ArgType);
char
AcpiUtHexToAsciiChar (
UINT64 Integer,

22
sys/contrib/dev/acpica/include/amlcode.h
View File

@ -243,6 +243,7 @@
#define ARGP_QWORDDATA 0x11
#define ARGP_SIMPLENAME 0x12 /* NameString | LocalTerm | ArgTerm */
#define ARGP_NAME_OR_REF 0x13 /* For ObjectType only */
#define ARGP_MAX 0x13
/*
* Resolved argument types for the AML Interpreter
@ -279,9 +280,24 @@
#define ARGI_DEVICE_REF 0x0D
#define ARGI_REFERENCE 0x0E
#define ARGI_TARGETREF 0x0F /* Target, subject to implicit conversion */
#define ARGI_FIXED_TARGET 0x10 /* Target, no implicit conversion */
#define ARGI_SIMPLE_TARGET 0x11 /* Name, Local, Arg -- no implicit conversion */
#define ARGI_STORE_TARGET 0x12 /* Target for store is TARGETREF + package objects */
#define ARGI_SIMPLE_TARGET 0x10 /* Name, Local, Arg -- no implicit conversion */
#define ARGI_STORE_TARGET 0x11 /* Target for store is TARGETREF + package objects */
/*
* #define ARGI_FIXED_TARGET 0x10 Target, no implicit conversion
*
* Removed 10/2016. ARGI_FIXED_TARGET was used for these operators:
* FromBCD
* ToBCD
* ToDecimalString
* ToHexString
* ToInteger
* ToBuffer
* The purpose of this type was to disable "implicit result conversion",
* but this was incorrect per the ACPI spec and other ACPI implementations.
* These operators now have the target operand defined as a normal
* ARGI_TARGETREF.
*/
/* Multiple/complex types */