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

Merge ACPICA 20200214.

Browse Source
This commit is contained in:
Jung-uk Kim 2020-02-14 19:19:39 +00:00
parent 8bf5cb5c35
commit aa36cd6999
44 changed files with 1253 additions and 5349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
changes.txt
View File

@ -1,3 +1,101 @@
----------------------------------------
14 February 2020. Summary of changes for version 20200214:
1) ACPICA kernel-resident subsystem:
Enable sleep button on ACPI legacy wake: Hibernation (S4) is triggered
in a guest when it receives a sleep trigger from the hypervisor. When the
guest resumes from this power state, it does not see the SleepEnabled
bit. In other words, the sleepHibernation (S4) is triggered in a guest
when it receives a sleep trigger from the hypervisor. When the guest
resumes from this power state, it does not see the SleepEnabled bit. In
other words, the sleep button is not enabled on waking from an S4 state.
This causes subsequent invocation of sleep state to fail since the
guest.button is not enabled on waking from an S4 state. This causes
subsequent invocation of sleep state to fail in the guest. Fix this
problem by enabling the sleep button in ACPI legacy wake. From Anchal
Agarwal <anchalag@amazon.com>.
Implemented a new external interface, AcpiAnyGpeStatusSet (). To be used
for checking the status bits of all enabled GPEs in one go. It is needed
to distinguish spurious SCIs from genuine ones when deciding whether or
not to wake up the system from suspend-to-idle.
Generic Makefiles: replace HOST name with ACPI_HOST: Some machines may be
using HOST in their environment to represent the host name for their
machines. Avoid this problem by renaming this variable from HOST to
ACPI_HOST.
MSVC 2017 project files: Enable multiprocessor generation to improve
build performance.
Added a macro to get the byte width of a Generic Address structure. New
ACPI_ACCESS_BYTE_WIDTH is in addition to the existing
ACPI_ACCESS_BIT_WIDTH. From Mika Westerberg.
2) iASL Compiler/Disassembler and ACPICA tools:
iASL: Implemented full support for the (optional, rarely used) ReturnType
and ParameterTypesList for the Method, Function, and External operators.
For Method declarations, the number of individual ParameterTypes must
match the declaration of the number of arguments (NumArgs). This also
Fixes a problem with the External operator where extra/extraneous bytes
were emitted in the AML code if the optional ReturnType/ParameterTypes
were specified for a MethodObj declaration.
New error message:
1) Method NumArgs count does not match length of ParameterTypes list
iASL: Implemented detection of type mismatches between External
declarations and named object declarations. Also, detect type mismatches
between multiple External declarations of the same Name.
New error messages:
1) Type mismatch between external declaration and actual object
declaration detected
2) Type mismatch between multiple external declarations detected
iASL: Implemented new error messages for External operators that specify
a ReturnType and/or ParameterTypesList for any object type other than
control methods (MethodObj).
New error messages:
1) Return type is only allowed for Externals declared as MethodObj
2) Parameter type is only allowed for Externals declared as MethodObj
iASL: Implemented two new remark/warning messages for ASL code that
creates named objects from within a control method. This is very
inefficient since the named object must be created and deleted each time
the method is executed.
New messages:
1) Creation of named objects within a method is highly inefficient, use
globals or method local variables instead (remark)
2) Static OperationRegion should be declared outside control method
(warning)
iASL: Improved illegal forward reference detection by adding support to
detect forward-reference method invocations.
iASL: Detect and issue an error message for NameStrings that contain too
many individual NameSegs (>255). This is an AML limitation that is
defined in the ACPI specification.
New message:
1) NameString contains too many NameSegs (>255)
acpidump: windows: use GetSystemFirmwareTable API for all tables except
SSDT. By using this API, acpidump is able to get all tables in the XSDT
iASL: Removed unused parser file and updated msvc2017 project files.
Removed the obsolete AslCompiler.y from the repository.
iASL: msvc2017: Fixed macros in the file dependency list to prevent
unnecessary rebuilds. Replace %(Directory) with %(RelativeDir).
Disassembler: Prevent spilling error messages to the output file. All
errors are directed to the console instead. These error messages
prevented re-compilation of the resulting disassembled ASL output file
(.DSL).
----------------------------------------
10 January 2020. Summary of changes for version 20200110:
@ -8845,8 +8943,8 @@ much larger code and data size.
Fix build error under Bison-2.4.
Dissasembler: Enhanced FADT support. Added decoding of the Boot
Architecture
Disassembler: Enhanced FADT support. Added decoding of the Boot
Architecture
flags. Now decode all flags, regardless of the FADT version. Flag output
includes the FADT version which first defined each flag.

1
generate/lint/files.lnt
View File

@ -12,4 +12,3 @@
..\..\source\components\resources\*.c
..\..\source\components\tables\*.c
..\..\source\components\utilities\*.c

1
generate/lint/lint.bat
View File

@ -13,4 +13,3 @@ echo 32-bit lint completed >> LintOut.txt
@echo off
echo ---
echo Output placed in LintOut.txt

1
generate/lint/readme.txt
View File

@ -11,4 +11,3 @@ std32.lnt - 32-bit options
std64.lnt - 64-bit options
options.lnt - common options
others - windows/dos compiler option files

1
generate/lint/std16.lnt
View File

@ -13,4 +13,3 @@ c:\acpi\generate\lint\co-msc40.lnt
options.lnt -mL -si2 -spN2 -spF4 -sl4

1
generate/lint/std64.lnt
View File

@ -15,4 +15,3 @@
co.lnt
options.lnt

26
generate/unix/Makefile.config
View File

@ -26,15 +26,15 @@
# Notes:
# gcc should be version 4 or greater, otherwise some of the options
# used will not be recognized.
# Optional: Set HOST to an appropriate value (_LINUX, _FreeBSD, _APPLE, _CYGWIN, etc.)
# Optional: Set ACPI_HOST to an appropriate value (_LINUX, _FreeBSD, _APPLE, _CYGWIN, etc.)
# See include/platform/acenv.h for supported values.
# Note: HOST is not nearly as important for applications as it
# Note: ACPI_HOST is not nearly as important for applications as it
# is for the kernel-resident version of ACPICA, and it may
# not be necessary to change it.
#
.SUFFIXES :
PROGS = acpibin acpidump acpiexamples acpiexec acpihelp acpinames acpisrc acpixtract iasl
HOST ?= _CYGWIN
ACPI_HOST ?= _CYGWIN
CC ?= gcc
#
@ -52,26 +52,26 @@ UNAME_S := $(shell uname -s)
# Host detection and configuration
#
ifeq ($(UNAME_S), Darwin) # Mac OS X
HOST = _APPLE
ACPI_HOST = _APPLE
endif
ifeq ($(UNAME_S), DragonFly)
HOST = _DragonFly
ACPI_HOST = _DragonFly
endif
ifeq ($(UNAME_S), FreeBSD)
HOST = _FreeBSD
ACPI_HOST = _FreeBSD
endif
ifeq ($(UNAME_S), NetBSD)
HOST = _NetBSD
ACPI_HOST = _NetBSD
endif
ifeq ($(UNAME_S), QNX)
HOST = _QNX
ACPI_HOST = _QNX
endif
ifeq ($(HOST), _APPLE)
ifeq ($(ACPI_HOST), _APPLE)
INSTALL = cp
INSTALLFLAGS ?= -f
else
@ -183,7 +183,7 @@ OPT_CFLAGS += -D_FORTIFY_SOURCE=2
endif
CFLAGS += \
-D$(HOST)\
-D$(ACPI_HOST)\
-D_GNU_SOURCE\
-I$(ACPICA_INCLUDE)
@ -191,7 +191,7 @@ CFLAGS += \
# QNX requires __EXT to enable most functions in its C library, analogous
# to _GNU_SOURCE.
#
ifeq ($(HOST), _QNX)
ifeq ($(ACPI_HOST), _QNX)
CFLAGS+=-D__EXT
endif
@ -231,11 +231,11 @@ CWARNINGFLAGS += \
#
# Per-host flags and exclusions
#
ifneq ($(HOST), _FreeBSD)
ifneq ($(ACPI_HOST), _FreeBSD)
CWARNINGFLAGS += \
-Wempty-body
ifneq ($(HOST), _APPLE)
ifneq ($(ACPI_HOST), _APPLE)
CWARNINGFLAGS += \
-Woverride-init\
-Wlogical-op\

8
generate/unix/acpidump/Makefile
View File

@ -54,19 +54,19 @@ OBJECTS = \
#
# Per-host interfaces
#
ifeq ($(HOST), _DragonFly)
ifeq ($(ACPI_HOST), _DragonFly)
HOST_FAMILY = BSD
endif
ifeq ($(HOST), _FreeBSD)
ifeq ($(ACPI_HOST), _FreeBSD)
HOST_FAMILY = BSD
endif
ifeq ($(HOST), _NetBSD)
ifeq ($(ACPI_HOST), _NetBSD)
HOST_FAMILY = BSD
endif
ifeq ($(HOST), _QNX)
ifeq ($(ACPI_HOST), _QNX)
HOST_FAMILY = BSD
endif

6
generate/unix/acpiexec/Makefile
View File

@ -255,12 +255,12 @@ CFLAGS += \
-DACPI_CHECKSUM_ABORT=TRUE
endif
ifneq ($(HOST),_QNX)
ifneq ($(ACPI_HOST),_QNX)
LDFLAGS += -lpthread
endif
ifneq ($(HOST),_APPLE)
ifneq ($(HOST),_QNX)
ifneq ($(ACPI_HOST),_APPLE)
ifneq ($(ACPI_HOST),_QNX)
LDFLAGS += -lrt
endif
endif

19
source/common/adisasm.c
View File

