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

MFV: r360512

Browse Source 
Merge ACPICA 20200430.
This commit is contained in:
Jung-uk Kim 2020-05-01 01:26:36 +00:00
commit 08ddfe8657
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=360517
17 changed files with 307 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,3 +1,60 @@
----------------------------------------
30 April 2020. Summary of changes for version 20200430:
1) ACPICA kernel-resident subsystem:
Cleaned up the coding style of a couple of global variables
(AcpiGbl_NextCmdNum and AcpiProtocolLengths) caught by static analyzers.
AcpiProtocolLengths was made static, and the definition of
AcpiGbl_NextCmdNum was moved to acglobal.h.
2) iASL Compiler/Disassembler and ACPICA tools:
iASL DataTable Compiler: Fixed a segfault on errors that aren't directly
associated with a field.
Disassembler: has been made more resilient so that it will continue to
parse AML even if the AML generates ACPI namespace errors. This enables
iASL to disassemble some AML that may have been compiled using older
versions of iASL that no longer compile with newer versions of iASL.
iASL: Fixed the required parameters for _NIH and _NIG. Previously, there
was a mixup where _NIG required one parameter and _NIH required zero
parameters. This change swaps these parameter requirements. Now it is
required that _NIH must be called with one parameter and _NIG requires
zero parameters.
iASL: Allow use of undefined externals as long as they are protected by
an if (CondRefOf (...)) block when compiling multiple definition blocks.
iASL: Fixed the type override behavior of named objects that are declared
as External. External declarations will no longer override the type of
the actual definition if it already exists.
AcpiNames: Added setargv.obj to the MSVC 2017 link sequence to enable
command line wildcard support on Windows. Note: the AcpiNames utility is
essentially redundant with the AcpiExec utility (using the "namespace"
command) and is therefore deprecated. It will be removed in future
releases of ACPICA.
Disassembler: ignore AE_ALREADY_EXISTS status when parsing create*
operators. The disassembler is intended to emit existing ASL code as-is.
Therefore, error messages emitted during disassembly should be ignored or
handled in a way such that the disassembler can continue to parse the
AML. This change ignores AE_ALREADY_EXISTS errors during the deferred Op
parsing for create operators in order to complete parsing ASL termlists.
iASL DataTable Compiler: IVRS table: fix potentially uninitialized
variable warning. Some compilers catch potential uninitialized variables.
This is done by examining branches of if/else statements. This change
replaces an "else if" with an "else" to fix the uninitialized variable
warning.
----------------------------------------
26 March 2020. Summary of changes for version 20200326:
@ -674,7 +731,7 @@ temporary.
iASL: Emit error for creation of a zero-length operation region. Such a
region is rather pointless. If encountered, a runtime error is also
implemented in the interpeter.
implemented in the interpreter.
Debugger: Fix a possible fault with the "test objects" command.

2
sys/contrib/dev/acpica/common/acgetline.c
View File

@ -189,8 +189,6 @@ AcpiAcClearLine (
#define _ASCII_LEFT_ARROW 'D'
#define _ASCII_NEWLINE '\n'
extern UINT32 AcpiGbl_NextCmdNum;
/* Erase a single character on the input command line */
#define ACPI_CLEAR_CHAR() \

4
sys/contrib/dev/acpica/common/dmtbdump2.c
View File

@ -528,8 +528,10 @@ AcpiDmDumpIvrs (
DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
sizeof (ACPI_IVRS_HARDWARE1));
}
else if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE2)
else
{
/* ACPI_IVRS_TYPE_HARDWARE2 subtable type */
EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE2);
DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
sizeof (ACPI_IVRS_HARDWARE2));

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

@ -819,7 +819,7 @@ NamePathTail [.]{NameSeg}
}
/*
* The eror code is contained inside the
* The error code is contained inside the
* {ErrorCode} pattern. Extract it and log it
* as the expected error code.
*/

81
sys/contrib/dev/acpica/compiler/aslload.c
View File