@ -156,6 +156,7 @@
#include "acnamesp.h"
#include "acparser.h"
#include "acapps.h"
#include "acconvert.h"
#define _COMPONENT ACPI_TOOLS
@ -379,8 +380,6 @@ AdAmlDisassemble (
Status = AE_ERROR;
goto Cleanup;
}
AcpiOsRedirectOutput (File);
}
*OutFilename = DisasmFilename;
@ -467,6 +466,11 @@ AdDisassembleOneTable (
if (!AcpiGbl_ForceAmlDisassembly && !AcpiUtIsAmlTable (Table))
{
if (File)
{
AcpiOsRedirectOutput (File);
}
AdDisassemblerHeader (Filename, ACPI_IS_DATA_TABLE);
/* This is a "Data Table" (non-AML table) */
@ -489,6 +493,10 @@ AdDisassembleOneTable (
return (AE_OK);
}
/* Initialize the converter output file */
ASL_CV_INIT_FILETREE(Table, File);
/*
* This is an AML table (DSDT or SSDT).
* Always parse the tables, only option is what to display
@ -501,6 +509,13 @@ AdDisassembleOneTable (
return (Status);
}
/* Redirect output for code generation and debugging output */
if (File)
{
AcpiOsRedirectOutput (File);
}
/* Debug output, namespace and parse tree */
if (AslCompilerdebug && File)

1
source/common/dmtables.c
View File

@ -506,7 +506,6 @@ AdParseTable (
AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER));
ASL_CV_INIT_FILETREE(Table, AmlStart, AmlLength);
AcpiUtSetIntegerWidth (Table->Revision);

14
source/compiler/aslanalyze.c
View File

@ -151,6 +151,7 @@
#include "aslcompiler.h"
#include "aslcompiler.y.h"
#include "acnamesp.h"
#include <string.h>
@ -421,6 +422,7 @@ AnCheckMethodReturnValue (
{
ACPI_PARSE_OBJECT *OwningOp;
ACPI_NAMESPACE_NODE *Node;
char *ExternalPath;
Node = ArgOp->Asl.Node;
@ -435,18 +437,19 @@ AnCheckMethodReturnValue (
/* Examine the parent op of this method */
OwningOp = Node->Op;
ExternalPath = AcpiNsGetNormalizedPathname (Node, TRUE);
if (OwningOp->Asl.CompileFlags & OP_METHOD_NO_RETVAL)
{
/* Method NEVER returns a value */
AslError (ASL_ERROR, ASL_MSG_NO_RETVAL, Op, Op->Asl.ExternalName);
AslError (ASL_ERROR, ASL_MSG_NO_RETVAL, Op, ExternalPath);
}
else if (OwningOp->Asl.CompileFlags & OP_METHOD_SOME_NO_RETVAL)
{
/* Method SOMETIMES returns a value, SOMETIMES not */
AslError (ASL_WARNING, ASL_MSG_SOME_NO_RETVAL,
Op, Op->Asl.ExternalName);
AslError (ASL_WARNING, ASL_MSG_SOME_NO_RETVAL, Op, ExternalPath);
}
else if (!(ThisNodeBtype & RequiredBtypes))
{
@ -470,6 +473,11 @@ AnCheckMethodReturnValue (
AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, AslGbl_MsgBuffer);
}
}
if (ExternalPath)
{
ACPI_FREE (ExternalPath);
}
}

16
source/compiler/aslcompile.c
View File

@ -647,7 +647,7 @@ void
AslCompilerFileHeader (
UINT32 FileId)
{
struct tm *NewTime;
char *NewTime;
time_t Aclock;
char *Prefix = "";
@ -691,13 +691,17 @@ AslCompilerFileHeader (
/* Compilation header with timestamp */
(void) time (&Aclock);
NewTime = localtime (&Aclock);
Aclock = time (NULL);
NewTime = ctime (&Aclock);
FlPrintFile (FileId,
"%sCompilation of \"%s\" - %s%s\n",
Prefix, AslGbl_Files[ASL_FILE_INPUT].Filename, asctime (NewTime),
Prefix);
"%sCompilation of \"%s\" -",
Prefix, AslGbl_Files[ASL_FILE_INPUT].Filename);
if (NewTime)
{
FlPrintFile (FileId, " %s%s\n", NewTime, Prefix);
}
switch (FileId)
{

17
source/compiler/aslcompiler.h
View File

@ -373,6 +373,15 @@ MtMethodAnalysisWalkEnd (
UINT32 Level,
void *Context);
UINT32
MtProcessTypeOp (
ACPI_PARSE_OBJECT *TypeOp);
UINT8
MtProcessParameterTypeList (
ACPI_PARSE_OBJECT *ParamTypeOp,
UINT32 *TypeList);
/*
* aslbtypes - bitfield data types
@ -1233,10 +1242,14 @@ UtDumpBasicOp (
ACPI_PARSE_OBJECT *Op,
UINT32 Level);
void *
UtGetParentMethod (
ACPI_NAMESPACE_NODE *
UtGetParentMethodNode (
ACPI_NAMESPACE_NODE *Node);
ACPI_PARSE_OBJECT *
UtGetParentMethodOp (
ACPI_PARSE_OBJECT *Op);
BOOLEAN
UtNodeIsDescendantOf (
ACPI_NAMESPACE_NODE *Node1,

4921
source/compiler/aslcompiler.y
View File

File diff suppressed because it is too large Load Diff

44
source/compiler/aslexternal.c
View File

@ -192,12 +192,54 @@ ExDoExternal (
ACPI_PARSE_OBJECT *Prev;
ACPI_PARSE_OBJECT *Next;
ACPI_PARSE_OBJECT *ArgCountOp;
ACPI_PARSE_OBJECT *TypeOp;
ACPI_PARSE_OBJECT *ExternTypeOp = Op->Asl.Child->Asl.Next;
UINT32 ExternType;
UINT8 ParamCount = ASL_EXTERNAL_METHOD_UNKNOWN_PARAMS;
UINT32 ParamTypes[ACPI_METHOD_NUM_ARGS];
ExternType = AnMapObjTypeToBtype (ExternTypeOp);
/*
* The parser allows optional parameter return types regardless of the
* type. Check object type keyword emit error if optional parameter/return
* types exist.
*
* Check the parameter return type
*/
TypeOp = ExternTypeOp->Asl.Next;
if (TypeOp->Asl.Child)
{
/* Ignore the return type for now. */
(void) MtProcessTypeOp (TypeOp->Asl.Child);
if (ExternType != ACPI_BTYPE_METHOD)
{
sprintf (AslGbl_MsgBuffer, "Found type [%s]", AcpiUtGetTypeName(ExternType));
AslError (ASL_ERROR, ASL_MSG_EXTERN_INVALID_RET_TYPE, TypeOp,
AslGbl_MsgBuffer);
}
}
/* Check the parameter types */
TypeOp = TypeOp->Asl.Next;
if (TypeOp->Asl.Child)
{
ParamCount = MtProcessParameterTypeList (TypeOp->Asl.Child, ParamTypes);
if (ExternType != ACPI_BTYPE_METHOD)
{
sprintf (AslGbl_MsgBuffer, "Found type [%s]", AcpiUtGetTypeName(ExternType));
AslError (ASL_ERROR, ASL_MSG_EXTERN_INVALID_PARAM_TYPE, TypeOp,
AslGbl_MsgBuffer);
}
}
ArgCountOp = Op->Asl.Child->Asl.Next->Asl.Next;
ArgCountOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
ArgCountOp->Asl.ParseOpcode = PARSEOP_BYTECONST;
ArgCountOp->Asl.Value.Integer = 0;
ArgCountOp->Asl.Value.Integer = ParamCount;
UtSetParseOpName (ArgCountOp);
/* Create new list node of arbitrary type */

228
source/compiler/aslload.c
View File

@ -196,6 +196,15 @@ LdCheckSpecialNames (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op);
static ACPI_STATUS
LdAnalyzeExternals (
ACPI_NAMESPACE_NODE *Node,
ACPI_PARSE_OBJECT *Op,
ACPI_OBJECT_TYPE ExternalOpType,
ACPI_OBJECT_TYPE ObjectType,
ACPI_WALK_STATE *WalkState);
/*******************************************************************************
*
* FUNCTION: LdLoadNamespace
@ -575,7 +584,8 @@ LdNamespace1Begin (
/* Check for a possible illegal forward reference */
if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
(Op->Asl.ParseOpcode == PARSEOP_NAMESTRING))
(Op->Asl.ParseOpcode == PARSEOP_NAMESTRING) ||
(Op->Asl.ParseOpcode == PARSEOP_METHODCALL))
{
/*
* Op->Asl.Namepath will be NULL for these opcodes.
@ -591,7 +601,8 @@ LdNamespace1Begin (
* We only want references to named objects:
* Store (2, WXYZ) -> Attempt to resolve the name
*/
if (OpInfo->Class == AML_CLASS_NAMED_OBJECT)
if ((Op->Asl.ParseOpcode != PARSEOP_METHODCALL) &&
(OpInfo->Class == AML_CLASS_NAMED_OBJECT))
{
return (AE_OK);
}
@ -899,56 +910,24 @@ LdNamespace1Begin (
Node->Type = (UINT8) ObjectType;
Status = AE_OK;
}
else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode != PARSEOP_EXTERNAL))
{
/*
* Allow one create on an object or segment that was
* previously declared External
*/
Node->Flags &= ~ANOBJ_IS_EXTERNAL;
Node->Type = (UINT8) ObjectType;
/* Just retyped a node, probably will need to open a scope */
if (AcpiNsOpensScope (ObjectType))
{
Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
Status = AE_OK;
}
else if (!(Node->Flags & ANOBJ_IS_EXTERNAL) &&
else if ((Node->Flags & ANOBJ_IS_EXTERNAL) ||
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))
{
/*
* Allow externals in same scope as the definition of the
* actual object. Similar to C. Allows multiple definition
* blocks that refer to each other in the same file.
*/
Status = AE_OK;
}
else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) &&
(ObjectType == ACPI_TYPE_ANY))
{
/* Allow update of externals of unknown type. */
if (AcpiNsOpensScope (ActualObjectType))
Status = LdAnalyzeExternals (Node, Op, ActualObjectType,
ObjectType, WalkState);
if (ACPI_FAILURE (Status))
{
Node->Type = (UINT8) ActualObjectType;
Status = AE_OK;
}
else
{
sprintf (AslGbl_MsgBuffer, "%s [%s]", Op->Asl.ExternalName,
AcpiUtGetTypeName (Node->Type));
AslError (ASL_ERROR, ASL_MSG_SCOPE_TYPE, Op, AslGbl_MsgBuffer);
return_ACPI_STATUS (AE_OK);
if (Status == AE_ERROR)
{
/*
* The use of AE_ERROR here indicates that there was a
* compiler error emitted in LdAnalyzeExternals which
* means that the caller should proceed to the next Op
* for analysis of subsequent parse objects.
*/
Status = AE_OK;
}
return_ACPI_STATUS (Status);
}
}
else
@ -1013,15 +992,17 @@ FinishNode:
* 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
* unknown setting Node->Value to ASL_EXTERNAL_METHOD_UNKNOWN_PARAMS
* indicates that the parameter count for this method is unknown.
* This information is used in ASL cross reference to help determine the
* parameter count through method calls.
* 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 = ASL_EXTERNAL_METHOD_UNKNOWN_PARAMS;
Node->Value = (UINT32)
Op->Asl.Child->Asl.Next->Asl.Next->Asl.Value.Integer;
}
if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
@ -1037,6 +1018,145 @@ FinishNode:
}
/*******************************************************************************
*
* FUNCTION: LdAnalyzeExternals
*
* 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
*
* DESCRIPTION: Node and Op represents an identically named object declaration
* that is either declared by the ASL external keyword or declared
* by operators that declare named objects (i.e. Name, Device,
* OperationRegion, and etc.). This function ensures that the
* declarations do not contradict each other.
*
******************************************************************************/
static ACPI_STATUS
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;
ACPI_OBJECT_TYPE ActualExternalOpType;
ACPI_OBJECT_TYPE ActualOpType;
ACPI_PARSE_OBJECT *ExternalOp;
ACPI_PARSE_OBJECT *ActualOp;
/*
* The declaration represented by Node and Op must have the same type.
* The type of the external Op is represented by ExternalOpType. However,
* the type of the pre-existing declaration depends on whether if Op
* is an external declaration or an actual declaration.
*/
if (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL)
{
ActualExternalOpType = ExternalOpType;
ActualOpType = Node->Type;
}
else
{
ActualExternalOpType = Node->Type;
ActualOpType = ObjectType;
}
if ((ActualOpType != ACPI_TYPE_ANY) &&
(ActualExternalOpType != ACPI_TYPE_ANY) &&
(ActualExternalOpType != ActualOpType))
{
if (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL &&
Node->Op->Asl.ParseOpcode == PARSEOP_EXTERNAL)
{
AslDualParseOpError (ASL_ERROR,
ASL_MSG_DUPLICATE_EXTERN_MISMATCH, Op, NULL,
ASL_MSG_DUPLICATE_EXTERN_FOUND_HERE, Node->Op, NULL);
}
else
{
if (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL &&
Node->Op->Asl.ParseOpcode != PARSEOP_EXTERNAL)
{
ExternalOp = Op;
ActualOp = Node->Op;
}
else
{
ExternalOp = Node->Op;
ActualOp = Op;
}
AslDualParseOpError (ASL_ERROR,
ASL_MSG_DECLARATION_TYPE_MISMATCH, ExternalOp, NULL,
ASL_MSG_TYPE_MISMATCH_FOUND_HERE, ActualOp, NULL);
}
}
if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode != PARSEOP_EXTERNAL))
{
/*
* Allow one create on an object or segment that was
* previously declared External
*/
Node->Flags &= ~ANOBJ_IS_EXTERNAL;
Node->Type = (UINT8) ObjectType;
/* Just retyped a node, probably will need to open a scope */
if (AcpiNsOpensScope (ObjectType))
{
Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
if (ACPI_FAILURE (Status))
{
return (Status);
}
}
Status = AE_OK;
}
else if (!(Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))
{
/*
* Allow externals in same scope as the definition of the
* actual object. Similar to C. Allows multiple definition
* blocks that refer to each other in the same file.
*/
Status = AE_OK;
}
else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&
(Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) &&
(ObjectType == ACPI_TYPE_ANY))
{
/* Allow update of externals of unknown type. */
if (AcpiNsOpensScope (ExternalOpType))
{
Node->Type = (UINT8) ExternalOpType;
Status = AE_OK;
}
else
{
sprintf (AslGbl_MsgBuffer, "%s [%s]", Op->Asl.ExternalName,
AcpiUtGetTypeName (Node->Type));
AslError (ASL_ERROR, ASL_MSG_SCOPE_TYPE, Op, AslGbl_MsgBuffer);
Status = AE_ERROR;
}
}
return (Status);
}
/*******************************************************************************
*
* FUNCTION: LdCheckSpecialNames

13
source/compiler/aslmessages.c
View File

@ -320,7 +320,7 @@ const char *AslCompilerMsgs [] =
/* ASL_MSG_SCOPE_TYPE */ "Existing object has invalid type for Scope operator",
/* ASL_MSG_SEEK */ "Could not seek file",
/* ASL_MSG_SERIALIZED */ "Control Method marked Serialized",
/* ASL_MSG_SERIALIZED_REQUIRED */ "Control Method should be made Serialized",
/* ASL_MSG_SERIALIZED_REQUIRED */ "Control Method should be made Serialized due to creation of named objects within",
/* ASL_MSG_SINGLE_NAME_OPTIMIZATION */ "NamePath optimized to NameSeg (uses run-time search path)",
/* ASL_MSG_SOME_NO_RETVAL */ "Called method may not always return a value",
/* ASL_MSG_STRING_LENGTH */ "String literal too long",
@ -370,7 +370,16 @@ const char *AslCompilerMsgs [] =
/* ASL_MSG_INVALID_PROCESSOR_UID */ "_UID inside processor declaration must be an integer",
/* ASL_MSG_LEGACY_PROCESSOR_OP */ "Legacy Processor() keyword detected. Use Device() keyword instead.",
/* ASL_MSG_NAMESTRING_LENGTH */ "NameString contains too many NameSegs (>255)",
/* ASL_MSG_CASE_FOUND_HERE */ "Original Case value below:"
/* ASL_MSG_CASE_FOUND_HERE */ "Original Case value below:",
/* ASL_MSG_EXTERN_INVALID_RET_TYPE */ "Return type is only allowed for Externals declared as MethodObj",
/* ASL_MSG_EXTERN_INVALID_PARAM_TYPE */ "Parameter type is only allowed for Externals declared as MethodObj",
/* ASL_MSG_NAMED_OBJECT_CREATION */ "Creation of named objects within a method is highly inefficient, use globals or method local variables instead",
/* ASL_MSG_ARG_COUNT_MISMATCH */ "Method NumArgs count does not match length of ParameterTypes list",
/* ASL_MSG_STATIC_OPREGION_IN_METHOD */ "Static OperationRegion should be declared outside control method",
/* ASL_MSG_DECLARATION_TYPE_MISMATCH */ "Type mismatch between external declaration and actual object declaration detected",
/* 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:",
};
/* Table compiler */

10
source/compiler/aslmessages.h
View File

@ -373,6 +373,16 @@ typedef enum
ASL_MSG_LEGACY_PROCESSOR_OP,
ASL_MSG_NAMESTRING_LENGTH,
ASL_MSG_CASE_FOUND_HERE,
ASL_MSG_EXTERN_INVALID_RET_TYPE,
ASL_MSG_EXTERN_INVALID_PARAM_TYPE,
ASL_MSG_NAMED_OBJECT_CREATION,
ASL_MSG_ARG_COUNT_MISMATCH,
ASL_MSG_STATIC_OPREGION_IN_METHOD,
ASL_MSG_DECLARATION_TYPE_MISMATCH,
ASL_MSG_TYPE_MISMATCH_FOUND_HERE,
ASL_MSG_DUPLICATE_EXTERN_MISMATCH,
ASL_MSG_DUPLICATE_EXTERN_FOUND_HERE,
/* These messages are used by the Data Table compiler only */

205
source/compiler/aslmethod.c
View File

@ -151,6 +151,7 @@
#include "aslcompiler.h"
#include "aslcompiler.y.h"
#include "acnamesp.h"
#include "acparser.h"
#include "amlcode.h"
@ -166,6 +167,10 @@ MtCheckNamedObjectInMethod (
ACPI_PARSE_OBJECT *Op,
ASL_METHOD_INFO *MethodInfo);
static void
MtCheckStaticOperationRegionInMethod (
ACPI_PARSE_OBJECT *Op);
/*******************************************************************************
*
@ -197,7 +202,6 @@ MtMethodAnalysisWalkBegin (
char ArgName[] = "Arg0";
ACPI_PARSE_OBJECT *ArgNode;
ACPI_PARSE_OBJECT *NextType;
ACPI_PARSE_OBJECT *NextParamType;
UINT8 ActualArgs = 0;
BOOLEAN HidExists;
BOOLEAN AdrExists;
@ -282,50 +286,35 @@ MtMethodAnalysisWalkBegin (
Next = Next->Asl.Next;
NextType = Next->Asl.Child;
while (NextType)
{
/* Get and map each of the ReturnTypes */
MethodInfo->ValidReturnTypes |= AnMapObjTypeToBtype (NextType);
NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
NextType = NextType->Asl.Next;
}
MethodInfo->ValidReturnTypes = MtProcessTypeOp (NextType);
/* Get the ParameterType node */
Next = Next->Asl.Next;
NextType = Next->Asl.Child;
while (NextType)
if (!NextType)
{
if (NextType->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
{
NextParamType = NextType->Asl.Child;
while (NextParamType)
{
MethodInfo->ValidArgTypes[ActualArgs] |=
AnMapObjTypeToBtype (NextParamType);
NextParamType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
NextParamType = NextParamType->Asl.Next;
}
}
else
{
MethodInfo->ValidArgTypes[ActualArgs] =
AnMapObjTypeToBtype (NextType);
NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
ActualArgs++;
}
NextType = NextType->Asl.Next;
/*
* The optional parameter types list was omitted at the source
* level. Use the Argument count parameter instead.
*/
ActualArgs = MethodInfo->NumArguments;
}
else
{
ActualArgs = MtProcessParameterTypeList (NextType,
MethodInfo->ValidArgTypes);
}
if ((MethodInfo->NumArguments) &&
(MethodInfo->NumArguments != ActualArgs))
{
/* error: Param list did not match number of args */
sprintf (AslGbl_MsgBuffer,
"Length = %u", ActualArgs);
AslError (ASL_ERROR, ASL_MSG_ARG_COUNT_MISMATCH,
Op->Asl.Child->Asl.Next, AslGbl_MsgBuffer);
}
/* Allow numarguments == 0 for Function() */
@ -576,6 +565,8 @@ MtMethodAnalysisWalkBegin (
AslError (ASL_ERROR, ASL_MSG_RESERVED_USE,
Op, Op->Asl.ExternalName);
}
MtCheckStaticOperationRegionInMethod (Op);
break;
case PARSEOP_NAME:
@ -628,6 +619,71 @@ MtMethodAnalysisWalkBegin (
}
/*******************************************************************************
*
* FUNCTION: MtProcessTypeOp
*
* PARAMETERS: Op - Op representing a btype
*
* RETURN: Btype represented by Op
*
* DESCRIPTION: Process a parse object that represents single parameter type or
* a return type in method, function, and external declarations.
*
******************************************************************************/
UINT32
MtProcessTypeOp (
ACPI_PARSE_OBJECT *TypeOp)
{
UINT32 Btype = ACPI_BTYPE_ANY;
while (TypeOp)
{
Btype |= AnMapObjTypeToBtype (TypeOp);
TypeOp->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
TypeOp = TypeOp->Asl.Next;
}
return (Btype);
}
/*******************************************************************************
*
* FUNCTION: MtProcessParameterTypeList
*
* PARAMETERS: Op - Op representing a btype
*
* RETURN: Btype represented by Op
*
* DESCRIPTION: Process a parse object that represents a parameter type list in
* method, function, and external declarations.
*
******************************************************************************/
UINT8
MtProcessParameterTypeList (
ACPI_PARSE_OBJECT *ParamTypeOp,
UINT32 *TypeList)
{
UINT8 ParameterCount = 0;
while (ParamTypeOp)
{
TypeList[ParameterCount] =
MtProcessTypeOp (ParamTypeOp->Asl.Child);
ParameterCount++;
ParamTypeOp = ParamTypeOp->Asl.Next;
}
return (ParameterCount);
}
/*******************************************************************************
*
* FUNCTION: MtCheckNamedObjectInMethod
@ -649,6 +705,7 @@ MtCheckNamedObjectInMethod (
ASL_METHOD_INFO *MethodInfo)
{
const ACPI_OPCODE_INFO *OpInfo;
char *ExternalPath;
/* We don't care about actual method declarations or scopes */
@ -672,27 +729,97 @@ MtCheckNamedObjectInMethod (
/*
* 1) Mark the method as a method that creates named objects.
*
* 2) If the method is non-serialized, emit a remark that the method
* 2) Issue a remark indicating the inefficiency of creating named
* objects within a method (Except for compiler-emitted temporary
* variables).
*
* 3) If the method is non-serialized, emit a remark that the method
* should be serialized.
*
* Reason: If a thread blocks within the method for any reason, and
* another thread enters the method, the method will fail because
* an attempt will be made to create the same object twice.
*/
ExternalPath = AcpiNsGetNormalizedPathname (MethodInfo->Op->Asl.Node, TRUE);
/* No error for compiler temp variables (name starts with "_T_") */
if ((Op->Asl.NameSeg[0] != '_') &&
(Op->Asl.NameSeg[1] != 'T') &&
(Op->Asl.NameSeg[2] != '_'))
{
AslError (ASL_REMARK, ASL_MSG_NAMED_OBJECT_CREATION, Op,
ExternalPath);
}
MethodInfo->CreatesNamedObjects = TRUE;
if (!MethodInfo->ShouldBeSerialized)
{
AslError (ASL_REMARK, ASL_MSG_SERIALIZED_REQUIRED, MethodInfo->Op,
"due to creation of named objects within");
ExternalPath);
/* Emit message only ONCE per method */
MethodInfo->ShouldBeSerialized = TRUE;
}
if (ExternalPath)
{
ACPI_FREE (ExternalPath);
}
}
}
/*******************************************************************************
*
* FUNCTION: MtCheckStaticOperationRegionInMethod
*
* PARAMETERS: Op - Current parser op
*
* RETURN: None
*
* DESCRIPTION: Warns if an Operation Region with static address or length
* is declared inside a control method
*
******************************************************************************/
static void
MtCheckStaticOperationRegionInMethod(
ACPI_PARSE_OBJECT* Op)
{
ACPI_PARSE_OBJECT* AddressOp;
ACPI_PARSE_OBJECT* LengthOp;
if (Op->Asl.ParseOpcode != PARSEOP_OPERATIONREGION)
{
return;
}
/*
* OperationRegion should have 4 arguments defined. At this point, we
* assume that the parse tree is well-formed.
*/
AddressOp = Op->Asl.Child->Asl.Next->Asl.Next;
LengthOp = Op->Asl.Child->Asl.Next->Asl.Next->Asl.Next;
if (UtGetParentMethodOp (Op) &&
AddressOp->Asl.ParseOpcode == PARSEOP_INTEGER &&
LengthOp->Asl.ParseOpcode == PARSEOP_INTEGER)
{
/*
* At this point, a static operation region declared inside of a
* control method has been found. Throw a warning because this is
* highly inefficient.
*/
AslError(ASL_WARNING, ASL_MSG_STATIC_OPREGION_IN_METHOD, Op, NULL);
}
return;
}
/*******************************************************************************
*
* FUNCTION: MtMethodAnalysisWalkEnd
@ -714,6 +841,7 @@ MtMethodAnalysisWalkEnd (
{
ASL_ANALYSIS_WALK_INFO *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
ASL_METHOD_INFO *MethodInfo = WalkInfo->MethodStack;
char *ExternalPath;
switch (Op->Asl.ParseOpcode)
@ -766,8 +894,15 @@ MtMethodAnalysisWalkEnd (
if (MethodInfo->NumReturnNoValue &&
MethodInfo->NumReturnWithValue)
{
ExternalPath = AcpiNsGetNormalizedPathname (Op->Asl.Node, TRUE);
AslError (ASL_WARNING, ASL_MSG_RETURN_TYPES, Op,
Op->Asl.ExternalName);
ExternalPath);
if (ExternalPath)
{
ACPI_FREE (ExternalPath);
}
}
/*

15
source/compiler/aslparseop.c
View File

@ -743,13 +743,18 @@ TrCreateConstantLeafOp (
/* Get a copy of the current time */
Op->Asl.Value.String = "";
CurrentTime = time (NULL);
StaticTimeString = ctime (&CurrentTime);
TimeString = UtLocalCalloc (strlen (StaticTimeString) + 1);
strcpy (TimeString, StaticTimeString);
TimeString[strlen(TimeString) -1] = 0; /* Remove trailing newline */
Op->Asl.Value.String = TimeString;
StaticTimeString = ctime (&CurrentTime);
if (StaticTimeString)
{
TimeString = UtLocalCalloc (strlen (StaticTimeString) + 1);
strcpy (TimeString, StaticTimeString);
TimeString[strlen(TimeString) -1] = 0; /* Remove trailing newline */
Op->Asl.Value.String = TimeString;
}
break;
default: /* This would be an internal error */