@ -1,6 +1,6 @@
/******************************************************************************
*
* Module Name: dswload - Dispatcher namespace load callbacks
* Module Name: aslload - compiler namespace load callbacks
*
*****************************************************************************/
@ -201,7 +201,6 @@ LdAnalyzeExternals (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op,
ACPI_OBJECT_TYPE ExternalOpType,
ACPI_OBJECT_TYPE ObjectType,
ACPI_WALK_STATE *WalkState);
@ -515,7 +514,6 @@ LdNamespace1Begin (
ACPI_PARSE_OBJECT *MethodOp;
ACPI_STATUS Status;
ACPI_OBJECT_TYPE ObjectType;
ACPI_OBJECT_TYPE ActualObjectType = ACPI_TYPE_ANY;
char *Path;
UINT32 Flags = ACPI_NS_NO_UPSEARCH;
ACPI_PARSE_OBJECT *Arg;
@ -689,8 +687,7 @@ LdNamespace1Begin (
*
* first child is name, next child is ObjectType
*/
ActualObjectType = (UINT8) Op->Asl.Child->Asl.Next->Asl.Value.Integer;
ObjectType = ACPI_TYPE_ANY;
ObjectType = (UINT8) Op->Asl.Child->Asl.Next->Asl.Value.Integer;
/*
* We will mark every new node along the path as "External". This
@ -709,7 +706,7 @@ LdNamespace1Begin (
* Store (\_SB_.PCI0.ABCD, Local0)
* }
*/
Flags |= ACPI_NS_EXTERNAL;
Flags |= ACPI_NS_EXTERNAL | ACPI_NS_DONT_OPEN_SCOPE;
break;
case PARSEOP_DEFAULT_ARG:
@ -913,8 +910,7 @@ LdNamespace1Begin (
else if ((Node->Flags & ANOBJ_IS_EXTERNAL) ||
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))
{
Status = LdAnalyzeExternals (Node, Op, ActualObjectType,
ObjectType, WalkState);
Status = LdAnalyzeExternals (Node, Op, ObjectType, WalkState);
if (ACPI_FAILURE (Status))
{
if (Status == AE_ERROR)
@ -929,6 +925,19 @@ LdNamespace1Begin (
}
return_ACPI_STATUS (Status);
}
if (!(Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))
{
/*
* If we get to here, it means that an actual definition of
* the object declared external exists. Meaning that Op
* loading this this Op should have no change to the ACPI
* namespace. By going to FinishNode, we skip the
* assignment of Node->Op = Op.
*/
goto FinishNode;
}
}
else
{
@ -980,30 +989,15 @@ LdNamespace1Begin (
}
}
FinishNode:
/*
* Point the parse node to the new namespace node, and point
* the Node back to the original Parse node
*/
Op->Asl.Node = Node;
/* Point the Node back to the original Parse node */
Node->Op = Op;
/*
* Set the actual data type if appropriate (EXTERNAL term only)
* As of 11/19/2019, ASL External() does not support parameter
* counts. When an External method is loaded, the parameter count is
* recorded in the external's arg count parameter. The parameter count may
* or may not be known in the declaration. If the value of this node turns
* out to be ASL_EXTERNAL_METHOD_UNKNOWN_PARAMS, it indicates that
* we do not know the parameter count and that we must look at the usage of
* the External method call to get this information.
*/
if (ActualObjectType != ACPI_TYPE_ANY)
{
Node->Type = (UINT8) ActualObjectType;
Node->Value = (UINT32)
Op->Asl.Child->Asl.Next->Asl.Next->Asl.Value.Integer;
}
FinishNode:
/* Point the parse node to the new namespace node */
Op->Asl.Node = Node;
if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
{
@ -1013,6 +1007,13 @@ LdNamespace1Begin (
*/
Node->Value = (UINT32) Op->Asl.Extra;
}
else if (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL &&
Node->Type == ACPI_TYPE_METHOD &&
(Node->Flags & ANOBJ_IS_EXTERNAL))
{
Node->Value =
(UINT32) Op->Asl.Child->Asl.Next->Asl.Next->Asl.Value.Integer;
}
return_ACPI_STATUS (Status);
}
@ -1020,7 +1021,7 @@ LdNamespace1Begin (
/*******************************************************************************
*
* FUNCTION: LdAnalyzeExternals
* FUNCTION: LdMatchExternType
*
* PARAMETERS: Type1
* Type2
@ -1037,7 +1038,7 @@ LdNamespace1Begin (
******************************************************************************/
static BOOLEAN
LdTypesMatchExternType (
LdMatchExternType (
ACPI_OBJECT_TYPE Type1,
ACPI_OBJECT_TYPE Type2)
{
@ -1093,7 +1094,6 @@ LdTypesMatchExternType (
* PARAMETERS: Node - Node that represents the named object
* Op - Named object declaring this named object
* ExternalOpType - Type of ExternalOp
* ObjectType - Type of Declared object
* WalkState - Current WalkState
*
* RETURN: Status
@ -1111,7 +1111,6 @@ LdAnalyzeExternals (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op,
ACPI_OBJECT_TYPE ExternalOpType,
ACPI_OBJECT_TYPE ObjectType,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
@ -1135,12 +1134,12 @@ LdAnalyzeExternals (
else
{
ActualExternalOpType = Node->Type;
ActualOpType = ObjectType;
ActualOpType = ExternalOpType;
}
if ((ActualOpType != ACPI_TYPE_ANY) &&
(ActualExternalOpType != ACPI_TYPE_ANY) &&
!LdTypesMatchExternType (ActualExternalOpType, ActualOpType))
!LdMatchExternType (ActualExternalOpType, ActualOpType))
{
if (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL &&
Node->Op->Asl.ParseOpcode == PARSEOP_EXTERNAL)
@ -1168,6 +1167,8 @@ LdAnalyzeExternals (
}
}
/* Set the object type of the external */
if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode != PARSEOP_EXTERNAL))
{
@ -1176,13 +1177,13 @@ LdAnalyzeExternals (
* previously declared External
*/
Node->Flags &= ~ANOBJ_IS_EXTERNAL;
Node->Type = (UINT8) ObjectType;
Node->Type = (UINT8) ExternalOpType;
/* Just retyped a node, probably will need to open a scope */
if (AcpiNsOpensScope (ObjectType))
if (AcpiNsOpensScope (ExternalOpType))
{
Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
Status = AcpiDsScopeStackPush (Node, ExternalOpType, WalkState);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1203,7 +1204,7 @@ LdAnalyzeExternals (
}
else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) &&
(ObjectType == ACPI_TYPE_ANY))
(ExternalOpType == ACPI_TYPE_ANY))
{
/* Allow update of externals of unknown type. */

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

@ -380,6 +380,7 @@ const char *AslCompilerMsgs [] =
/* ASL_MSG_TYPE_MISMATCH_FOUND_HERE */ "Actual object declaration:",
/* ASL_MSG_DUPLICATE_EXTERN_MISMATCH */ "Type mismatch between multiple external declarations detected",
/* ASL_MSG_DUPLICATE_EXTERN_FOUND_HERE */"Duplicate external declaration:",
/* ASL_MSG_CONDREF_NEEDS_EXTERNAL_DECL */"CondRefOf parameter requires External() declaration",
};
/* Table compiler */

1
sys/contrib/dev/acpica/compiler/aslmessages.h
View File

@ -382,6 +382,7 @@ typedef enum
ASL_MSG_TYPE_MISMATCH_FOUND_HERE,
ASL_MSG_DUPLICATE_EXTERN_MISMATCH,
ASL_MSG_DUPLICATE_EXTERN_FOUND_HERE,
ASL_MSG_CONDREF_NEEDS_EXTERNAL_DECL,
/* These messages are used by the Data Table compiler only */

2
sys/contrib/dev/acpica/compiler/aslpredef.c
View File

@ -674,7 +674,7 @@ ApCheckForSpecialName (
/*
* Was not actually emitted by the compiler. This is a special case,
* however. If the ASL code being compiled was the result of a
* dissasembly, it may possibly contain valid compiler-emitted names
* disassembly, it may possibly contain valid compiler-emitted names
* of the form "_T_x". We don't want to issue an error or even a
* warning and force the user to manually change the names. So, we
* will issue a remark instead.

165
sys/contrib/dev/acpica/compiler/aslxref.c
View File

@ -199,6 +199,16 @@ XfCheckFieldRange (
UINT32 FieldBitLength,
UINT32 AccessBitWidth);
static BOOLEAN
XfFindCondRefOfName (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op);
static BOOLEAN
XfRefIsGuardedByIfCondRefOf (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op);
/*******************************************************************************
*
@ -581,17 +591,6 @@ XfNamespaceLocateBegin (
return_ACPI_STATUS (AE_OK);
}
/*
* One special case: CondRefOf operator - we don't care if the name exists
* or not at this point, just ignore it, the point of the operator is to
* determine if the name exists at runtime.
*/
if ((Op->Asl.Parent) &&
(Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CONDREFOF))
{
return_ACPI_STATUS (AE_OK);
}
/*
* We must enable the "search-to-root" for single NameSegs, but
* we have to be very careful about opening up scopes
@ -600,7 +599,8 @@ XfNamespaceLocateBegin (
if ((Op->Asl.ParseOpcode == PARSEOP_NAMESTRING) ||
(Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
(Op->Asl.ParseOpcode == PARSEOP_METHODCALL) ||
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) ||
(Op->Asl.ParseOpcode == PARSEOP_CONDREFOF))
{
/*
* These are name references, do not push the scope stack
@ -665,7 +665,22 @@ XfNamespaceLocateBegin (
* We didn't find the name reference by path -- we can qualify this
* a little better before we print an error message
*/
if (strlen (Path) == ACPI_NAMESEG_SIZE)
if ((Op->Asl.Parent) &&
(Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_CONDREFOF))
{
/*
* One special case: CondRefOf operator - if the name doesn't
* exist at this point, it means that there's no actual or
* external declaration. If the name is not found, just ignore
* it, the point of the operator is to determine if the name
* exists at runtime. We wanted to see if this named object
* exists to facilitate analysis to allow protected usage of
* undeclared externals.
*/
return_ACPI_STATUS (AE_OK);
}
else if (strlen (Path) == ACPI_NAMESEG_SIZE)
{
/* A simple, one-segment ACPI name */
@ -1190,6 +1205,7 @@ XfNamespaceLocateBegin (
/*
* 5) Check for external resolution
*
* By this point, everything should be loaded in the namespace. If a
* namespace lookup results in a namespace node that is an external, it
* means that this named object was not defined in the input ASL. This
@ -1197,11 +1213,38 @@ XfNamespaceLocateBegin (
* use the external keyword to suppress compiler errors about undefined
* objects. Note: this only applies when compiling multiple definition
* blocks.
*
* Do not check for external resolution in the following cases:
*
* case 1) External (ABCD)
*
* This declares ABCD as an external so there is no requirement for
* ABCD to be loaded in the namespace when analyzing the actual
* External() statement.
*
* case 2) CondRefOf (ABCD)
*
* This operator will query the ACPI namespace on the existence of
* ABCD. If ABCD does not exist, this operator will return a 0
* without incurring AML runtime errors. Therefore, ABCD is allowed
* to not exist when analyzing the CondRefOf operator.
*
* case 3) External (ABCD)
* if (CondRefOf (ABCD))
* {
* Store (0, ABCD)
* }
*
* In this case, ABCD is accessed only if it exists due to the if
* statement so there is no need to flag the ABCD nested in the
* store operator.
*/
if (AslGbl_ParseTreeRoot->Asl.Child && AslGbl_ParseTreeRoot->Asl.Child->Asl.Next &&
(Op->Asl.ParseOpcode != PARSEOP_EXTERNAL &&
Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_EXTERNAL) &&
(Node->Flags & ANOBJ_IS_EXTERNAL))
(Node->Flags & ANOBJ_IS_EXTERNAL) &&
Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_EXTERNAL &&
Op->Asl.ParseOpcode != PARSEOP_EXTERNAL &&
Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_CONDREFOF &&
!XfRefIsGuardedByIfCondRefOf (Node, Op))
{
AslError (ASL_ERROR, ASL_MSG_UNDEFINED_EXTERNAL, Op, NULL);
}
@ -1219,6 +1262,96 @@ XfNamespaceLocateBegin (
}
/*******************************************************************************
*
* FUNCTION: XfRefIsGuardedByIfCondRefOf
*
* PARAMETERS: Node - Named object reference node
* Op - Named object reference parse node
*
* RETURN: BOOLEAN
*
* DESCRIPTION: returns true if Op checked inside if (CondRefOf (...))
* refers to Node.
*
******************************************************************************/
static BOOLEAN
XfRefIsGuardedByIfCondRefOf (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *Parent = Op->Asl.Parent;
while (Parent)
{
if (Parent->Asl.ParseOpcode == PARSEOP_IF &&
XfFindCondRefOfName (Node, Parent->Asl.Child))
{
return (TRUE);
}
Parent = Parent->Asl.Parent;
}
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: XfRefIsGuardedByIfCondRefOf
*
* PARAMETERS: Node - Named object reference node
* Op - Named object reference parse node
*
* RETURN: BOOLEAN
*
* DESCRIPTION: returns true if Op checked inside if (CondRefOf (...))
* refers to Node.
*
******************************************************************************/
static BOOLEAN
XfFindCondRefOfName (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op)
{
BOOLEAN CondRefOfFound = FALSE;
if (!Op)
{
return (FALSE);
}
switch (Op->Asl.ParseOpcode)
{
case PARSEOP_CONDREFOF:
return (Op->Asl.Child->Common.Node == Node);
break;
case PARSEOP_LAND:
CondRefOfFound = XfFindCondRefOfName (Node, Op->Asl.Child);
if (CondRefOfFound)
{
return (TRUE);
}
return (XfFindCondRefOfName (Node, Op->Asl.Child->Asl.Next));
break;
default:
return (FALSE);
break;
}
}
/*******************************************************************************
*
* FUNCTION: XfNamespaceLocateEnd

11
sys/contrib/dev/acpica/compiler/dtutils.c
View File

@ -186,11 +186,20 @@ DtError (
DT_FIELD *FieldObject,
char *ExtraMessage)
{
UINT32 Line = 0;
/* Field object could be NULL */
if (FieldObject)
{
Line = FieldObject->Line;
}
/* Check if user wants to ignore this exception */
if (AslIsExceptionIgnored (AslGbl_Files[ASL_FILE_INPUT].Filename,
FieldObject->Line, Level, MessageId))
Line, Level, MessageId))
{
return;
}

1
sys/contrib/dev/acpica/components/debugger/dbhistry.c
View File

@ -175,7 +175,6 @@ static HISTORY_INFO AcpiGbl_HistoryBuffer[HISTORY_SIZE];
static UINT16 AcpiGbl_LoHistory = 0;
static UINT16 AcpiGbl_NumHistory = 0;
static UINT16 AcpiGbl_NextHistoryIndex = 0;
UINT32 AcpiGbl_NextCmdNum = 1;
/*******************************************************************************

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

@ -400,6 +400,10 @@ AcpiDmIsUuidBuffer (
/* Buffer size is the buffer argument */
SizeOp = Op->Common.Value.Arg;
if (!SizeOp)
{
return (FALSE);
}
/* Next, the initializer byte list to examine */
@ -520,6 +524,10 @@ AcpiDmIsUnicodeBuffer (
/* Buffer size is the buffer argument */
SizeOp = Op->Common.Value.Arg;
if (!SizeOp)
{
return (FALSE);
}
/* Next, the initializer byte list to examine */
@ -596,6 +604,10 @@ AcpiDmIsStringBuffer (
/* Buffer size is the buffer argument */
SizeOp = Op->Common.Value.Arg;
if (!SizeOp)
{
return (FALSE);
}
/* Next, the initializer byte list to examine */
@ -675,13 +687,18 @@ AcpiDmIsPldBuffer (
UINT64 InitializerSize;
if (!Op)
{
return (FALSE);
}
/*
* Get the BufferSize argument - Buffer(BufferSize)
* If the buffer was generated by the ToPld macro, it must
* be a BYTE constant.
*/
SizeOp = Op->Common.Value.Arg;
if (SizeOp->Common.AmlOpcode != AML_BYTE_OP)
if (!SizeOp || SizeOp->Common.AmlOpcode != AML_BYTE_OP)
{
return (FALSE);
}

24
sys/contrib/dev/acpica/components/dispatcher/dsfield.c
View File

@ -341,7 +341,12 @@ AcpiDsCreateBufferField (
Status = AcpiNsLookup (WalkState->ScopeInfo,
Arg->Common.Value.String, ACPI_TYPE_ANY,
ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
if (ACPI_FAILURE (Status))
if ((WalkState->ParseFlags & ACPI_PARSE_DISASSEMBLE) &&
Status == AE_ALREADY_EXISTS)
{
Status = AE_OK;
}
else if (ACPI_FAILURE (Status))
{
ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo,
Arg->Common.Value.String, Status);
@ -682,12 +687,21 @@ AcpiDsCreateField (
Info.RegionNode = RegionNode;
Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next);
if (Info.RegionNode->Object->Region.SpaceId == ACPI_ADR_SPACE_PLATFORM_COMM &&
!(RegionNode->Object->Field.InternalPccBuffer
= ACPI_ALLOCATE_ZEROED(Info.RegionNode->Object->Region.Length)))
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (AE_NO_MEMORY);
return_ACPI_STATUS (Status);
}
if (Info.RegionNode->Object->Region.SpaceId == ACPI_ADR_SPACE_PLATFORM_COMM)
{
RegionNode->Object->Field.InternalPccBuffer =
ACPI_ALLOCATE_ZEROED(Info.RegionNode->Object->Region.Length);
if (!RegionNode->Object->Field.InternalPccBuffer)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
}
return_ACPI_STATUS (Status);
}

2
sys/contrib/dev/acpica/components/executer/exfield.c
View File

@ -167,7 +167,7 @@
#define ACPI_INVALID_PROTOCOL_ID 0x80
#define ACPI_MAX_PROTOCOL_ID 0x0F
const UINT8 AcpiProtocolLengths[] =
static const UINT8 AcpiProtocolLengths[] =
{
ACPI_INVALID_PROTOCOL_ID, /* 0 - reserved */
ACPI_INVALID_PROTOCOL_ID, /* 1 - reserved */

1
sys/contrib/dev/acpica/include/acglobal.h
View File

@ -436,6 +436,7 @@ ACPI_GLOBAL (ACPI_EXTERNAL_FILE *, AcpiGbl_ExternalFileList);
#ifdef ACPI_DEBUGGER
ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_AbortMethod, FALSE);
ACPI_INIT_GLOBAL (ACPI_THREAD_ID, AcpiGbl_DbThreadId, ACPI_INVALID_THREAD_ID);
ACPI_INIT_GLOBAL (UINT32, AcpiGbl_NextCmdNum, 1);
ACPI_GLOBAL (BOOLEAN, AcpiGbl_DbOpt_NoIniMethods);
ACPI_GLOBAL (BOOLEAN, AcpiGbl_DbOpt_NoRegionSupport);

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

@ -154,7 +154,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20200326
#define ACPI_CA_VERSION 0x20200430
#include <contrib/dev/acpica/include/acconfig.h>
#include <contrib/dev/acpica/include/actypes.h>

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

@ -769,10 +769,10 @@ const ACPI_PREDEFINED_INFO AcpiGbl_PredefinedMethods[] =
{{"_NIC", METHOD_0ARGS, /* ACPI 6.3 */
METHOD_RETURNS (ACPI_RTYPE_BUFFER)}},
{{"_NIG", METHOD_1ARGS (ACPI_TYPE_BUFFER), /* ACPI 6.3 */
{{"_NIG", METHOD_0ARGS, /* ACPI 6.3 */
METHOD_RETURNS (ACPI_RTYPE_BUFFER)}},
{{"_NIH", METHOD_0ARGS, /* ACPI 6.3 */
{{"_NIH", METHOD_1ARGS (ACPI_TYPE_BUFFER), /* ACPI 6.3 */
METHOD_RETURNS (ACPI_RTYPE_BUFFER)}},
{{"_NTT", METHOD_0ARGS,