2
source/compiler/aslprimaries.y
View File

@ -663,7 +663,7 @@ FunctionTerm
PARSEOP_CLOSE_PAREN '{' {COMMENT_CAPTURE_ON; }
TermList '}' {$$ = TrLinkOpChildren ($<n>3,7,
TrSetOpFlags ($4, OP_IS_NAME_DECLARATION),
TrCreateValuedLeafOp (PARSEOP_BYTECONST, 0),
TrCreateLeafOp (PARSEOP_DEFAULT_ARG),
TrCreateLeafOp (PARSEOP_SERIALIZERULE_NOTSERIAL),
TrCreateValuedLeafOp (PARSEOP_BYTECONST, 0),$5,$6,$10);}
| PARSEOP_FUNCTION

23
source/compiler/aslrules.y
View File

@ -421,14 +421,16 @@ ParameterTypePackage
ParameterTypePackageList
: {$$ = NULL;}
| ObjectTypeKeyword {$$ = $1;}
| '{' ParameterTypePackage '}' {$$ = $2;}
| ObjectTypeKeyword {$$ = TrLinkOpChildren (
TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$1);}
| '{' ParameterTypePackage '}' {$$ = TrLinkOpChildren (
TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
;
OptionalParameterTypePackage
: {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);}
| ',' ParameterTypePackageList {$$ = TrLinkOpChildren (
TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
: {$$ = NULL;}
| ',' ParameterTypePackageList {$$ = $2;}
;
/* Rules for specifying the types for method arguments */
@ -441,14 +443,15 @@ ParameterTypesPackage
ParameterTypesPackageList
: {$$ = NULL;}
| ObjectTypeKeyword {$$ = $1;}
| '{' ParameterTypesPackage '}' {$$ = $2;}
| ObjectTypeKeyword {$$ = TrLinkOpChildren (
TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$1);}
| '{' ParameterTypesPackage '}' {$$ = TrLinkOpChildren (
TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
;
OptionalParameterTypesPackage
: {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);}
| ',' ParameterTypesPackageList {$$ = TrLinkOpChildren (
TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
: {$$ = NULL;}
| ',' ParameterTypesPackageList {$$ = $2;}
;
/*

84
source/compiler/asltransform.c
View File

@ -205,6 +205,10 @@ TrCheckForBufferMatch (
ACPI_PARSE_OBJECT *Next1,
ACPI_PARSE_OBJECT *Next2);
static void
TrDoMethod (
ACPI_PARSE_OBJECT *Op);
/*******************************************************************************
*
@ -463,11 +467,8 @@ TrTransformSubtree (
break;
case PARSEOP_METHOD:
/*
* TBD: Zero the tempname (_T_x) count. Probably shouldn't be a global,
* however
*/
AslGbl_TempCount = 0;
TrDoMethod (Op);
break;
case PARSEOP_EXTERNAL:
@ -1240,3 +1241,76 @@ TrCheckForBufferMatch (
return (TRUE);
}
/*******************************************************************************
*
* FUNCTION: TrDoMethod
*
* PARAMETERS: Op - Parse node for SWITCH
*
* RETURN: None
*
* DESCRIPTION: Determine that parameter count of an ASL method node by
* translating the parameter count parse node from
* PARSEOP_DEFAULT_ARG to PARSEOP_BYTECONST.
*
******************************************************************************/
static void
TrDoMethod (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *ArgCountOp;
UINT8 ArgCount;
ACPI_PARSE_OBJECT *ParameterOp;
/*
* TBD: Zero the tempname (_T_x) count. Probably shouldn't be a global,
* however
*/
AslGbl_TempCount = 0;
ArgCountOp = Op->Asl.Child->Asl.Next;
if (ArgCountOp->Asl.ParseOpcode == PARSEOP_BYTECONST)
{
/*
* Parameter count for this method has already been recorded in the
* method declaration.
*/
return;
}
/*
* Parameter count has been omitted in the method declaration.
* Count the amount of arguments here.
*/
ParameterOp = ArgCountOp->Asl.Next->Asl.Next->Asl.Next->Asl.Next;
if (ParameterOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
{
ArgCount = 0;
ParameterOp = ParameterOp->Asl.Child;
while (ParameterOp)
{
ParameterOp = ParameterOp->Asl.Next;
ArgCount++;
}
ArgCountOp->Asl.Value.Integer = ArgCount;
ArgCountOp->Asl.ParseOpcode = PARSEOP_BYTECONST;
}
else
{
/*
* Method parameters can be counted by analyzing the Parameter type
* list. If the Parameter list contains more than 1 parameter, it
* is nested under PARSEOP_DEFAULT_ARG. When there is only 1
* parameter, the parse tree contains a single node representing
* that type.
*/
ArgCountOp->Asl.Value.Integer = 1;
ArgCountOp->Asl.ParseOpcode = PARSEOP_BYTECONST;
}
}

41
source/compiler/aslutils.c
View File

@ -298,7 +298,7 @@ UtNodeIsDescendantOf (
/*******************************************************************************
*
* FUNCTION: UtGetParentMethod
* FUNCTION: UtGetParentMethodNode
*
* PARAMETERS: Node - Namespace node for any object
*
@ -309,8 +309,8 @@ UtNodeIsDescendantOf (
*
******************************************************************************/
void *
UtGetParentMethod (
ACPI_NAMESPACE_NODE *
UtGetParentMethodNode (
ACPI_NAMESPACE_NODE *Node)
{
ACPI_NAMESPACE_NODE *ParentNode;
@ -338,6 +338,41 @@ UtGetParentMethod (
}
/*******************************************************************************
*
* FUNCTION: UtGetParentMethodOp
*
* PARAMETERS: Op - Parse Op to be checked
*
* RETURN: Control method Op if found. NULL otherwise
*
* DESCRIPTION: Find the control method parent of a parse op. Returns NULL if
* the input Op is not within a control method.
*
******************************************************************************/
ACPI_PARSE_OBJECT *
UtGetParentMethodOp (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *NextOp;
NextOp = Op->Asl.Parent;
while (NextOp)
{
if (NextOp->Asl.AmlOpcode == AML_METHOD_OP)
{
return (NextOp);
}
NextOp = NextOp->Asl.Parent;
}
return (NULL); /* No parent method found */
}
/*******************************************************************************
*
* FUNCTION: UtDisplaySupportedTables

57
source/compiler/aslxref.c
View File

@ -180,10 +180,6 @@ XfValidateCrossReference (
const ACPI_OPCODE_INFO *OpInfo,
ACPI_NAMESPACE_NODE *Node);
static ACPI_PARSE_OBJECT *
XfGetParentMethod (
ACPI_PARSE_OBJECT *Op);
static BOOLEAN
XfObjectExists (
char *Name);
@ -380,41 +376,6 @@ XfCheckFieldRange (
}
/*******************************************************************************
*
* FUNCTION: XfGetParentMethod
*
* PARAMETERS: Op - Parse Op to be checked
*
* RETURN: Control method Op if found. NULL otherwise
*
* DESCRIPTION: Find the control method parent of a parse op. Returns NULL if
* the input Op is not within a control method.
*
******************************************************************************/
static ACPI_PARSE_OBJECT *
XfGetParentMethod (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *NextOp;
NextOp = Op->Asl.Parent;
while (NextOp)
{
if (NextOp->Asl.AmlOpcode == AML_METHOD_OP)
{
return (NextOp);
}
NextOp = NextOp->Asl.Parent;
}
return (NULL); /* No parent method found */
}
/*******************************************************************************
*
* FUNCTION: XfNamespaceLocateBegin
@ -539,7 +500,7 @@ XfNamespaceLocateBegin (
{
/* Find parent method Op */
NextOp = XfGetParentMethod (Op);
NextOp = UtGetParentMethodOp (Op);
if (!NextOp)
{
return_ACPI_STATUS (AE_OK);
@ -576,7 +537,7 @@ XfNamespaceLocateBegin (
{
/* Find parent method Op */
NextOp = XfGetParentMethod (Op);
NextOp = UtGetParentMethodOp (Op);
if (!NextOp)
{
return_ACPI_STATUS (AE_OK);
@ -814,10 +775,10 @@ XfNamespaceLocateBegin (
* same method or outside of any method, this is a forward reference
* and should be reported as a compiler error.
*/
DeclarationParentMethod = UtGetParentMethod (Node);
ReferenceParentMethod = XfGetParentMethod (Op);
DeclarationParentMethod = UtGetParentMethodNode (Node);
ReferenceParentMethod = UtGetParentMethodOp (Op);
/* case 1: declaration and refrence are both outside of method */
/* case 1: declaration and reference are both outside of method */
if (!ReferenceParentMethod && !DeclarationParentMethod)
{
@ -1337,8 +1298,8 @@ XfNamespaceLocateEnd (
* execution of A)
*
* NOTES:
* A null pointer returned by either XfGetParentMethod or
* UtGetParentMethod indicates that the parameter object is not
* A null pointer returned by either UtGetParentMethodOp or
* UtGetParentMethodNode indicates that the parameter object is not
* within a control method.
*
* Five cases are handled: Case(Op, Node)
@ -1371,8 +1332,8 @@ XfValidateCrossReference (
* 1) Search upwards in parse tree for owner of the referencing object
* 2) Search upwards in namespace to find the owner of the referenced object
*/
ReferencingMethodOp = XfGetParentMethod (Op);
ReferencedMethodNode = UtGetParentMethod (Node);
ReferencingMethodOp = UtGetParentMethodOp (Op);
ReferencedMethodNode = UtGetParentMethodNode (Node);
if (!ReferencingMethodOp && !ReferencedMethodNode)
{

16
source/compiler/cvparser.c
View File

@ -230,8 +230,7 @@ CvIsFilename (
* FUNCTION: CvInitFileTree
*
* PARAMETERS: Table - input table
* AmlStart - Address of the starting point of the AML.
* AmlLength - Length of the AML file.
* RootFile - Output file that defines the DefinitionBlock
*
* RETURN: None
*
@ -243,8 +242,7 @@ CvIsFilename (
void
CvInitFileTree (
ACPI_TABLE_HEADER *Table,
UINT8 *AmlStart,
UINT32 AmlLength)
FILE *RootFile)
{
UINT8 *TreeAml;
UINT8 *FileEnd;
@ -252,6 +250,8 @@ CvInitFileTree (
char *PreviousFilename = NULL;
char *ParentFilename = NULL;
char *ChildFilename = NULL;
UINT8 *AmlStart;
UINT32 AmlLength;
if (!AcpiGbl_CaptureComments)
@ -259,9 +259,13 @@ CvInitFileTree (
return;
}
AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER));
CvDbgPrint ("AmlLength: %x\n", AmlLength);
CvDbgPrint ("AmlStart: %p\n", AmlStart);
CvDbgPrint ("AmlEnd?: %p\n", AmlStart+AmlLength);
CvDbgPrint ("AmlEnd: %p\n", AmlStart+AmlLength);
AcpiGbl_FileTreeRoot = AcpiOsAcquireObject (AcpiGbl_FileCache);
@ -273,7 +277,7 @@ CvInitFileTree (
/* Set the root file to the current open file */
AcpiGbl_FileTreeRoot->File = AcpiGbl_OutputFile;
AcpiGbl_FileTreeRoot->File = RootFile;
/*
* Set this to true because we don't need to output

2
source/components/events/evevent.c
View File

@ -299,7 +299,7 @@ AcpiEvFixedEventInitialize (
/*
* Initialize the structure that keeps track of fixed event handlers and
* enable the fixed events.
* disable all of the fixed events.
*/
for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
{

38
source/components/events/evxfgpe.c
View File

@ -1065,6 +1065,44 @@ AcpiEnableAllWakeupGpes (
ACPI_EXPORT_SYMBOL (AcpiEnableAllWakeupGpes)
/******************************************************************************
*
* FUNCTION: AcpiAnyGpeStatusSet
*
* PARAMETERS: None
*
* RETURN: Whether or not the status bit is set for any GPE
*
* DESCRIPTION: Check the status bits of all enabled GPEs and return TRUE if any
* of them is set or FALSE otherwise.
*
******************************************************************************/
UINT32
AcpiAnyGpeStatusSet (
void)
{
ACPI_STATUS Status;
UINT8 Ret;
ACPI_FUNCTION_TRACE (AcpiAnyGpeStatusSet);
Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
if (ACPI_FAILURE (Status))
{
return (FALSE);
}
Ret = AcpiHwCheckAllGpes ();
(void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
return (Ret);
}
ACPI_EXPORT_SYMBOL(AcpiAnyGpeStatusSet)
/*******************************************************************************
*
* FUNCTION: AcpiInstallGpeBlock

79
source/components/hardware/hwgpe.c
View File

@ -635,6 +635,58 @@ AcpiHwEnableWakeupGpeBlock (
}
/******************************************************************************
*
* FUNCTION: AcpiHwGetGpeBlockStatus
*
* PARAMETERS: GpeXruptInfo - GPE Interrupt info
* GpeBlock - Gpe Block info
*
* RETURN: Success
*
* DESCRIPTION: Produce a combined GPE status bits mask for the given block.
*
******************************************************************************/
static ACPI_STATUS
AcpiHwGetGpeBlockStatus(
ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
ACPI_GPE_BLOCK_INFO *GpeBlock,
void *RetPtr)
{
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
UINT64 InEnable;
UINT64 InStatus;
ACPI_STATUS Status;
UINT8 *Ret = RetPtr;
UINT32 i;
/* Examine each GPE Register within the block */
for (i = 0; i < GpeBlock->RegisterCount; i++)
{
GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
Status = AcpiHwRead (&InEnable, &GpeRegisterInfo->EnableAddress);
if (ACPI_FAILURE (Status))
{
continue;
}
Status = AcpiHwRead (&InStatus, &GpeRegisterInfo->StatusAddress);
if (ACPI_FAILURE (Status))
{
continue;
}
*Ret |= InEnable & InStatus;
}
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: AcpiHwDisableAllGpes
@ -715,4 +767,31 @@ AcpiHwEnableAllWakeupGpes (
return_ACPI_STATUS (Status);
}
/******************************************************************************
*
* FUNCTION: AcpiHwCheckAllGpes
*
* PARAMETERS: None
*
* RETURN: Combined status of all GPEs
*
* DESCRIPTION: Check all enabled GPEs in all GPE blocks and return TRUE if the
* status bit is set for at least one of them of FALSE otherwise.
*
******************************************************************************/
UINT8
AcpiHwCheckAllGpes (
void)
{
UINT8 Ret = 0;
ACPI_FUNCTION_TRACE (AcpiHwCheckAllGpes);
(void) AcpiEvWalkGpeList (AcpiHwGetGpeBlockStatus, &Ret);
return (Ret != 0);
}
#endif /* !ACPI_REDUCED_HARDWARE */

10
source/components/hardware/hwsleep.c
View File

@ -464,6 +464,16 @@ AcpiHwLegacyWake (
AcpiGbl_FixedEventInfo[ACPI_EVENT_POWER_BUTTON].StatusRegisterId,
ACPI_CLEAR_STATUS);
/* Enable sleep button */
(void) AcpiWriteBitRegister (
AcpiGbl_FixedEventInfo[ACPI_EVENT_SLEEP_BUTTON].EnableRegisterId,
ACPI_ENABLE_EVENT);
(void) AcpiWriteBitRegister (
AcpiGbl_FixedEventInfo[ACPI_EVENT_SLEEP_BUTTON].StatusRegisterId,
ACPI_CLEAR_STATUS);
AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WORKING);
return_ACPI_STATUS (Status);
}

6
source/components/namespace/nsnames.c
View File

@ -336,7 +336,7 @@ AcpiNsHandleToPathname (
/* Build the path in the caller buffer */
(void) AcpiNsBuildNormalizedPath (Node, Buffer->Pointer,
RequiredSize, NoTrailing);
(UINT32) RequiredSize, NoTrailing);
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s [%X]\n",
(char *) Buffer->Pointer, (UINT32) RequiredSize));
@ -509,7 +509,7 @@ AcpiNsGetNormalizedPathname (
/* Build the path in the allocated buffer */
(void) AcpiNsBuildNormalizedPath (Node, NameBuffer, Size, NoTrailing);
(void) AcpiNsBuildNormalizedPath (Node, NameBuffer, (UINT32) Size, NoTrailing);
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES, "%s: Path \"%s\"\n",
ACPI_GET_FUNCTION_NAME, NameBuffer));
@ -542,7 +542,7 @@ AcpiNsBuildPrefixedPathname (
char *FullPath = NULL;
char *ExternalPath = NULL;
char *PrefixPath = NULL;
UINT32 PrefixPathLength = 0;
ACPI_SIZE PrefixPathLength = 0;
/* If there is a prefix, get the pathname to it */

2
source/components/namespace/nsxfname.c
View File

@ -714,7 +714,7 @@ AcpiInstallMethod (
MethodFlags = *ParserState.Aml++;
AmlStart = ParserState.Aml;
AmlLength = ACPI_PTR_DIFF (ParserState.PkgEnd, AmlStart);
AmlLength = (UINT32) ACPI_PTR_DIFF (ParserState.PkgEnd, AmlStart);
/*
* Allocate resources up-front. We don't want to have to delete a new

12
source/components/tables/tbxface.c
View File

@ -368,14 +368,14 @@ ACPI_EXPORT_SYMBOL_INIT (AcpiReallocateRootTable)
*
* PARAMETERS: Signature - ACPI signature of needed table
* Instance - Which instance (for SSDTs)
* OutTableHeader - The pointer to the table header to fill
* OutTableHeader - The pointer to the where the table header
* is returned
*
* RETURN: Status and pointer to mapped table header
* RETURN: Status and a copy of the table header
*
* DESCRIPTION: Finds an ACPI table header.
*
* NOTE: Caller is responsible in unmapping the header with
* AcpiOsUnmapMemory
* DESCRIPTION: Finds and returns an ACPI table header. Caller provides the
* memory where a copy of the header is to be returned
* (fixed length).
*
******************************************************************************/

2
source/components/utilities/utobject.c
View File

@ -192,7 +192,7 @@ AcpiUtGetElementLength (
*
* NOTE: We always allocate the worst-case object descriptor because
* these objects are cached, and we want them to be
* one-size-satisifies-any-request. This in itself may not be
* one-size-satisfies-any-request. This in itself may not be
* the most memory efficient, but the efficiency of the object
* cache should more than make up for this!
*

3
source/include/acconvert.h
View File

@ -237,8 +237,7 @@ CgWriteAmlComment (
void
CvInitFileTree (
ACPI_TABLE_HEADER *Table,
UINT8 *AmlStart,
UINT32 AmlLength);
FILE *RootFile);
void
CvClearOpComments (

4
source/include/achware.h
View File

@ -315,6 +315,10 @@ ACPI_STATUS
AcpiHwEnableAllWakeupGpes (
void);
UINT8
AcpiHwCheckAllGpes (
void);
ACPI_STATUS
AcpiHwEnableRuntimeGpeBlock (
ACPI_GPE_XRUPT_INFO *GpeXruptInfo,

4
source/include/acmacros.h
View File

@ -625,7 +625,7 @@
#define ASL_CV_PRINT_ONE_COMMENT(a,b,c,d) CvPrintOneCommentType (a,b,c,d);
#define ASL_CV_PRINT_ONE_COMMENT_LIST(a,b) CvPrintOneCommentList (a,b);
#define ASL_CV_FILE_HAS_SWITCHED(a) CvFileHasSwitched(a)
#define ASL_CV_INIT_FILETREE(a,b,c) CvInitFileTree(a,b,c);
#define ASL_CV_INIT_FILETREE(a,b) CvInitFileTree(a,b);
#else
@ -640,7 +640,7 @@
#define ASL_CV_PRINT_ONE_COMMENT(a,b,c,d)
#define ASL_CV_PRINT_ONE_COMMENT_LIST(a,b)
#define ASL_CV_FILE_HAS_SWITCHED(a) 0
#define ASL_CV_INIT_FILETREE(a,b,c)
#define ASL_CV_INIT_FILETREE(a,b)
#endif

6
source/include/acpixf.h
View File

@ -154,7 +154,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20200110
#define ACPI_CA_VERSION 0x20200214
#include "acconfig.h"
#include "actypes.h"
@ -1109,6 +1109,10 @@ ACPI_STATUS
AcpiEnableAllWakeupGpes (
void))
ACPI_HW_DEPENDENT_RETURN_UINT32 (
UINT32 AcpiAnyGpeStatusSet (
void))
ACPI_HW_DEPENDENT_RETURN_STATUS (
ACPI_STATUS
AcpiGetGpeDevice (

2
source/include/actbl1.h
View File

@ -1149,7 +1149,7 @@ enum AcpiErstInstructions
enum AcpiErstCommandStatus
{
ACPI_ERST_SUCESS = 0,
ACPI_ERST_SUCCESS = 0,
ACPI_ERST_NO_SPACE = 1,
ACPI_ERST_NOT_AVAILABLE = 2,
ACPI_ERST_FAILURE = 3,

7
source/include/actypes.h
View File

@ -683,11 +683,12 @@ typedef UINT64 ACPI_INTEGER;
strnlen (a, ACPI_NAMESEG_SIZE) == ACPI_NAMESEG_SIZE)
/*
* Algorithm to obtain access bit width.
* Can be used with AccessWidth of ACPI_GENERIC_ADDRESS and AccessSize of
* Algorithm to obtain access bit or byte width.
* Can be used with AccessSize field of ACPI_GENERIC_ADDRESS and
* ACPI_RESOURCE_GENERIC_REGISTER.
*/
#define ACPI_ACCESS_BIT_WIDTH(size) (1 << ((size) + 2))
#define ACPI_ACCESS_BIT_WIDTH(AccessSize) (1 << ((AccessSize) + 2))
#define ACPI_ACCESS_BYTE_WIDTH(AccessSize) (1 << ((AccessSize) - 1))
/*******************************************************************************

541
source/os_specific/service_layers/oswintbl.c
View File

@ -179,20 +179,17 @@ static char KeyBuffer[LOCAL_BUFFER_SIZE];
static char ErrorBuffer[LOCAL_BUFFER_SIZE];
/*
* Tables supported in the Windows registry. Zero or more SSDTs are assumed to
* follow these tables.
* List of table signatures reported by EnumSystemFirmwareTables ()
*/
static char *SupportedTables[] =
{
"DSDT",
"RSDT",
"FACS",
"FACP"
};
UINT32 *Gbl_AvailableTableSignatures;
UINT32 Gbl_TableCount = 0;
UINT32 Gbl_SsdtInstance = 0;
/* Number of table names for the table above. */
BOOLEAN Gbl_TableListInitialized = FALSE;
#define ACPI_OS_NUM_TABLE_ENTRIES 4
static ACPI_STATUS
OslTableInitialize (
void);
/******************************************************************************
@ -264,7 +261,8 @@ AcpiOsGetTableByAddress (
* DESCRIPTION: Get an ACPI table via an index value (0 through n). Returns
* AE_LIMIT when an invalid index is reached. Index is not
* necessarily an index into the RSDT/XSDT.
* Table is obtained from the Windows registry.
* SSDT tables are obtained from the Windows registry. All other
* tables are obtained through GetSystemFirmwareTable ().
*
* NOTE: Cannot get the physical address from the windows registry;
* zero is returned instead.
@ -280,35 +278,327 @@ AcpiOsGetTableByIndex (
{
ACPI_STATUS Status;
char *Signature;
UINT32 CurrentInstance;
if (Index < ACPI_OS_NUM_TABLE_ENTRIES)
/* Enumerate all ACPI table signatures on first invocation of this function */
Status = OslTableInitialize ();
if (ACPI_FAILURE (Status))
{
Signature = SupportedTables[Index];
Index = 0;
return (Status);
}
/* Validate Index */
if (Index < Gbl_TableCount)
{
Signature = malloc (ACPI_NAMESEG_SIZE + 1);
if (!Signature)
{
return (AE_NO_MEMORY);
}
Signature = memmove (Signature, &Gbl_AvailableTableSignatures[Index], ACPI_NAMESEG_SIZE);
}
else
{
Signature = ACPI_SIG_SSDT;
Index -= ACPI_OS_NUM_TABLE_ENTRIES;
return (AE_LIMIT);
}
Status = AcpiOsGetTableByName (Signature, Index, Table, Address);
if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
{
CurrentInstance = Gbl_SsdtInstance;
Gbl_SsdtInstance++;
}
else
{
CurrentInstance = 0;
}
Status = AcpiOsGetTableByName (Signature, CurrentInstance, Table, Address);
if (ACPI_SUCCESS (Status))
{
*Instance = Index;
*Instance = CurrentInstance;
}
else if (Status == AE_NOT_FOUND &&
ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
{
/* Treat SSDTs that are not found as invalid index. */
Status = (AE_LIMIT);
Status = AE_LIMIT;
}
free (Signature);
return (Status);
}
/******************************************************************************
*
* FUNCTION: OslTableInitialize
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Initialize ACPI table data. Enumerate all ACPI table signatures
* and save them to a global list.
*
*****************************************************************************/
static ACPI_STATUS
OslTableInitialize (
void)
{
UINT32 ResultSize;
UINT32 DataSize;
if (Gbl_TableListInitialized)
{
return (AE_OK);
}
/*
* ACPI table signatures are always 4 characters. Therefore, the data size
* buffer should be a multiple of 4
*/
DataSize = EnumSystemFirmwareTables ('ACPI', NULL, 0);
if (DataSize % ACPI_NAMESEG_SIZE)
{
return (AE_ERROR);
}
/*
* EnumSystemFirmwareTables () does not report the DSDT or XSDT. Work around this
* by adding these entries manually.
*/
Gbl_TableCount = 2 + DataSize / ACPI_NAMESEG_SIZE;
Gbl_AvailableTableSignatures = malloc (Gbl_TableCount * ACPI_NAMESEG_SIZE);
if (!Gbl_AvailableTableSignatures)
{
return (AE_NO_MEMORY);
}
ResultSize = EnumSystemFirmwareTables ('ACPI', Gbl_AvailableTableSignatures, DataSize);
if (ResultSize > DataSize)
{
return (AE_ERROR);
}
/* Insert the DSDT and XSDT tables signatures */
Gbl_AvailableTableSignatures [Gbl_TableCount - 1] = 'TDSD';
Gbl_AvailableTableSignatures [Gbl_TableCount - 2] = 'TDSX';
Gbl_TableListInitialized = TRUE;
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: WindowsGetTableFromRegistry
*
* PARAMETERS: Signature - ACPI Signature for desired table. Must be
* a null terminated 4-character string.
* Instance - For SSDTs (0...n). Use 0 otherwise.
* Table - Where a pointer to the table is returned
* Address - Where the table physical address is returned
*
* RETURN: Status; Table buffer and physical address returned if AE_OK.
* AE_LIMIT: Instance is beyond valid limit
* AE_NOT_FOUND: A table with the signature was not found
*
* DESCRIPTION: Get an ACPI table via a table signature (4 ASCII characters).
* Returns AE_LIMIT when an invalid instance is reached.
* Table is obtained from the Windows registry.
*
* NOTE: Assumes the input signature is uppercase.
* Cannot get the physical address from the windows registry;
* zero is returned instead.
*
*****************************************************************************/
static ACPI_STATUS
WindowsGetTableFromRegistry (
char *Signature,
UINT32 Instance,
ACPI_TABLE_HEADER **Table,
ACPI_PHYSICAL_ADDRESS *Address)
{
HKEY Handle = NULL;
LONG WinStatus;
ULONG Type;
ULONG NameSize;
ULONG DataSize;
HKEY SubKey;
ULONG i;
ACPI_TABLE_HEADER *ReturnTable;
ACPI_STATUS Status = AE_OK;
/* Get a handle to the table key */
while (1)
{
strcpy(KeyBuffer, "HARDWARE\\ACPI\\");
if (AcpiUtSafeStrcat(KeyBuffer, sizeof(KeyBuffer), Signature))
{
return (AE_BUFFER_OVERFLOW);
}
/*
* Windows stores SSDT at SSDT, SSD1, ..., SSD9, SSDA, ..., SSDS, SSDT,
* SSDU, ..., SSDY. If the first (0th) and the 29th tables have the same
* OEM ID, Table ID and Revision, then the 29th entry will overwrite the
* first entry... Let's hope that we do not have that many entries.
*/
if (Instance > 0 && ACPI_COMPARE_NAMESEG(Signature, ACPI_SIG_SSDT))
{
if (Instance < 10)
{
KeyBuffer[strlen(KeyBuffer) - 1] = '0' + (char)Instance;
}
else if (Instance < 29)
{
KeyBuffer[strlen(KeyBuffer) - 1] = 'A' + (char)(Instance - 10);
}
else
{
return (AE_LIMIT);
}
}
WinStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, KeyBuffer,
0L, KEY_READ, &Handle);
if (WinStatus != ERROR_SUCCESS)
{
/*
* Somewhere along the way, MS changed the registry entry for
* the FADT from
* HARDWARE/ACPI/FACP to
* HARDWARE/ACPI/FADT.
*
* This code allows for both.
*/
if (ACPI_COMPARE_NAMESEG(Signature, "FACP"))
{
Signature = "FADT";
}
else if (ACPI_COMPARE_NAMESEG(Signature, "XSDT"))
{
Signature = "RSDT";
}
else if (ACPI_COMPARE_NAMESEG(Signature, ACPI_SIG_SSDT))
{
/*
* SSDT may not be present on older Windows versions, but it is
* also possible that the index is not found.
*/
return (AE_NOT_FOUND);
}
else
{
fprintf(stderr,
"Could not find %s in registry at %s: %s (WinStatus=0x%X)\n",
Signature, KeyBuffer, WindowsFormatException(WinStatus), WinStatus);
return (AE_NOT_FOUND);
}
}
else
{
break;
}
}
/* Actual data for the table is down a couple levels */
for (i = 0; ;)
{
WinStatus = RegEnumKey(Handle, i, KeyBuffer, sizeof(KeyBuffer));
i++;
if (WinStatus == ERROR_NO_MORE_ITEMS)
{
break;
}
WinStatus = RegOpenKey(Handle, KeyBuffer, &SubKey);
if (WinStatus != ERROR_SUCCESS)
{
fprintf(stderr, "Could not open %s entry: %s\n",
Signature, WindowsFormatException(WinStatus));
Status = AE_ERROR;
goto Cleanup;
}
RegCloseKey(Handle);
Handle = SubKey;
i = 0;
}
/* Find the (binary) table entry */
for (i = 0; ; i++)
{
NameSize = sizeof(KeyBuffer);
WinStatus = RegEnumValue(Handle, i, KeyBuffer, &NameSize, NULL,
&Type, NULL, 0);
if (WinStatus != ERROR_SUCCESS)
{
fprintf(stderr, "Could not get %s registry entry: %s\n",
Signature, WindowsFormatException(WinStatus));
Status = AE_ERROR;
goto Cleanup;
}
if (Type == REG_BINARY)
{
break;
}
}
/* Get the size of the table */
WinStatus = RegQueryValueEx(Handle, KeyBuffer, NULL, NULL,
NULL, &DataSize);
if (WinStatus != ERROR_SUCCESS)
{
fprintf(stderr, "Could not read the %s table size: %s\n",
Signature, WindowsFormatException(WinStatus));
Status = AE_ERROR;
goto Cleanup;
}
/* Allocate a new buffer for the table */
ReturnTable = malloc(DataSize);
if (!ReturnTable)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
/* Get the actual table from the registry */
WinStatus = RegQueryValueEx(Handle, KeyBuffer, NULL, NULL,
(UCHAR *)ReturnTable, &DataSize);
if (WinStatus != ERROR_SUCCESS)
{
fprintf(stderr, "Could not read %s data: %s\n",
Signature, WindowsFormatException(WinStatus));
free(ReturnTable);
Status = AE_ERROR;
goto Cleanup;
}
*Table = ReturnTable;
*Address = 0;
Cleanup:
RegCloseKey(Handle);
return (Status);
}
/******************************************************************************
*
@ -335,189 +625,60 @@ AcpiOsGetTableByIndex (
*****************************************************************************/
ACPI_STATUS
AcpiOsGetTableByName (
char *Signature,
UINT32 Instance,
ACPI_TABLE_HEADER **Table,
ACPI_PHYSICAL_ADDRESS *Address)
AcpiOsGetTableByName(
char *Signature,
UINT32 Instance,
ACPI_TABLE_HEADER **Table,
ACPI_PHYSICAL_ADDRESS *Address)
{
HKEY Handle = NULL;
LONG WinStatus;
ULONG Type;
ULONG NameSize;
ULONG DataSize;
HKEY SubKey;
ULONG i;
ACPI_TABLE_HEADER *ReturnTable;
ACPI_STATUS Status = AE_OK;
LONG Result;
ACPI_STATUS Status = AE_OK;
UINT32 DataSize;
ACPI_TABLE_HEADER *ReturnTable;
UINT32 UIntSignature = 0;
/* Multiple instances are only supported for SSDT tables. */
if (Instance > 0 && !ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
{
return (AE_LIMIT);
}
if (Instance > 0 && !ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
{
return (AE_LIMIT);
}
/* Get a handle to the table key */
if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
{
Status = WindowsGetTableFromRegistry ("SSDT", Instance, Table, Address);
return (Status);
}
while (1)
{
strcpy (KeyBuffer, "HARDWARE\\ACPI\\");
if (AcpiUtSafeStrcat (KeyBuffer, sizeof (KeyBuffer), Signature))
{
return (AE_BUFFER_OVERFLOW);
}
/* GetSystemFirmwareTable requires the table signature to be UINT32 */
/*
* Windows stores SSDT at SSDT, SSD1, ..., SSD9, SSDA, ..., SSDS, SSDT,
* SSDU, ..., SSDY. If the first (0th) and the 29th tables have the same
* OEM ID, Table ID and Revision, then the 29th entry will overwrite the
* first entry... Let's hope that we do not have that many entries.
*/
if (Instance > 0 && ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
{
if (Instance < 10)
{
KeyBuffer[strlen (KeyBuffer) - 1] = '0' + (char) Instance;
}
else if (Instance < 29)
{
KeyBuffer[strlen (KeyBuffer) - 1] = 'A' + (char) (Instance - 10);
}
else
{
return (AE_LIMIT);
}
}
UIntSignature = *ACPI_CAST_PTR (UINT32, Signature);
DataSize = GetSystemFirmwareTable('ACPI', UIntSignature, NULL, 0);
if (!DataSize)
{
fprintf(stderr, "The table signature %s does not exist.", Signature);
return (AE_ERROR);
}
WinStatus = RegOpenKeyEx (HKEY_LOCAL_MACHINE, KeyBuffer,
0L, KEY_READ, &Handle);
ReturnTable = malloc(DataSize);
if (!ReturnTable)
{
return (AE_NO_MEMORY);
}
if (WinStatus != ERROR_SUCCESS)
{
/*
* Somewhere along the way, MS changed the registry entry for
* the FADT from
* HARDWARE/ACPI/FACP to
* HARDWARE/ACPI/FADT.
*
* This code allows for both.
*/
if (ACPI_COMPARE_NAMESEG (Signature, "FACP"))
{
Signature = "FADT";
}
else if (ACPI_COMPARE_NAMESEG (Signature, "XSDT"))
{
Signature = "RSDT";
}
else if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
{
/* SSDT may not be present on older Windows versions, but it is
* also possible that the index is not found. */
return (AE_NOT_FOUND);
}
else
{
fprintf (stderr,
"Could not find %s in registry at %s: %s (WinStatus=0x%X)\n",
Signature, KeyBuffer, WindowsFormatException (WinStatus), WinStatus);
return (AE_NOT_FOUND);
}
}
else
{
break;
}
}
Result = GetSystemFirmwareTable('ACPI', UIntSignature, ReturnTable, DataSize);
if (Result > (LONG) DataSize)
{
/* Clean up */
/* Actual data for the table is down a couple levels */
for (i = 0; ;)
{
WinStatus = RegEnumKey (Handle, i, KeyBuffer, sizeof (KeyBuffer));
i++;
if (WinStatus == ERROR_NO_MORE_ITEMS)
{
break;
}
WinStatus = RegOpenKey (Handle, KeyBuffer, &SubKey);
if (WinStatus != ERROR_SUCCESS)
{
fprintf (stderr, "Could not open %s entry: %s\n",
Signature, WindowsFormatException (WinStatus));
Status = AE_ERROR;
goto Cleanup;
}
RegCloseKey (Handle);
Handle = SubKey;
i = 0;
}
/* Find the (binary) table entry */
for (i = 0; ; i++)
{
NameSize = sizeof (KeyBuffer);
WinStatus = RegEnumValue (Handle, i, KeyBuffer, &NameSize, NULL,
&Type, NULL, 0);
if (WinStatus != ERROR_SUCCESS)
{
fprintf (stderr, "Could not get %s registry entry: %s\n",
Signature, WindowsFormatException (WinStatus));
Status = AE_ERROR;
goto Cleanup;
}
if (Type == REG_BINARY)
{
break;
}
}
/* Get the size of the table */
WinStatus = RegQueryValueEx (Handle, KeyBuffer, NULL, NULL,
NULL, &DataSize);
if (WinStatus != ERROR_SUCCESS)
{
fprintf (stderr, "Could not read the %s table size: %s\n",
Signature, WindowsFormatException (WinStatus));
Status = AE_ERROR;
goto Cleanup;
}
/* Allocate a new buffer for the table */
ReturnTable = malloc (DataSize);
if (!ReturnTable)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
/* Get the actual table from the registry */
WinStatus = RegQueryValueEx (Handle, KeyBuffer, NULL, NULL,
(UCHAR *) ReturnTable, &DataSize);
if (WinStatus != ERROR_SUCCESS)
{
fprintf (stderr, "Could not read %s data: %s\n",
Signature, WindowsFormatException (WinStatus));
free (ReturnTable);
Status = AE_ERROR;
goto Cleanup;
}
fprintf (stderr, "Could not read %s data\n", Signature);
free (ReturnTable);
return (AE_ERROR);
}
*Table = ReturnTable;
*Address = 0;
Cleanup:
RegCloseKey (Handle);
return (Status);
return (Status);
}

10
tests/misc/grammar.asl
View File

@ -5692,7 +5692,7 @@ DefinitionBlock (
{ Return (0x41) } // Local1 indicates Local0 is not a Number
If (LEqual (Local0, 0)) // Number is type 1
{ Return (0x42) } // non-existant signal was acquired
{ Return (0x42) } // non-existent signal was acquired
Store ("Acquire signal timeout PASS", Debug)
@ -5713,7 +5713,7 @@ DefinitionBlock (
{ Return (0x51) } // Local1 indicates Local0 is not a Number
If (LEqual (Local0, 0)) // Number is type 1
{ Return (0x52) } // non-existant signal was acquired
{ Return (0x52) } // non-existent signal was acquired
Store ("Reset signal PASS", Debug)
@ -5727,7 +5727,7 @@ DefinitionBlock (
{ Return (0x61) } // Local1 indicates Local0 is not a Number
If (LEqual (Local0, 0)) // Number is type 1
{ Return (0x62) } // non-existant signal was acquired
{ Return (0x62) } // non-existent signal was acquired
Store ("Zero Lvalue PASS", Debug)
@ -5741,7 +5741,7 @@ DefinitionBlock (
{ Return (0x71) } // Local1 indicates Local0 is not a Number
If (LEqual (Local0, 0)) // Number is type 1
{ Return (0x72) } // non-existant signal was acquired
{ Return (0x72) } // non-existent signal was acquired
Store ("One Lvalue PASS", Debug)
@ -5782,7 +5782,7 @@ DefinitionBlock (
{ Return (0x84) } // Local1 indicates Local0 is not a Number
If (LEqual (Local0, 0)) // Number is type 1
{ Return (0x85) } // non-existant signal was acquired
{ Return (0x85) } // non-existent signal was acquired
Store ("Acquire Lvalue signal timeout PASS", Debug)

1
tests/templates/templates.sh
View File

@ -47,4 +47,3 @@ for f in $files ; do
diff -pu -I" \*" $sig.asl $sig.dsl >> diff.log
fi
done