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

Import ACPICA 20170728.

Browse Source
This commit is contained in:
jkim 2017-07-28 17:44:36 +00:00
parent e90a704516
commit fd207c000f
88 changed files with 1987 additions and 586 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
changes.txt
View File

@ -1,3 +1,85 @@
----------------------------------------
28 July 2017. Summary of changes for version 20170728:
1) ACPICA kernel-resident subsystem:
Fixed a regression seen with small resource descriptors that could cause
an inadvertent AE_AML_NO_RESOURCE_END_TAG exception.
AML interpreter: Implemented a new feature that allows forward references
from individual named references within package objects that are
contained within blocks of "module-level code". This provides
compatibility with other ACPI implementations and supports existing
firmware that depends on this feature. Example:
Name (ABCD, 1)
If (ABCD) /* An If() at module-level */
{
Name (PKG1, Package()
{
INT1 /* Forward reference to object INT1
*/
})
Name (INT1, 0x1234)
}
AML Interpreter: Fixed a problem with the Alias() operator where aliases
to some ASL objects were not handled properly. Objects affected are:
Mutex, Event, and OperationRegion.
AML Debugger: Enhanced to properly handle AML Alias objects. These
objects have one level of indirection which was not fully supported by
the debugger.
Table Manager: Added support to detect and ignore duplicate SSDTs within
the XSDT/RSDT. This error in the XSDT has been seen in the field.
EFI and EDK2 support:
Enabled /WX flag for MSVC builds
Added support for AcpiOsStall, AcpiOsSleep, and AcpiOsGetTimer
Added local support for 64-bit multiply and shift operations
Added support to compile acpidump.efi on Windows
Added OSL function stubs for interfaces not used under EFI
Added additional support for the _DMA predefined name. _DMA returns a
buffer containing a resource template. This change add support within the
resource manager (AcpiWalkResourceBuffer) to walk and parse this list of
resource descriptors. Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
2) iASL Compiler/Disassembler and Tools:
iASL: Fixed a problem where the internal input line buffer(s) could
overflow if there are very long lines in the input ASL source code file.
Implemented buffer management that automatically increases the size of
the buffers as necessary.
iASL: Added an option (-vx) to "expect" particular remarks, warnings and
errors. If the specified exception is not raised during compilation, the
compiler emits an error. This is intended to support the ASL test suite,
but may be useful in other contexts.
iASL: Implemented a new predefined macro, __METHOD__, which returns a
string containing the name of the current control method that is being
compiled.
iASL: Implemented debugger and table compiler support for the SDEI ACPI
table (Software Delegated Exception Interface). James Morse
<james.morse@arm.com>
Unix/Linux makefiles: Added an option to disable compile optimizations.
The disable occurs when the NOOPT flag is set to TRUE.
theracermaster@gmail.com
Acpidump: Added support for multiple DSDT and FACS tables. This can occur
when there are different tables for 32-bit versus 64-bit.
Enhanced error reporting for the ASL test suite (ASLTS) by removing
unnecessary/verbose text, and emit the actual line number where an error
has occurred. These changes are intended to improve the usefulness of the
test suite.
----------------------------------------
29 June 2017. Summary of changes for version 20170629:

8
generate/unix/Makefile.config
View File

@ -43,7 +43,7 @@ CC = gcc
OBJDIR = obj
BINDIR = bin
COMPILEOBJ = $(CC) -c $(CFLAGS) $(OPT_CFLAGS) -o $@ $<
LINKPROG = $(CC) $(OBJECTS) -o $(PROG) $(LDFLAGS)
LINKPROG = $(CC) $(OBJECTS) -o $(PROG) $(LDFLAGS) $(OPT_LDFLAGS)
PREFIX ?= /usr
INSTALLDIR = $(PREFIX)/bin
UNAME_S := $(shell uname -s)
@ -162,6 +162,8 @@ endif
#
ifneq ($(NOOPT),TRUE)
OPT_CFLAGS += -O2
else
OPT_CFLAGS += -O0
endif
#
@ -176,14 +178,14 @@ CFLAGS += \
-D$(HOST)\
-D_GNU_SOURCE\
-I$(ACPICA_INCLUDE)
#
# QNX requires __EXT to enable most functions in its C library, analogous
# to _GNU_SOURCE.
#
ifeq ($(HOST), _QNX)
CFLAGS+=-D__EXT
endif
endif
#
# Common compiler warning flags. The warning flags in addition

1
generate/unix/acpiexamples/Makefile
View File

@ -47,6 +47,7 @@ OBJECTS = \
$(OBJDIR)/dsmthdat.o\
$(OBJDIR)/dsobject.o\
$(OBJDIR)/dsopcode.o\
$(OBJDIR)/dspkginit.o\
$(OBJDIR)/dsutils.o\
$(OBJDIR)/dswexec.o\
$(OBJDIR)/dswload.o\

1
generate/unix/acpiexec/Makefile
View File

@ -85,6 +85,7 @@ OBJECTS = \
$(OBJDIR)/dsmthdat.o\
$(OBJDIR)/dsobject.o\
$(OBJDIR)/dsopcode.o\
$(OBJDIR)/dspkginit.o\
$(OBJDIR)/dsutils.o\
$(OBJDIR)/dswexec.o\
$(OBJDIR)/dswload.o\

1
generate/unix/acpinames/Makefile
View File

@ -43,6 +43,7 @@ OBJECTS = \
$(OBJDIR)/dsinit.o\
$(OBJDIR)/dsmthdat.o\
$(OBJDIR)/dsobject.o\
$(OBJDIR)/dspkginit.o\
$(OBJDIR)/dsutils.o\
$(OBJDIR)/dswload.o\
$(OBJDIR)/dswload2.o\

1
generate/unix/iasl/Makefile
View File

@ -134,6 +134,7 @@ OBJECTS = \
$(OBJDIR)/dsfield.o\
$(OBJDIR)/dsobject.o\
$(OBJDIR)/dsopcode.o\
$(OBJDIR)/dspkginit.o\
$(OBJDIR)/dsutils.o\
$(OBJDIR)/dswexec.o\
$(OBJDIR)/dswload.o\

1
source/common/ahtable.c
View File

@ -239,6 +239,7 @@ const AH_TABLE Gbl_AcpiSupportedTables[] =
{ACPI_SIG_RSDT, "Root System Description Table"},
{ACPI_SIG_S3PT, "S3 Performance Table"},
{ACPI_SIG_SBST, "Smart Battery Specification Table"},
{ACPI_SIG_SDEI, "Software Delegated Exception Interface Table"},
{ACPI_SIG_SLIC, "Software Licensing Description Table"},
{ACPI_SIG_SLIT, "System Locality Information Table"},
{ACPI_SIG_SPCR, "Serial Port Console Redirection table"},

1
source/common/dmtable.c
View File

@ -493,6 +493,7 @@ const ACPI_DMTABLE_DATA AcpiDmTableData[] =
{ACPI_SIG_RSDT, NULL, AcpiDmDumpRsdt, DtCompileRsdt, TemplateRsdt},
{ACPI_SIG_S3PT, NULL, NULL, NULL, TemplateS3pt},
{ACPI_SIG_SBST, AcpiDmTableInfoSbst, NULL, NULL, TemplateSbst},
{ACPI_SIG_SDEI, AcpiDmTableInfoSdei, NULL, NULL, TemplateSdei},
{ACPI_SIG_SLIC, NULL, AcpiDmDumpSlic, DtCompileSlic, TemplateSlic},
{ACPI_SIG_SLIT, NULL, AcpiDmDumpSlit, DtCompileSlit, TemplateSlit},
{ACPI_SIG_SPCR, AcpiDmTableInfoSpcr, NULL, NULL, TemplateSpcr},

11
source/common/dmtbinfo.c
View File

@ -218,6 +218,7 @@
#define ACPI_RASF_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_RASF,f)
#define ACPI_S3PT_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_S3PT,f)
#define ACPI_SBST_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_SBST,f)
#define ACPI_SDEI_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_SDEI,f)
#define ACPI_SLIT_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_SLIT,f)
#define ACPI_SPCR_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_SPCR,f)
#define ACPI_SPMI_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_SPMI,f)
@ -2767,6 +2768,16 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoPmtt2[] =
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* SDEI - Software Delegated Execption Interface Descriptor Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoSdei[] =
{
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*

1
source/compiler/aslcompile.c
View File

@ -815,6 +815,7 @@ CmCleanupAndExit (
BOOLEAN DeleteAmlFile = FALSE;
AslCheckExpectedExceptions ();
AePrintErrorLog (ASL_FILE_STDERR);
if (Gbl_DebugFlag)
{

10
source/compiler/aslcompiler.h
View File

@ -413,12 +413,20 @@ AslError (
ACPI_PARSE_OBJECT *Op,
char *ExtraMessage);
void
AslCheckExpectedExceptions (
void);
ACPI_STATUS
AslExpectException (
char *MessageIdString);
ACPI_STATUS
AslDisableException (
char *MessageIdString);
BOOLEAN
AslIsExceptionDisabled (
AslIsExceptionIgnored (
UINT8 Level,
UINT16 MessageId);

2
source/compiler/aslcompiler.l
View File

@ -809,7 +809,7 @@ NamePathTail [.]{NameSeg}
"__FILE__" { count (0); return (PARSEOP___FILE__); }
"__LINE__" { count (0); return (PARSEOP___LINE__); }
"__PATH__" { count (0); return (PARSEOP___PATH__); }
"__METHOD__" { count (0); return (PARSEOP___METHOD__); }
{NameSeg} { char *s;
count (0);

165
source/compiler/aslerror.c
View File

@ -160,6 +160,16 @@ static void
AeAddToErrorLog (
ASL_ERROR_MSG *Enode);
static BOOLEAN
AslIsExceptionExpected (
UINT8 Level,
UINT16 MessageId);
static BOOLEAN
AslIsExceptionDisabled (
UINT8 Level,
UINT16 MessageId);
/*******************************************************************************
*
@ -806,6 +816,115 @@ AslCommonError (
return;
}
/*******************************************************************************
*
* FUNCTION: AslIsExceptionIgnored
*
* PARAMETERS: Level - Seriousness (Warning/error, etc.)
* MessageId - Index into global message buffer
*
* RETURN: BOOLEAN
*
* DESCRIPTION: Check if a particular exception is ignored. In this case it
* means that the exception is (expected or disabled.
*
******************************************************************************/
BOOLEAN
AslIsExceptionIgnored (
UINT8 Level,
UINT16 MessageId)
{
BOOLEAN ExceptionIgnored;
/* Note: this allows exception to be disabled and expected */
ExceptionIgnored = AslIsExceptionDisabled (Level, MessageId);
ExceptionIgnored |= AslIsExceptionExpected (Level, MessageId);
return (Gbl_AllExceptionsDisabled || ExceptionIgnored);
}
/*******************************************************************************
*
* FUNCTION: AslCheckExpectException
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Check the global expected messages table and raise an error
* for each message that has not been received.
*
******************************************************************************/
void
AslCheckExpectedExceptions (
void)
{
UINT8 i;
for (i = 0; i < Gbl_ExpectedMessagesIndex; ++i)
{
if (!Gbl_ExpectedMessages[i].MessageReceived)
{
AslError (ASL_ERROR, ASL_MSG_EXCEPTION_NOT_RECEIVED, NULL,
Gbl_ExpectedMessages[i].MessageIdStr);
}
}
}
/*******************************************************************************
*
* FUNCTION: AslExpectException
*
* PARAMETERS: MessageIdString - ID of excepted exception during compile
*
* RETURN: Status
*
* DESCRIPTION: Enter a message ID into the global expected messages table
* If these messages are not raised during the compilation, throw
* an error.
*
******************************************************************************/
ACPI_STATUS
AslExpectException (
char *MessageIdString)
{
UINT32 MessageId;
/* Convert argument to an integer and validate it */
MessageId = (UINT32) strtoul (MessageIdString, NULL, 0);
if (MessageId > 6999)
{
printf ("\"%s\" is not a valid warning/remark/erro ID\n",
MessageIdString);
return (AE_BAD_PARAMETER);
}
/* Insert value into the global expected message array */
if (Gbl_ExpectedMessagesIndex >= ASL_MAX_EXPECTED_MESSAGES)
{
printf ("Too many messages have been registered as expected (max %u)\n",
ASL_MAX_DISABLED_MESSAGES);
return (AE_LIMIT);
}
Gbl_ExpectedMessages[Gbl_ExpectedMessagesIndex].MessageId = MessageId;
Gbl_ExpectedMessages[Gbl_ExpectedMessagesIndex].MessageIdStr = MessageIdString;
Gbl_ExpectedMessages[Gbl_ExpectedMessagesIndex].MessageReceived = FALSE;
Gbl_ExpectedMessagesIndex++;
return (AE_OK);
}
/*******************************************************************************
*
@ -866,7 +985,48 @@ AslDisableException (
*
******************************************************************************/
BOOLEAN
static BOOLEAN
AslIsExceptionExpected (
UINT8 Level,
UINT16 MessageId)
{
UINT32 EncodedMessageId;
UINT32 i;
/*
* Mark this exception as received
*/
EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId);
for (i = 0; i < Gbl_ExpectedMessagesIndex; i++)
{
/* Simple implementation via fixed array */
if (EncodedMessageId == Gbl_ExpectedMessages[i].MessageId)
{
return (Gbl_ExpectedMessages[i].MessageReceived = TRUE);
}
}
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: AslIsExceptionDisabled
*
* PARAMETERS: Level - Seriousness (Warning/error, etc.)
* MessageId - Index into global message buffer
*
* RETURN: TRUE if exception/message should be ignored
*
* DESCRIPTION: Check if the user has specified options such that this
* exception should be ignored
*
******************************************************************************/
static BOOLEAN
AslIsExceptionDisabled (
UINT8 Level,
UINT16 MessageId)
@ -940,8 +1100,7 @@ AslError (
/* Check if user wants to ignore this exception */
if (Gbl_AllExceptionsDisabled ||
AslIsExceptionDisabled (Level, MessageId))
if (AslIsExceptionIgnored (Level, MessageId))
{
return;
}

3
source/compiler/aslglobal.h
View File

@ -252,6 +252,7 @@ extern int AslCompilerdebug;
#define ASL_DEFAULT_LINE_BUFFER_SIZE (1024 * 32) /* 32K */
#define ASL_MSG_BUFFER_SIZE (1024 * 32) /* 32k */
#define ASL_MAX_DISABLED_MESSAGES 32
#define ASL_MAX_EXPECTED_MESSAGES 32
#define HEX_TABLE_LINE_SIZE 8
#define HEX_LISTING_LINE_SIZE 8
@ -396,6 +397,7 @@ ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentHexColumn, 0);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentAmlOffset, 0);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentLine, 0);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_DisabledMessagesIndex, 0);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_ExpectedMessagesIndex, 0);
ASL_EXTERN UINT8 ASL_INIT_GLOBAL (Gbl_HexBytesWereWritten, FALSE);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_NumNamespaceObjects, 0);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_ReservedMethods, 0);
@ -438,6 +440,7 @@ ASL_EXTERN char MsgBuffer[ASL_MSG_BUFFER_SIZE];
ASL_EXTERN char StringBuffer[ASL_MSG_BUFFER_SIZE];
ASL_EXTERN char StringBuffer2[ASL_MSG_BUFFER_SIZE];
ASL_EXTERN UINT32 Gbl_DisabledMessages[ASL_MAX_DISABLED_MESSAGES];
ASL_EXTERN ASL_EXPECTED_MESSAGE Gbl_ExpectedMessages[ASL_MAX_EXPECTED_MESSAGES];
#endif /* __ASLGLOBAL_H */

1
source/compiler/aslhelp.c
View File

@ -205,6 +205,7 @@ Usage (
ACPI_OPTION ("-vi", "Less verbose errors and warnings for use with IDEs");
ACPI_OPTION ("-vr", "Disable remarks");
ACPI_OPTION ("-vw <messageid>", "Disable specific warning or remark");
ACPI_OPTION ("-vx <messageid>", "Expect a specific warning, remark, or error");
ACPI_OPTION ("-w <1|2|3>", "Set warning reporting level");
ACPI_OPTION ("-we", "Report warnings as errors");

3
source/compiler/aslmessages.c
View File

@ -348,7 +348,8 @@ const char *AslCompilerMsgs [] =
/* ASL_MSG_ARG_AS_LOCAL_NOT_USED */ "Method Argument (as a local) is set but never used",
/* ASL_MSG_ARG_NOT_USED */ "Method Argument is never used",
/* ASL_MSG_CONSTANT_REQUIRED */ "Non-reducible expression",
/* ASL_MSG_CROSS_TABLE_SCOPE */ "Illegal open scope on external object from within DSDT"
/* ASL_MSG_CROSS_TABLE_SCOPE */ "Illegal open scope on external object from within DSDT",
/* ASL_MSG_EXCEPTION_NOT_RECEIVED */ "Expected remark, warning, or error did not occur. Message ID:"
};
/* Table compiler */

1
source/compiler/aslmessages.h
View File

@ -351,6 +351,7 @@ typedef enum
ASL_MSG_ARG_NOT_USED,
ASL_MSG_CONSTANT_REQUIRED,
ASL_MSG_CROSS_TABLE_SCOPE,
ASL_MSG_EXCEPTION_NOT_RECEIVED,
/* These messages are used by the Data Table compiler only */

16
source/compiler/asloptions.c
View File

@ -954,6 +954,22 @@ AslDoOptions (
}
break;
case 'x':
/* Get the required argument */
if (AcpiGetoptArgument (argc, argv))
{
return (-1);
}
Status = AslExpectException (AcpiGbl_Optarg);
if (ACPI_FAILURE (Status))
{
return (-1);
}
break;
default:
printf ("Unknown option: -v%s\n", AcpiGbl_Optarg);

16
source/compiler/aslparseop.c
View File

@ -685,10 +685,10 @@ TrCreateNullTargetOp (
* DESCRIPTION: Create a leaf op (no children or peers) for one of the
* special constants - __LINE__, __FILE__, and __DATE__.
*
* Note: An implemenation of __FUNC__ cannot happen here because we don't
* have a full parse tree at this time and cannot find the parent control
* method. If it is ever needed, __FUNC__ must be implemented later, after
* the parse tree has been fully constructed.
* Note: The fullimplemenation of __METHOD__ cannot happen here because we
* don't have a full parse tree at this time and cannot find the parent
* control method. __METHOD__ must be implemented later, after the parse
* tree has been fully constructed.
*
******************************************************************************/
@ -711,6 +711,14 @@ TrCreateConstantLeafOp (
Op->Asl.Value.Integer = Op->Asl.LineNumber;
break;
case PARSEOP___METHOD__:
/* Will become a string literal later */
Op = TrAllocateOp (PARSEOP___METHOD__);
Op->Asl.Value.String = NULL;
break;
case PARSEOP___PATH__:
Op = TrAllocateOp (PARSEOP_STRING_LITERAL);

1
source/compiler/aslrules.y
View File

@ -592,6 +592,7 @@ ConstExprTerm
| PARSEOP___FILE__ {$$ = TrCreateConstantLeafOp (PARSEOP___FILE__);}
| PARSEOP___LINE__ {$$ = TrCreateConstantLeafOp (PARSEOP___LINE__);}
| PARSEOP___PATH__ {$$ = TrCreateConstantLeafOp (PARSEOP___PATH__);}
| PARSEOP___METHOD__ {$$ = TrCreateConstantLeafOp (PARSEOP___METHOD__);}
;
Integer

1
source/compiler/asltokens.y
View File

@ -637,3 +637,4 @@ NoEcho('
%token <i> PARSEOP___FILE__
%token <i> PARSEOP___LINE__
%token <i> PARSEOP___PATH__
%token <i> PARSEOP___METHOD__

31
source/compiler/asltransform.c
View File

@ -430,6 +430,8 @@ static void
TrTransformSubtree (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *MethodOp;
if (Op->Asl.AmlOpcode == AML_RAW_DATA_BYTE)
{
@ -465,6 +467,35 @@ TrTransformSubtree (
break;
case PARSEOP___METHOD__:
/* Transform to a string op containing the parent method name */
Op->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
UtSetParseOpName (Op);
/* Find the parent control method op */
MethodOp = Op;
while (MethodOp)
{
if (MethodOp->Asl.ParseOpcode == PARSEOP_METHOD)
{
/* First child contains the method name */
MethodOp = MethodOp->Asl.Child;
Op->Asl.Value.String = MethodOp->Asl.Value.String;
return;
}
MethodOp = MethodOp->Asl.Parent;
}
/* At the root, invocation not within a control method */
Op->Asl.Value.String = "\\";
break;
default:
/* Nothing to do here for other opcodes */

9
source/compiler/asltypes.h
View File

@ -355,6 +355,15 @@ typedef struct asl_error_msg
} ASL_ERROR_MSG;
/* An entry in the expected messages array */
typedef struct asl_expected_message
{
UINT32 MessageId;
char *MessageIdStr;
BOOLEAN MessageReceived;
} ASL_EXPECTED_MESSAGE;
/* An entry in the listing file stack (for include files) */

71
source/compiler/aslutils.c
View File

@ -174,6 +174,12 @@ UtAttachNameseg (
ACPI_PARSE_OBJECT *Op,
char *Name);
static void
UtReallocLineBuffers (
char **Buffer,
UINT32 OldSize,
UINT32 NewSize);
/*******************************************************************************
*
@ -733,43 +739,48 @@ UtExpandLineBuffers (
Gbl_LineBufferSize, NewSize);
}
Gbl_CurrentLineBuffer = realloc (Gbl_CurrentLineBuffer, NewSize);
UtReallocLineBuffers (&Gbl_CurrentLineBuffer, Gbl_LineBufferSize, NewSize);
UtReallocLineBuffers (&Gbl_MainTokenBuffer, Gbl_LineBufferSize, NewSize);
UtReallocLineBuffers (&Gbl_MacroTokenBuffer, Gbl_LineBufferSize, NewSize);
UtReallocLineBuffers (&Gbl_ExpressionTokenBuffer, Gbl_LineBufferSize, NewSize);
Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
if (!Gbl_CurrentLineBuffer)
{
goto ErrorExit;
}
Gbl_MainTokenBuffer = realloc (Gbl_MainTokenBuffer, NewSize);
if (!Gbl_MainTokenBuffer)
{
goto ErrorExit;
}
Gbl_MacroTokenBuffer = realloc (Gbl_MacroTokenBuffer, NewSize);
if (!Gbl_MacroTokenBuffer)
{
goto ErrorExit;
}
Gbl_ExpressionTokenBuffer = realloc (Gbl_ExpressionTokenBuffer, NewSize);
if (!Gbl_ExpressionTokenBuffer)
{
goto ErrorExit;
}
Gbl_LineBufferSize = NewSize;
return;
}
/* On error above, simply issue error messages and abort, cannot continue */
/******************************************************************************
*
* FUNCTION: UtReallocLineBuffers
*
* PARAMETERS: Buffer - Buffer to realloc
* OldSize - Old size of Buffer
* NewSize - New size of Buffer
*
* RETURN: none
*
* DESCRIPTION: Reallocate and initialize Buffer
*
*****************************************************************************/
static void
UtReallocLineBuffers (
char **Buffer,
UINT32 OldSize,
UINT32 NewSize)
{
*Buffer = realloc (*Buffer, NewSize);
if (*Buffer)
{
memset (*Buffer + OldSize, 0, NewSize - OldSize);
return;
}
ErrorExit:
printf ("Could not increase line buffer size from %u to %u\n",
Gbl_LineBufferSize, Gbl_LineBufferSize * 2);
OldSize, NewSize);
AslError (ASL_ERROR, ASL_MSG_BUFFER_ALLOCATION,
NULL, NULL);
AslError (ASL_ERROR, ASL_MSG_BUFFER_ALLOCATION, NULL, NULL);
AslAbort ();
}

21
source/compiler/dtcompile.c
View File

@ -486,18 +486,21 @@ DtCompileDataTable (
}
else if (TableData->TableInfo)
{
/* Simple table, just walk the info table */
/* Simple table, just walk the info table, unless its empty */
Subtable = NULL;
Status = DtCompileTable (FieldList, TableData->TableInfo,
&Subtable, TRUE);
if (ACPI_FAILURE (Status))
if (FieldList && *FieldList)
{
return (Status);
}
Subtable = NULL;
Status = DtCompileTable (FieldList, TableData->TableInfo,
&Subtable, TRUE);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtInsertSubtable (Gbl_RootTable, Subtable);
DtPopSubtable ();
DtInsertSubtable (Gbl_RootTable, Subtable);
DtPopSubtable ();
}
}
else
{

1
source/compiler/dtcompiler.h
View File

@ -726,6 +726,7 @@ extern const unsigned char TemplateRasf[];
extern const unsigned char TemplateRsdt[];
extern const unsigned char TemplateS3pt[];
extern const unsigned char TemplateSbst[];
extern const unsigned char TemplateSdei[];
extern const unsigned char TemplateSlic[];
extern const unsigned char TemplateSlit[];
extern const unsigned char TemplateSpcr[];

9
source/compiler/dttemplate.h
View File

@ -1178,6 +1178,15 @@ const unsigned char TemplateSbst[] =
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 /* 00000028 "........" */
};
const unsigned char TemplateSdei[] =
{
0x53,0x44,0x45,0x49,0x3e,0x00,0x00,0x00, /* 00000000 "SDEI>..." */
0x01,0x59,0x41,0x52,0x4d,0x20,0x20,0x20, /* 00000008 ".mARM " */
0x54,0x45,0x4D,0x50,0x4C,0x41,0x54,0x45, /* 00000010 "TEMPLATE" */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x30,0x09,0x16,0x20 /* 00000028 "0.. " */
};
const unsigned char TemplateSlic[] =
{
0x53,0x4C,0x49,0x43,0x76,0x01,0x00,0x00, /* 00000000 "SLICv..." */

2
source/compiler/dtutils.c
View File

@ -190,7 +190,7 @@ DtError (
/* Check if user wants to ignore this exception */
if (AslIsExceptionDisabled (Level, MessageId))
if (AslIsExceptionIgnored (Level, MessageId))
{
return;
}

2
source/compiler/prmacros.c
View File

@ -483,7 +483,7 @@ PrAddMacro (
{
/* Search the macro arg list for matching arg */
for (i = 0; Args[i].Name && (i < PR_MAX_MACRO_ARGS); i++)
for (i = 0; ((i < PR_MAX_MACRO_ARGS) && Args[i].Name); i++)
{
/*
* Save argument offset within macro body. This is the mechanism

33
source/components/debugger/dbdisply.c
View File

@ -451,7 +451,7 @@ AcpiDbDecodeAndDisplayObject (
else
{
AcpiOsPrintf ("Object (%p) Pathname: %s\n",
AcpiOsPrintf ("Object %p: Namespace Node - Pathname: %s\n",
Node, (char *) RetBuf.Pointer);
}
@ -468,7 +468,7 @@ AcpiDbDecodeAndDisplayObject (
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
AcpiOsPrintf ("\nAttached Object (%p):\n", ObjDesc);
AcpiOsPrintf ("\nAttached Object %p:", ObjDesc);
if (!AcpiOsReadable (ObjDesc, sizeof (ACPI_OPERAND_OBJECT)))
{
AcpiOsPrintf ("Invalid internal ACPI Object at address %p\n",
@ -476,8 +476,33 @@ AcpiDbDecodeAndDisplayObject (
return;
}
AcpiUtDebugDumpBuffer ((void *) ObjDesc,
sizeof (ACPI_OPERAND_OBJECT), Display, ACPI_UINT32_MAX);
if (ACPI_GET_DESCRIPTOR_TYPE (
((ACPI_NAMESPACE_NODE *) ObjDesc)) == ACPI_DESC_TYPE_NAMED)
{
AcpiOsPrintf (" Namespace Node - ");
Status = AcpiGetName ((ACPI_NAMESPACE_NODE *) ObjDesc,
ACPI_FULL_PATHNAME_NO_TRAILING, &RetBuf);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not convert name to pathname\n");
}
else
{
AcpiOsPrintf ("Pathname: %s",
(char *) RetBuf.Pointer);
}
AcpiOsPrintf ("\n");
AcpiUtDebugDumpBuffer ((void *) ObjDesc,
sizeof (ACPI_NAMESPACE_NODE), Display, ACPI_UINT32_MAX);
}
else
{
AcpiOsPrintf ("\n");
AcpiUtDebugDumpBuffer ((void *) ObjDesc,
sizeof (ACPI_OPERAND_OBJECT), Display, ACPI_UINT32_MAX);
}
AcpiExDumpObjectDescriptor (ObjDesc, 1);
}
}

4
source/components/dispatcher/dsfield.c
View File

@ -313,6 +313,8 @@ AcpiDsCreateBufferField (
if (!(WalkState->ParseFlags & ACPI_PARSE_EXECUTE))
{
ACPI_ERROR ((AE_INFO,
"Parse execute mode is not set"));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
@ -701,6 +703,8 @@ AcpiDsInitFieldObjects (
return_ACPI_STATUS (AE_OK);
}
ACPI_ERROR ((AE_INFO,
"Parse deferred mode is not set"));
return_ACPI_STATUS (AE_AML_INTERNAL);
}

392
source/components/dispatcher/dsobject.c
View File

@ -160,14 +160,6 @@
#define _COMPONENT ACPI_DISPATCHER
ACPI_MODULE_NAME ("dsobject")
/* Local prototypes */
static ACPI_STATUS
AcpiDsBuildInternalObject (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
ACPI_OPERAND_OBJECT **ObjDescPtr);
#ifndef ACPI_NO_METHOD_EXECUTION
/*******************************************************************************
@ -185,7 +177,7 @@ AcpiDsBuildInternalObject (
*
******************************************************************************/
static ACPI_STATUS
ACPI_STATUS
AcpiDsBuildInternalObject (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
@ -193,7 +185,6 @@ AcpiDsBuildInternalObject (
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_STATUS Status;
ACPI_OBJECT_TYPE Type;
ACPI_FUNCTION_TRACE (DsBuildInternalObject);
@ -204,129 +195,43 @@ AcpiDsBuildInternalObject (
{
/*
* This is a named object reference. If this name was
* previously looked up in the namespace, it was stored in this op.
* Otherwise, go ahead and look it up now
* previously looked up in the namespace, it was stored in
* this op. Otherwise, go ahead and look it up now
*/
if (!Op->Common.Node)
{
Status = AcpiNsLookup (WalkState->ScopeInfo,
Op->Common.Value.String,
ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL,
ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, &(Op->Common.Node)));
if (ACPI_FAILURE (Status))
/* Check if we are resolving a named reference within a package */
if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
{
/* Check if we are resolving a named reference within a package */
if ((Status == AE_NOT_FOUND) && (AcpiGbl_EnableInterpreterSlack) &&
((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)))
{
/*
* We didn't find the target and we are populating elements
* of a package - ignore if slack enabled. Some ASL code
* contains dangling invalid references in packages and
* expects that no exception will be issued. Leave the
* element as a null element. It cannot be used, but it
* can be overwritten by subsequent ASL code - this is
* typically the case.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Ignoring unresolved reference in package [%4.4s]\n",
WalkState->ScopeInfo->Scope.Node->Name.Ascii));
return_ACPI_STATUS (AE_OK);
}
else
/*
* We won't resolve package elements here, we will do this
* after all ACPI tables are loaded into the namespace. This
* behavior supports both forward references to named objects
* and external references to objects in other tables.
*/
goto CreateNewObject;
}
else
{
Status = AcpiNsLookup (WalkState->ScopeInfo,
Op->Common.Value.String,
ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL,
ACPI_CAST_INDIRECT_PTR (
ACPI_NAMESPACE_NODE, &(Op->Common.Node)));
if (ACPI_FAILURE (Status))
{
ACPI_ERROR_NAMESPACE (Op->Common.Value.String, Status);
return_ACPI_STATUS (Status);
}
return_ACPI_STATUS (Status);
}
}
/* Special object resolution for elements of a package */
if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
{
/*
* Attempt to resolve the node to a value before we insert it into
* the package. If this is a reference to a common data type,
* resolve it immediately. According to the ACPI spec, package
* elements can only be "data objects" or method references.
* Attempt to resolve to an Integer, Buffer, String or Package.
* If cannot, return the named reference (for things like Devices,
* Methods, etc.) Buffer Fields and Fields will resolve to simple
* objects (int/buf/str/pkg).
*
* NOTE: References to things like Devices, Methods, Mutexes, etc.
* will remain as named references. This behavior is not described
* in the ACPI spec, but it appears to be an oversight.
*/
ObjDesc = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Op->Common.Node);
Status = AcpiExResolveNodeToValue (
ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, &ObjDesc),
WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/*
* Special handling for Alias objects. We need to setup the type
* and the Op->Common.Node to point to the Alias target. Note,
* Alias has at most one level of indirection internally.
*/
Type = Op->Common.Node->Type;
if (Type == ACPI_TYPE_LOCAL_ALIAS)
{
Type = ObjDesc->Common.Type;
Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE,
Op->Common.Node->Object);
}
switch (Type)
{
/*
* For these types, we need the actual node, not the subobject.
* However, the subobject did not get an extra reference count above.
*
* TBD: should ExResolveNodeToValue be changed to fix this?
*/
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_THERMAL:
AcpiUtAddReference (Op->Common.Node->Object);
/*lint -fallthrough */
/*
* For these types, we need the actual node, not the subobject.
* The subobject got an extra reference count in ExResolveNodeToValue.
*/
case ACPI_TYPE_MUTEX:
case ACPI_TYPE_METHOD:
case ACPI_TYPE_POWER:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_EVENT:
case ACPI_TYPE_REGION:
/* We will create a reference object for these types below */
break;
default:
/*
* All other types - the node was resolved to an actual
* object, we are done.
*/
goto Exit;
}
}
}
CreateNewObject:
/* Create and init a new internal ACPI object */
ObjDesc = AcpiUtCreateInternalObject (
@ -344,7 +249,28 @@ AcpiDsBuildInternalObject (
return_ACPI_STATUS (Status);
}
Exit:
/*
* Handling for unresolved package reference elements.
* These are elements that are namepaths.
*/
if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
{
ObjDesc->Reference.Resolved = TRUE;
if ((Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
!ObjDesc->Reference.Node)
{
/*
* Name was unresolved above.
* Get the prefix node for later lookup
*/
ObjDesc->Reference.Node = WalkState->ScopeInfo->Scope.Node;
ObjDesc->Reference.Aml = Op->Common.Aml;
ObjDesc->Reference.Resolved = FALSE;
}
}
*ObjDescPtr = ObjDesc;
return_ACPI_STATUS (Status);
}
@ -466,209 +392,6 @@ AcpiDsBuildInternalBufferObj (
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsBuildInternalPackageObj
*
* PARAMETERS: WalkState - Current walk state
* Op - Parser object to be translated
* ElementCount - Number of elements in the package - this is
* the NumElements argument to Package()
* ObjDescPtr - Where the ACPI internal object is returned
*
* RETURN: Status
*
* DESCRIPTION: Translate a parser Op package object to the equivalent
* namespace object
*
* NOTE: The number of elements in the package will be always be the NumElements
* count, regardless of the number of elements in the package list. If
* NumElements is smaller, only that many package list elements are used.
* if NumElements is larger, the Package object is padded out with
* objects of type Uninitialized (as per ACPI spec.)
*
* Even though the ASL compilers do not allow NumElements to be smaller
* than the Package list length (for the fixed length package opcode), some
* BIOS code modifies the AML on the fly to adjust the NumElements, and
* this code compensates for that. This also provides compatibility with
* other AML interpreters.
*
******************************************************************************/
ACPI_STATUS
AcpiDsBuildInternalPackageObj (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
UINT32 ElementCount,
ACPI_OPERAND_OBJECT **ObjDescPtr)
{
ACPI_PARSE_OBJECT *Arg;
ACPI_PARSE_OBJECT *Parent;
ACPI_OPERAND_OBJECT *ObjDesc = NULL;
ACPI_STATUS Status = AE_OK;
UINT32 i;
UINT16 Index;
UINT16 ReferenceCount;
ACPI_FUNCTION_TRACE (DsBuildInternalPackageObj);
/* Find the parent of a possibly nested package */
Parent = Op->Common.Parent;
while ((Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
{
Parent = Parent->Common.Parent;
}
/*
* If we are evaluating a Named package object "Name (xxxx, Package)",
* the package object already exists, otherwise it must be created.
*/
ObjDesc = *ObjDescPtr;
if (!ObjDesc)
{
ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE);
*ObjDescPtr = ObjDesc;
if (!ObjDesc)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
ObjDesc->Package.Node = Parent->Common.Node;
}
/*
* Allocate the element array (array of pointers to the individual
* objects) based on the NumElements parameter. Add an extra pointer slot
* so that the list is always null terminated.
*/
ObjDesc->Package.Elements = ACPI_ALLOCATE_ZEROED (
((ACPI_SIZE) ElementCount + 1) * sizeof (void *));
if (!ObjDesc->Package.Elements)
{
AcpiUtDeleteObjectDesc (ObjDesc);
return_ACPI_STATUS (AE_NO_MEMORY);
}
ObjDesc->Package.Count = ElementCount;
/*
* Initialize the elements of the package, up to the NumElements count.
* Package is automatically padded with uninitialized (NULL) elements
* if NumElements is greater than the package list length. Likewise,
* Package is truncated if NumElements is less than the list length.
*/
Arg = Op->Common.Value.Arg;
Arg = Arg->Common.Next;
for (i = 0; Arg && (i < ElementCount); i++)
{
if (Arg->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP)
{
if (Arg->Common.Node->Type == ACPI_TYPE_METHOD)
{
/*
* A method reference "looks" to the parser to be a method
* invocation, so we special case it here
*/
Arg->Common.AmlOpcode = AML_INT_NAMEPATH_OP;
Status = AcpiDsBuildInternalObject (
WalkState, Arg, &ObjDesc->Package.Elements[i]);
}
else
{
/* This package element is already built, just get it */
ObjDesc->Package.Elements[i] =
ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node);
}
}
else
{
Status = AcpiDsBuildInternalObject (
WalkState, Arg, &ObjDesc->Package.Elements[i]);
}
if (*ObjDescPtr)
{
/* Existing package, get existing reference count */
ReferenceCount = (*ObjDescPtr)->Common.ReferenceCount;
if (ReferenceCount > 1)
{
/* Make new element ref count match original ref count */
for (Index = 0; Index < (ReferenceCount - 1); Index++)
{
AcpiUtAddReference ((ObjDesc->Package.Elements[i]));
}
}
}
Arg = Arg->Common.Next;
}
/* Check for match between NumElements and actual length of PackageList */
if (Arg)
{
/*
* NumElements was exhausted, but there are remaining elements in the
* PackageList. Truncate the package to NumElements.
*
* Note: technically, this is an error, from ACPI spec: "It is an error
* for NumElements to be less than the number of elements in the
* PackageList". However, we just print a message and
* no exception is returned. This provides Windows compatibility. Some
* BIOSs will alter the NumElements on the fly, creating this type
* of ill-formed package object.
*/
while (Arg)
{
/*
* We must delete any package elements that were created earlier
* and are not going to be used because of the package truncation.
*/
if (Arg->Common.Node)
{
AcpiUtRemoveReference (
ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node));
Arg->Common.Node = NULL;
}
/* Find out how many elements there really are */
i++;
Arg = Arg->Common.Next;
}
ACPI_INFO ((
"Actual Package length (%u) is larger than "
"NumElements field (%u), truncated",
i, ElementCount));
}
else if (i < ElementCount)
{
/*
* Arg list (elements) was exhausted, but we did not reach NumElements count.
* Note: this is not an error, the package is padded out with NULLs.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Package List length (%u) smaller than NumElements "
"count (%u), padded with null elements\n",
i, ElementCount));
}
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsCreateNode
@ -796,10 +519,20 @@ AcpiDsInitObjectFromOp (
case ACPI_TYPE_PACKAGE:
/*
* Defer evaluation of Package TermArg operand
* Defer evaluation of Package TermArg operand and all
* package elements. (01/2017): We defer the element
* resolution to allow forward references from the package
* in order to provide compatibility with other ACPI
* implementations.
*/
ObjDesc->Package.Node = ACPI_CAST_PTR (
ACPI_NAMESPACE_NODE, WalkState->Operands[0]);
if (!Op->Named.Data)
{
return_ACPI_STATUS (AE_OK);
}
ObjDesc->Package.AmlStart = Op->Named.Data;
ObjDesc->Package.AmlLength = Op->Named.Length;
break;
@ -940,8 +673,11 @@ AcpiDsInitObjectFromOp (
/* Node was saved in Op */
ObjDesc->Reference.Node = Op->Common.Node;
ObjDesc->Reference.Object = Op->Common.Node->Object;
ObjDesc->Reference.Class = ACPI_REFCLASS_NAME;
if (Op->Common.Node)
{
ObjDesc->Reference.Object = Op->Common.Node->Object;
}
break;
case AML_DEBUG_OP:

10
source/components/dispatcher/dsopcode.c
View File

@ -747,6 +747,16 @@ AcpiDsEvalDataObjectOperands (
*/
WalkState->OperandIndex = WalkState->NumOperands;
/* Ignore if child is not valid */
if (!Op->Common.Value.Arg)
{
ACPI_ERROR ((AE_INFO,
"Dispatch: Missing child while executing TermArg for %X",
Op->Common.AmlOpcode));
return_ACPI_STATUS (AE_OK);
}
Status = AcpiDsCreateOperand (WalkState, Op->Common.Value.Arg, 1);
if (ACPI_FAILURE (Status))
{

635
source/components/dispatcher/dspkginit.c Normal file
View File

@ -0,0 +1,635 @@
/******************************************************************************
*
* Module Name: dspkginit - Completion of deferred package initialization
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2017, Intel Corp.
* All rights reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
* rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
* to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
* and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
* Code and the date of any change. Licensee must include in that file the
* documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
* documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
* any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************
*
* Alternatively, you may choose to be licensed under the terms of the
* following license:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, you may choose to be licensed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
*****************************************************************************/
#include "acpi.h"
#include "accommon.h"
#include "acnamesp.h"
#include "amlcode.h"
#include "acdispat.h"
#include "acinterp.h"
#define _COMPONENT ACPI_NAMESPACE
ACPI_MODULE_NAME ("dspkginit")
/* Local prototypes */
static void
AcpiDsResolvePackageElement (
ACPI_OPERAND_OBJECT **Element);
/*******************************************************************************
*
* FUNCTION: AcpiDsBuildInternalPackageObj
*
* PARAMETERS: WalkState - Current walk state
* Op - Parser object to be translated
* ElementCount - Number of elements in the package - this is
* the NumElements argument to Package()
* ObjDescPtr - Where the ACPI internal object is returned
*
* RETURN: Status
*
* DESCRIPTION: Translate a parser Op package object to the equivalent
* namespace object
*
* NOTE: The number of elements in the package will be always be the NumElements
* count, regardless of the number of elements in the package list. If
* NumElements is smaller, only that many package list elements are used.
* if NumElements is larger, the Package object is padded out with
* objects of type Uninitialized (as per ACPI spec.)
*
* Even though the ASL compilers do not allow NumElements to be smaller
* than the Package list length (for the fixed length package opcode), some
* BIOS code modifies the AML on the fly to adjust the NumElements, and
* this code compensates for that. This also provides compatibility with
* other AML interpreters.
*
******************************************************************************/
ACPI_STATUS
AcpiDsBuildInternalPackageObj (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
UINT32 ElementCount,
ACPI_OPERAND_OBJECT **ObjDescPtr)
{
ACPI_PARSE_OBJECT *Arg;
ACPI_PARSE_OBJECT *Parent;
ACPI_OPERAND_OBJECT *ObjDesc = NULL;
ACPI_STATUS Status = AE_OK;
UINT16 ReferenceCount;
UINT32 Index;
UINT32 i;
ACPI_FUNCTION_TRACE (DsBuildInternalPackageObj);
/* Find the parent of a possibly nested package */
Parent = Op->Common.Parent;
while ((Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
{
Parent = Parent->Common.Parent;
}
/*
* If we are evaluating a Named package object of the form:
* Name (xxxx, Package)
* the package object already exists, otherwise it must be created.
*/
ObjDesc = *ObjDescPtr;
if (!ObjDesc)
{
ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE);
*ObjDescPtr = ObjDesc;
if (!ObjDesc)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
ObjDesc->Package.Node = Parent->Common.Node;
}
if (ObjDesc->Package.Flags & AOPOBJ_DATA_VALID) /* Just in case */
{
return_ACPI_STATUS (AE_OK);
}
/*
* Allocate the element array (array of pointers to the individual
* objects) based on the NumElements parameter. Add an extra pointer slot
* so that the list is always null terminated.
*/
ObjDesc->Package.Elements = ACPI_ALLOCATE_ZEROED (
((ACPI_SIZE) ElementCount + 1) * sizeof (void *));
if (!ObjDesc->Package.Elements)
{
AcpiUtDeleteObjectDesc (ObjDesc);
return_ACPI_STATUS (AE_NO_MEMORY);
}
ObjDesc->Package.Count = ElementCount;
Arg = Op->Common.Value.Arg;
Arg = Arg->Common.Next;
if (Arg)
{
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
}
/*
* Initialize the elements of the package, up to the NumElements count.
* Package is automatically padded with uninitialized (NULL) elements
* if NumElements is greater than the package list length. Likewise,
* Package is truncated if NumElements is less than the list length.
*/
for (i = 0; Arg && (i < ElementCount); i++)
{
if (Arg->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP)
{
if (Arg->Common.Node->Type == ACPI_TYPE_METHOD)
{
/*
* A method reference "looks" to the parser to be a method
* invocation, so we special case it here
*/
Arg->Common.AmlOpcode = AML_INT_NAMEPATH_OP;
Status = AcpiDsBuildInternalObject (
WalkState, Arg, &ObjDesc->Package.Elements[i]);
}
else
{
/* This package element is already built, just get it */
ObjDesc->Package.Elements[i] =
ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node);
}
}
else
{
Status = AcpiDsBuildInternalObject (
WalkState, Arg, &ObjDesc->Package.Elements[i]);
if (Status == AE_NOT_FOUND)
{
ACPI_ERROR ((AE_INFO, "%-48s", "****DS namepath not found"));
}
/*
* Initialize this package element. This function handles the
* resolution of named references within the package.
*/
AcpiDsInitPackageElement (0, ObjDesc->Package.Elements[i],
NULL, &ObjDesc->Package.Elements[i]);
}
if (*ObjDescPtr)
{
/* Existing package, get existing reference count */
ReferenceCount = (*ObjDescPtr)->Common.ReferenceCount;
if (ReferenceCount > 1)
{
/* Make new element ref count match original ref count */
/* TBD: Probably need an AcpiUtAddReferences function */
for (Index = 0; Index < ((UINT32) ReferenceCount - 1); Index++)
{
AcpiUtAddReference ((ObjDesc->Package.Elements[i]));
}
}
}
Arg = Arg->Common.Next;
}
/* Check for match between NumElements and actual length of PackageList */
if (Arg)
{
/*
* NumElements was exhausted, but there are remaining elements in
* the PackageList. Truncate the package to NumElements.
*
* Note: technically, this is an error, from ACPI spec: "It is an
* error for NumElements to be less than the number of elements in
* the PackageList". However, we just print a message and no
* exception is returned. This provides compatibility with other
* ACPI implementations. Some firmware implementations will alter
* the NumElements on the fly, possibly creating this type of
* ill-formed package object.
*/
while (Arg)
{
/*
* We must delete any package elements that were created earlier
* and are not going to be used because of the package truncation.
*/
if (Arg->Common.Node)
{
AcpiUtRemoveReference (
ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node));
Arg->Common.Node = NULL;
}
/* Find out how many elements there really are */
i++;
Arg = Arg->Common.Next;
}
ACPI_INFO ((
"Actual Package length (%u) is larger than "
"NumElements field (%u), truncated",
i, ElementCount));
}
else if (i < ElementCount)
{
/*
* Arg list (elements) was exhausted, but we did not reach
* NumElements count.
*
* Note: this is not an error, the package is padded out
* with NULLs.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Package List length (%u) smaller than NumElements "
"count (%u), padded with null elements\n",
i, ElementCount));
}
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsInitPackageElement
*
* PARAMETERS: ACPI_PKG_CALLBACK
*
* RETURN: Status
*
* DESCRIPTION: Resolve a named reference element within a package object
*
******************************************************************************/
ACPI_STATUS
AcpiDsInitPackageElement (
UINT8 ObjectType,
ACPI_OPERAND_OBJECT *SourceObject,
ACPI_GENERIC_STATE *State,
void *Context)
{
ACPI_OPERAND_OBJECT **ElementPtr;
if (!SourceObject)
{
return (AE_OK);
}
/*
* The following code is a bit of a hack to workaround a (current)
* limitation of the ACPI_PKG_CALLBACK interface. We need a pointer
* to the location within the element array because a new object
* may be created and stored there.
*/
if (Context)
{
/* A direct call was made to this function */
ElementPtr = (ACPI_OPERAND_OBJECT **) Context;
}
else
{
/* Call came from AcpiUtWalkPackageTree */
ElementPtr = State->Pkg.ThisTargetObj;
}
/* We are only interested in reference objects/elements */
if (SourceObject->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)
{
/* Attempt to resolve the (named) reference to a namespace node */
AcpiDsResolvePackageElement (ElementPtr);
}
else if (SourceObject->Common.Type == ACPI_TYPE_PACKAGE)
{
SourceObject->Package.Flags |= AOPOBJ_DATA_VALID;
}
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsResolvePackageElement
*
* PARAMETERS: ElementPtr - Pointer to a reference object
*
* RETURN: Possible new element is stored to the indirect ElementPtr
*
* DESCRIPTION: Resolve a package element that is a reference to a named
* object.
*
******************************************************************************/
static void
AcpiDsResolvePackageElement (
ACPI_OPERAND_OBJECT **ElementPtr)
{
ACPI_STATUS Status;
ACPI_GENERIC_STATE ScopeInfo;
ACPI_OPERAND_OBJECT *Element = *ElementPtr;
ACPI_NAMESPACE_NODE *ResolvedNode;
char *ExternalPath = NULL;
ACPI_OBJECT_TYPE Type;
ACPI_FUNCTION_TRACE (DsResolvePackageElement);
/* Check if reference element is already resolved */
if (Element->Reference.Resolved)
{
return_VOID;
}
/* Element must be a reference object of correct type */
ScopeInfo.Scope.Node = Element->Reference.Node; /* Prefix node */
Status = AcpiNsLookup (&ScopeInfo,
(char *) Element->Reference.Aml, /* Pointer to AML path */
ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
NULL, &ResolvedNode);
if (ACPI_FAILURE (Status))
{
Status = AcpiNsExternalizeName (ACPI_UINT32_MAX,
(char *) Element->Reference.Aml,
NULL, &ExternalPath);
ACPI_EXCEPTION ((AE_INFO, Status,
"Could not find/resolve named package element: %s", ExternalPath));
ACPI_FREE (ExternalPath);
*ElementPtr = NULL;
return_VOID;
}
else if (ResolvedNode->Type == ACPI_TYPE_ANY)
{
/* Named reference not resolved, return a NULL package element */
ACPI_ERROR ((AE_INFO,
"Could not resolve named package element [%4.4s] in [%4.4s]",
ResolvedNode->Name.Ascii, ScopeInfo.Scope.Node->Name.Ascii));
*ElementPtr = NULL;
return_VOID;
}
#if 0
else if (ResolvedNode->Flags & ANOBJ_TEMPORARY)
{
/*
* A temporary node found here indicates that the reference is
* to a node that was created within this method. We are not
* going to allow it (especially if the package is returned
* from the method) -- the temporary node will be deleted out
* from under the method. (05/2017).
*/
ACPI_ERROR ((AE_INFO,
"Package element refers to a temporary name [%4.4s], "
"inserting a NULL element",
ResolvedNode->Name.Ascii));
*ElementPtr = NULL;
return_VOID;
}
#endif
/*
* Special handling for Alias objects. We need ResolvedNode to point
* to the Alias target. This effectively "resolves" the alias.
*/
if (ResolvedNode->Type == ACPI_TYPE_LOCAL_ALIAS)
{
ResolvedNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE,
ResolvedNode->Object);
}
/* Update the reference object */
Element->Reference.Resolved = TRUE;
Element->Reference.Node = ResolvedNode;
Type = Element->Reference.Node->Type;
/*
* Attempt to resolve the node to a value before we insert it into
* the package. If this is a reference to a common data type,
* resolve it immediately. According to the ACPI spec, package
* elements can only be "data objects" or method references.
* Attempt to resolve to an Integer, Buffer, String or Package.
* If cannot, return the named reference (for things like Devices,
* Methods, etc.) Buffer Fields and Fields will resolve to simple
* objects (int/buf/str/pkg).
*
* NOTE: References to things like Devices, Methods, Mutexes, etc.
* will remain as named references. This behavior is not described
* in the ACPI spec, but it appears to be an oversight.
*/
Status = AcpiExResolveNodeToValue (&ResolvedNode, NULL);
if (ACPI_FAILURE (Status))
{
return_VOID;
}
#if 0
/* TBD - alias support */
/*
* Special handling for Alias objects. We need to setup the type
* and the Op->Common.Node to point to the Alias target. Note,
* Alias has at most one level of indirection internally.
*/
Type = Op->Common.Node->Type;
if (Type == ACPI_TYPE_LOCAL_ALIAS)
{
Type = ObjDesc->Common.Type;
Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE,
Op->Common.Node->Object);
}
#endif
switch (Type)
{
/*
* These object types are a result of named references, so we will
* leave them as reference objects. In other words, these types
* have no intrinsic "value".
*/
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_THERMAL:
/* TBD: This may not be necesssary */
AcpiUtAddReference (ResolvedNode->Object);
break;
case ACPI_TYPE_MUTEX:
case ACPI_TYPE_METHOD:
case ACPI_TYPE_POWER:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_EVENT:
case ACPI_TYPE_REGION:
break;
default:
/*
* For all other types - the node was resolved to an actual
* operand object with a value, return the object
*/
*ElementPtr = (ACPI_OPERAND_OBJECT *) ResolvedNode;
break;
}
return_VOID;
}

61
source/components/executer/excreate.c
View File

@ -204,70 +204,39 @@ AcpiExCreateAlias (
}
/* Ensure that the target node is valid */
if (!TargetNode)
{
return_ACPI_STATUS (AE_NULL_OBJECT);
}
/*
* For objects that can never change (i.e., the NS node will
* permanently point to the same object), we can simply attach
* the object to the new NS node. For other objects (such as
* Integers, buffers, etc.), we have to point the Alias node
* to the original Node.
*/
/* Construct the alias object (a namespace node) */
switch (TargetNode->Type)
{
/* For these types, the sub-object can change dynamically via a Store */
case ACPI_TYPE_INTEGER:
case ACPI_TYPE_STRING:
case ACPI_TYPE_BUFFER:
case ACPI_TYPE_PACKAGE:
case ACPI_TYPE_BUFFER_FIELD:
/*
* These types open a new scope, so we need the NS node in order to access
* any children.
*/
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_POWER:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_THERMAL:
case ACPI_TYPE_LOCAL_SCOPE:
case ACPI_TYPE_METHOD:
/*
* Control method aliases need to be differentiated with
* a special type
*/
AliasNode->Type = ACPI_TYPE_LOCAL_METHOD_ALIAS;
break;
default:
/*
* All other object types.
*
* The new alias has the type ALIAS and points to the original
* NS node, not the object itself.
*/
AliasNode->Type = ACPI_TYPE_LOCAL_ALIAS;
AliasNode->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode);
break;
case ACPI_TYPE_METHOD:
/*
* Control method aliases need to be differentiated
*/
AliasNode->Type = ACPI_TYPE_LOCAL_METHOD_ALIAS;
AliasNode->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode);
break;
default:
/* Attach the original source object to the new Alias Node */
/*
* The new alias assumes the type of the target, and it points
* to the same object. The reference count of the object has an
* additional reference to prevent deletion out from under either the
* target node or the alias Node
*/
Status = AcpiNsAttachObject (AliasNode,
AcpiNsGetAttachedObject (TargetNode), TargetNode->Type);
break;
}
/* Since both operands are Nodes, we don't need to delete them */
AliasNode->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode);
return_ACPI_STATUS (Status);
}

41
source/components/executer/exdump.c
View File

@ -229,7 +229,7 @@ static ACPI_EXDUMP_INFO AcpiExDumpPackage[6] =
{ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpPackage), NULL},
{ACPI_EXD_NODE, ACPI_EXD_OFFSET (Package.Node), "Parent Node"},
{ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Package.Flags), "Flags"},
{ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Package.Count), "Elements"},
{ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Package.Count), "Element Count"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Package.Elements), "Element List"},
{ACPI_EXD_PACKAGE, 0, NULL}
};
@ -510,6 +510,11 @@ AcpiExDumpObject (
while (Count)
{
if (!ObjDesc)
{
return;
}
Target = ACPI_ADD_PTR (UINT8, ObjDesc, Info->Offset);
Name = Info->Name;
@ -522,7 +527,8 @@ AcpiExDumpObject (
case ACPI_EXD_TYPE:
AcpiOsPrintf ("%20s : %2.2X [%s]\n", "Type",
ObjDesc->Common.Type, AcpiUtGetObjectTypeName (ObjDesc));
ObjDesc->Common.Type,
AcpiUtGetObjectTypeName (ObjDesc));
break;
case ACPI_EXD_UINT8:
@ -588,10 +594,10 @@ AcpiExDumpObject (
Start = *ACPI_CAST_PTR (void *, Target);
Next = Start;
AcpiOsPrintf ("%20s : %p", Name, Next);
AcpiOsPrintf ("%20s : %p ", Name, Next);
if (Next)
{
AcpiOsPrintf ("(%s %2.2X)",
AcpiOsPrintf ("%s (Type %2.2X)",
AcpiUtGetObjectTypeName (Next), Next->Common.Type);
while (Next->Common.NextObject)
@ -614,6 +620,10 @@ AcpiExDumpObject (
}
}
}
else
{
AcpiOsPrintf ("- No attached objects");
}
AcpiOsPrintf ("\n");
break;
@ -1294,7 +1304,8 @@ AcpiExDumpPackageObj (
default:
AcpiOsPrintf ("[Unknown Type] %X\n", ObjDesc->Common.Type);
AcpiOsPrintf ("[%s] Type: %2.2X\n",
AcpiUtGetTypeName (ObjDesc->Common.Type), ObjDesc->Common.Type);
break;
}
}
@ -1338,10 +1349,19 @@ AcpiExDumpObjectDescriptor (
{
AcpiExDumpNamespaceNode ((ACPI_NAMESPACE_NODE *) ObjDesc, Flags);
AcpiOsPrintf ("\nAttached Object (%p):\n",
((ACPI_NAMESPACE_NODE *) ObjDesc)->Object);
ObjDesc = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Object;
if (!ObjDesc)
{
return_VOID;
}
AcpiOsPrintf ("\nAttached Object %p", ObjDesc);
if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED)
{
AcpiOsPrintf (" - Namespace Node");
}
AcpiOsPrintf (":\n");
goto DumpObject;
}
@ -1365,6 +1385,11 @@ AcpiExDumpObjectDescriptor (
DumpObject:
if (!ObjDesc)
{
return_VOID;
}
/* Common Fields */
AcpiExDumpObject (ObjDesc, AcpiExDumpCommon);

9
source/components/executer/exmisc.c
View File

@ -401,6 +401,8 @@ AcpiExDoLogicalNumericOp (
default:
ACPI_ERROR ((AE_INFO,
"Invalid numeric logical opcode: %X", Opcode));
Status = AE_AML_INTERNAL;
break;
}
@ -486,6 +488,9 @@ AcpiExDoLogicalOp (
default:
ACPI_ERROR ((AE_INFO,
"Invalid object type for logical operator: %X",
Operand0->Common.Type));
Status = AE_AML_INTERNAL;
break;
}
@ -535,6 +540,8 @@ AcpiExDoLogicalOp (
default:
ACPI_ERROR ((AE_INFO,
"Invalid comparison opcode: %X", Opcode));
Status = AE_AML_INTERNAL;
break;
}
@ -613,6 +620,8 @@ AcpiExDoLogicalOp (
default:
ACPI_ERROR ((AE_INFO,
"Invalid comparison opcode: %X", Opcode));
Status = AE_AML_INTERNAL;
break;
}

2
source/components/executer/exoparg2.c
View File

@ -556,6 +556,8 @@ AcpiExOpcode_2A_1T_1R (
default:
ACPI_ERROR ((AE_INFO,
"Invalid object type: %X", (Operand[0])->Common.Type));
Status = AE_AML_INTERNAL;
goto Cleanup;
}

2
source/components/hardware/hwregs.c
View File

@ -228,7 +228,7 @@ AcpiHwGetAccessBitWidth (
}
else if (Reg->AccessWidth)
{
AccessBitWidth = (1 << (Reg->AccessWidth + 2));
AccessBitWidth = ACPI_ACCESS_BIT_WIDTH (Reg->AccessWidth);
}
else
{

19
source/components/namespace/nsaccess.c
View File

@ -410,6 +410,7 @@ AcpiNsLookup (
{
ACPI_STATUS Status;
char *Path = Pathname;
char *ExternalPath;
ACPI_NAMESPACE_NODE *PrefixNode;
ACPI_NAMESPACE_NODE *CurrentNode = NULL;
ACPI_NAMESPACE_NODE *ThisNode = NULL;
@ -556,11 +557,21 @@ AcpiNsLookup (
ThisNode = ThisNode->Parent;
if (!ThisNode)
{
/* Current scope has no parent scope */
/*
* Current scope has no parent scope. Externalize
* the internal path for error message.
*/
Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, Pathname,
NULL, &ExternalPath);
if (ACPI_SUCCESS (Status))
{
ACPI_ERROR ((AE_INFO,
"%s: Path has too many parent prefixes (^)",
ExternalPath));
ACPI_FREE (ExternalPath);
}
ACPI_ERROR ((AE_INFO,
"%s: Path has too many parent prefixes (^) "
"- reached beyond root node", Pathname));
return_ACPI_STATUS (AE_NOT_FOUND);
}
}

22
source/components/namespace/nsarguments.c
View File

@ -183,9 +183,14 @@ AcpiNsCheckArgumentTypes (
UINT32 i;
/* If not a predefined name, cannot typecheck args */
if (!Info->Predefined)
/*
* If not a predefined name, cannot typecheck args, because
* we have no idea what argument types are expected.
* Also, ignore typecheck if warnings/errors if this method
* has already been evaluated at least once -- in order
* to suppress repetitive messages.
*/
if (!Info->Predefined || (Info->Node->Flags & ANOBJ_EVALUATED))
{
return;
}
@ -207,6 +212,10 @@ AcpiNsCheckArgumentTypes (
"Found [%s], ACPI requires [%s]", (i + 1),
AcpiUtGetTypeName (UserArgType),
AcpiUtGetTypeName (ArgType)));
/* Prevent any additional typechecking for this method */
Info->Node->Flags |= ANOBJ_EVALUATED;
}
}
}
@ -238,7 +247,7 @@ AcpiNsCheckAcpiCompliance (
UINT32 RequiredParamCount;
if (!Predefined)
if (!Predefined || (Node->Flags & ANOBJ_EVALUATED))
{
return;
}
@ -332,6 +341,11 @@ AcpiNsCheckArgumentCount (
UINT32 RequiredParamCount;
if (Node->Flags & ANOBJ_EVALUATED)
{
return;
}
if (!Predefined)
{
/*

14
source/components/namespace/nsinit.c
View File

@ -535,6 +535,20 @@ AcpiNsInitOneObject (
Info->PackageInit++;
Status = AcpiDsGetPackageArguments (ObjDesc);
if (ACPI_FAILURE (Status))
{
break;
}
/*
* Resolve all named references in package objects (and all
* sub-packages). This action has been deferred until the entire
* namespace has been loaded, in order to support external and
* forward references from individual package elements (05/2017).
*/
Status = AcpiUtWalkPackageTree (ObjDesc, NULL,
AcpiDsInitPackageElement, NULL);
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
break;
default:

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

@ -208,8 +208,15 @@ AcpiNsGetPathnameLength (
ACPI_SIZE Size;
ACPI_FUNCTION_ENTRY ();
/* Validate the Node */
if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
{
ACPI_ERROR ((AE_INFO,
"Invalid/cached reference target node: %p, descriptor type %d",
Node, ACPI_GET_DESCRIPTOR_TYPE (Node)));
return (0);
}
Size = AcpiNsBuildNormalizedPath (Node, NULL, 0, FALSE);
return (Size);

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

@ -722,6 +722,8 @@ AcpiNsCheckPackageList (
default: /* Should not get here, type was validated by caller */
ACPI_ERROR ((AE_INFO, "Invalid Package type: %X",
Package->RetInfo.Type));
return (AE_AML_INTERNAL);
}

10
source/components/parser/psloop.c
View File

@ -282,6 +282,9 @@ AcpiPsGetArguments (
INCREMENT_ARG_LIST (WalkState->ArgTypes);
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Final argument count: %u pass %u\n",
WalkState->ArgCount, WalkState->PassNumber));
/*
* Handle executable code at "module-level". This refers to
@ -380,6 +383,10 @@ AcpiPsGetArguments (
(Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
(WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
{
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Setup Package/Buffer: Pass %u, AML Ptr: %p\n",
WalkState->PassNumber, AmlOpStart));
/*
* Skip parsing of Buffers and Packages because we don't have
* enough info in the first pass to parse them correctly.
@ -689,6 +696,9 @@ AcpiPsParseLoop (
/* Check for arguments that need to be processed */
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Parseloop: argument count: %u\n", WalkState->ArgCount));
if (WalkState->ArgCount)
{
/*

7
source/components/resources/rsxface.c
View File

@ -796,7 +796,7 @@ ACPI_EXPORT_SYMBOL (AcpiWalkResourceBuffer)
* device we are querying
* Name - Method name of the resources we want.
* (METHOD_NAME__CRS, METHOD_NAME__PRS, or
* METHOD_NAME__AEI)
* METHOD_NAME__AEI or METHOD_NAME__DMA)
* UserFunction - Called for each resource
* Context - Passed to UserFunction
*
@ -827,12 +827,13 @@ AcpiWalkResources (
if (!DeviceHandle || !UserFunction || !Name ||
(!ACPI_COMPARE_NAME (Name, METHOD_NAME__CRS) &&
!ACPI_COMPARE_NAME (Name, METHOD_NAME__PRS) &&
!ACPI_COMPARE_NAME (Name, METHOD_NAME__AEI)))
!ACPI_COMPARE_NAME (Name, METHOD_NAME__AEI) &&
!ACPI_COMPARE_NAME (Name, METHOD_NAME__DMA)))
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* Get the _CRS/_PRS/_AEI resource list */
/* Get the _CRS/_PRS/_AEI/_DMA resource list */
Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
Status = AcpiRsGetMethodData (DeviceHandle, Name, &Buffer);

2
source/components/tables/tbdata.c
View File

@ -648,6 +648,8 @@ AcpiTbCheckDuplication (
*
* DESCRIPTION: This function is called to validate and verify the table, the
* returned table descriptor is in "VALIDATED" state.
* Note that 'TableIndex' is required to be set to !NULL to
* enable duplication check.
*
*****************************************************************************/

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

@ -293,7 +293,7 @@ AcpiReallocateRootTable (
{
ACPI_STATUS Status;
ACPI_TABLE_DESC *TableDesc;
UINT32 i;
UINT32 i, j;
ACPI_FUNCTION_TRACE (AcpiReallocateRootTable);
@ -339,7 +339,7 @@ AcpiReallocateRootTable (
TableDesc = &AcpiGbl_RootTableList.Tables[i];
if (!(TableDesc->Flags & ACPI_TABLE_IS_VERIFIED))
{
Status = AcpiTbVerifyTempTable (TableDesc, NULL, NULL);
Status = AcpiTbVerifyTempTable (TableDesc, NULL, &j);
if (ACPI_FAILURE (Status))
{
AcpiTbUninstallTable (TableDesc);

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

@ -762,7 +762,7 @@ strstr (
char *String1,
char *String2)
{
UINT32 Length;
ACPI_SIZE Length;
Length = strlen (String2);

4
source/components/utilities/uthex.c
View File

@ -183,8 +183,10 @@ AcpiUtHexToAsciiChar (
UINT64 Integer,
UINT32 Position)
{
UINT64 Index;
return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]);
AcpiUtShortShiftRight (Integer, Position, &Index);
return (AcpiGbl_HexToAscii[Index & 0xF]);
}

261
source/components/utilities/utmath.c
View File

@ -156,16 +156,6 @@
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utmath")
/*
* Optional support for 64-bit double-precision integer divide. This code
* is configurable and is implemented in order to support 32-bit kernel
* environments where a 64-bit double-precision math library is not available.
*
* Support for a more normal 64-bit divide/modulo (with check for a divide-
* by-zero) appears after this optional section of code.
*/
#ifndef ACPI_USE_NATIVE_DIVIDE
/* Structures used only for 64-bit divide */
typedef struct uint64_struct
@ -182,6 +172,257 @@ typedef union uint64_overlay
} UINT64_OVERLAY;
/*
* Optional support for 64-bit double-precision integer multiply and shift.
* This code is configurable and is implemented in order to support 32-bit
* kernel environments where a 64-bit double-precision math library is not
* available.
*/
#ifndef ACPI_USE_NATIVE_MATH64
/*******************************************************************************
*
* FUNCTION: AcpiUtShortMultiply
*
* PARAMETERS: Multiplicand - 64-bit multiplicand
* Multiplier - 32-bit multiplier
* OutProduct - Pointer to where the product is returned
*
* DESCRIPTION: Perform a short multiply.
*
******************************************************************************/
ACPI_STATUS
AcpiUtShortMultiply (
UINT64 Multiplicand,
UINT32 Multiplier,
UINT64 *OutProduct)
{
UINT64_OVERLAY MultiplicandOvl;
UINT64_OVERLAY Product;
UINT32 Carry32;
ACPI_FUNCTION_TRACE (UtShortMultiply);
MultiplicandOvl.Full = Multiplicand;
/*
* The Product is 64 bits, the carry is always 32 bits,
* and is generated by the second multiply.
*/
ACPI_MUL_64_BY_32 (0, MultiplicandOvl.Part.Hi, Multiplier,
Product.Part.Hi, Carry32);
ACPI_MUL_64_BY_32 (0, MultiplicandOvl.Part.Lo, Multiplier,
Product.Part.Lo, Carry32);
Product.Part.Hi += Carry32;
/* Return only what was requested */
if (OutProduct)
{
*OutProduct = Product.Full;
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtShortShiftLeft
*
* PARAMETERS: Operand - 64-bit shift operand
* Count - 32-bit shift count
* OutResult - Pointer to where the result is returned
*
* DESCRIPTION: Perform a short left shift.
*
******************************************************************************/
ACPI_STATUS
AcpiUtShortShiftLeft (
UINT64 Operand,
UINT32 Count,
UINT64 *OutResult)
{
UINT64_OVERLAY OperandOvl;
ACPI_FUNCTION_TRACE (UtShortShiftLeft);
OperandOvl.Full = Operand;
if ((Count & 63) >= 32)
{
OperandOvl.Part.Hi = OperandOvl.Part.Lo;
OperandOvl.Part.Lo ^= OperandOvl.Part.Lo;
Count = (Count & 63) - 32;
}
ACPI_SHIFT_LEFT_64_BY_32 (OperandOvl.Part.Hi,
OperandOvl.Part.Lo, Count);
/* Return only what was requested */
if (OutResult)
{
*OutResult = OperandOvl.Full;
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtShortShiftRight
*
* PARAMETERS: Operand - 64-bit shift operand
* Count - 32-bit shift count
* OutResult - Pointer to where the result is returned
*
* DESCRIPTION: Perform a short right shift.
*
******************************************************************************/
ACPI_STATUS
AcpiUtShortShiftRight (
UINT64 Operand,
UINT32 Count,
UINT64 *OutResult)
{
UINT64_OVERLAY OperandOvl;
ACPI_FUNCTION_TRACE (UtShortShiftRight);
OperandOvl.Full = Operand;
if ((Count & 63) >= 32)
{
OperandOvl.Part.Lo = OperandOvl.Part.Hi;
OperandOvl.Part.Hi ^= OperandOvl.Part.Hi;
Count = (Count & 63) - 32;
}
ACPI_SHIFT_RIGHT_64_BY_32 (OperandOvl.Part.Hi,
OperandOvl.Part.Lo, Count);
/* Return only what was requested */
if (OutResult)
{
*OutResult = OperandOvl.Full;
}
return_ACPI_STATUS (AE_OK);
}
#else
/*******************************************************************************
*
* FUNCTION: AcpiUtShortMultiply
*
* PARAMETERS: See function headers above
*
* DESCRIPTION: Native version of the UtShortMultiply function.
*
******************************************************************************/
ACPI_STATUS
AcpiUtShortMultiply (
UINT64 Multiplicand,
UINT32 Multiplier,
UINT64 *OutProduct)
{
ACPI_FUNCTION_TRACE (UtShortMultiply);
/* Return only what was requested */
if (OutProduct)
{
*OutProduct = Multiplicand * Multiplier;
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtShortShiftLeft
*
* PARAMETERS: See function headers above
*
* DESCRIPTION: Native version of the UtShortShiftLeft function.
*
******************************************************************************/
ACPI_STATUS
AcpiUtShortShiftLeft (
UINT64 Operand,
UINT32 Count,
UINT64 *OutResult)
{
ACPI_FUNCTION_TRACE (UtShortShiftLeft);
/* Return only what was requested */
if (OutResult)
{
*OutResult = Operand << Count;
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtShortShiftRight
*
* PARAMETERS: See function headers above
*
* DESCRIPTION: Native version of the UtShortShiftRight function.
*
******************************************************************************/
ACPI_STATUS
AcpiUtShortShiftRight (
UINT64 Operand,
UINT32 Count,
UINT64 *OutResult)
{
ACPI_FUNCTION_TRACE (UtShortShiftRight);
/* Return only what was requested */
if (OutResult)
{
*OutResult = Operand >> Count;
}
return_ACPI_STATUS (AE_OK);
}
#endif
/*
* Optional support for 64-bit double-precision integer divide. This code
* is configurable and is implemented in order to support 32-bit kernel
* environments where a 64-bit double-precision math library is not available.
*
* Support for a more normal 64-bit divide/modulo (with check for a divide-
* by-zero) appears after this optional section of code.
*/
#ifndef ACPI_USE_NATIVE_DIVIDE
/*******************************************************************************
*

13
source/components/utilities/utmisc.c
View File

@ -363,7 +363,7 @@ AcpiUtCreateUpdateStateAndPush (
*
* RETURN: Status
*
* DESCRIPTION: Walk through a package
* DESCRIPTION: Walk through a package, including subpackages
*
******************************************************************************/
@ -377,8 +377,8 @@ AcpiUtWalkPackageTree (
ACPI_STATUS Status = AE_OK;
ACPI_GENERIC_STATE *StateList = NULL;
ACPI_GENERIC_STATE *State;
UINT32 ThisIndex;
ACPI_OPERAND_OBJECT *ThisSourceObj;
UINT32 ThisIndex;
ACPI_FUNCTION_TRACE (UtWalkPackageTree);
@ -395,8 +395,10 @@ AcpiUtWalkPackageTree (
/* Get one element of the package */
ThisIndex = State->Pkg.Index;
ThisSourceObj = (ACPI_OPERAND_OBJECT *)
ThisSourceObj =
State->Pkg.SourceObject->Package.Elements[ThisIndex];
State->Pkg.ThisTargetObj =
&State->Pkg.SourceObject->Package.Elements[ThisIndex];
/*
* Check for:
@ -412,7 +414,7 @@ AcpiUtWalkPackageTree (
(ThisSourceObj->Common.Type != ACPI_TYPE_PACKAGE))
{
Status = WalkCallback (ACPI_COPY_TYPE_SIMPLE, ThisSourceObj,
State, Context);
State, Context);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -485,6 +487,9 @@ AcpiUtWalkPackageTree (
/* We should never get here */
ACPI_ERROR ((AE_INFO,
"State list did not terminate correctly"));
return_ACPI_STATUS (AE_AML_INTERNAL);
}

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

@ -651,6 +651,10 @@ AcpiUtGetSimpleObjectSize (
{
/* A namespace node should never get here */
ACPI_ERROR ((AE_INFO,
"Received a namespace node [%4.4s] "
"where an operand object is required",
ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, InternalObject)->Name.Ascii));
return_ACPI_STATUS (AE_AML_INTERNAL);
}

8
source/components/utilities/utprint.c
View File

@ -331,7 +331,7 @@ AcpiUtScanNumber (
while (isdigit ((int) *String))
{
Number *= 10;
AcpiUtShortMultiply (Number, 10, &Number);
Number += *(String++) - '0';
}
@ -463,7 +463,7 @@ AcpiUtFormatNumber (
/* Generate full string in reverse order */
Pos = AcpiUtPutNumber (ReversedString, Number, Base, Upper);
i = ACPI_PTR_DIFF (Pos, ReversedString);
i = (INT32) ACPI_PTR_DIFF (Pos, ReversedString);
/* Printing 100 using %2d gives "100", not "00" */
@ -695,7 +695,7 @@ vsnprintf (
{
s = "<NULL>";
}
Length = AcpiUtBoundStringLength (s, Precision);
Length = (INT32) AcpiUtBoundStringLength (s, Precision);
if (!(Type & ACPI_FORMAT_LEFT))
{
while (Length < Width--)
@ -815,7 +815,7 @@ vsnprintf (
}
}
return (ACPI_PTR_DIFF (Pos, String));
return ((int) ACPI_PTR_DIFF (Pos, String));
}

11
source/components/utilities/utresrc.c
View File

@ -360,14 +360,11 @@ AcpiUtWalkAmlResources (
}
/*
* The EndTag opcode must be followed by a zero byte.
* Although this byte is technically defined to be a checksum,
* in practice, all ASL compilers set this byte to zero.
* Don't attempt to perform any validation on the 2nd byte.
* Although all known ASL compilers insert a zero for the 2nd
* byte, it can also be a checksum (as per the ACPI spec),
* and this is occasionally seen in the field. July 2017.
*/
if (*(Aml + 1) != 0)
{
return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
}
/* Return the pointer to the EndTag if requested */

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

@ -363,7 +363,7 @@ ACPI_GENERIC_STATE *
AcpiUtCreatePkgState (
void *InternalObject,
void *ExternalObject,
UINT16 Index)
UINT32 Index)
{
ACPI_GENERIC_STATE *State;

8
source/components/utilities/utstrtoul64.c
View File

@ -419,8 +419,8 @@ AcpiUtStrtoulBase10 (
/* Convert and insert (add) the decimal digit */
NextValue =
(ReturnValue * 10) + (AsciiDigit - ACPI_ASCII_ZERO);
AcpiUtShortMultiply (ReturnValue, 10, &NextValue);
NextValue += (AsciiDigit - ACPI_ASCII_ZERO);
/* Check for overflow (32 or 64 bit) - return current converted value */
@ -486,8 +486,8 @@ AcpiUtStrtoulBase16 (
/* Convert and insert the hex digit */
ReturnValue =
(ReturnValue << 4) | AcpiUtAsciiCharToHex (AsciiDigit);
AcpiUtShortShiftLeft (ReturnValue, 4, &ReturnValue);
ReturnValue |= AcpiUtAsciiCharToHex (AsciiDigit);
String++;
ValidDigits++;

10
source/components/utilities/uttrack.c
View File

@ -776,6 +776,11 @@ AcpiUtDumpAllocations (
return_VOID;
}
if (!AcpiGbl_GlobalList)
{
goto Exit;
}
Element = AcpiGbl_GlobalList->ListHead;
while (Element)
{
@ -787,7 +792,7 @@ AcpiUtDumpAllocations (
if (Element->Size < sizeof (ACPI_COMMON_DESCRIPTOR))
{
AcpiOsPrintf ("%p Length 0x%04X %9.9s-%u "
AcpiOsPrintf ("%p Length 0x%04X %9.9s-%4.4u "
"[Not a Descriptor - too small]\n",
Descriptor, Element->Size, Element->Module,
Element->Line);
@ -799,7 +804,7 @@ AcpiUtDumpAllocations (
if (ACPI_GET_DESCRIPTOR_TYPE (Descriptor) !=
ACPI_DESC_TYPE_CACHED)
{
AcpiOsPrintf ("%p Length 0x%04X %9.9s-%u [%s] ",
AcpiOsPrintf ("%p Length 0x%04X %9.9s-%4.4u [%s] ",
Descriptor, Element->Size, Element->Module,
Element->Line, AcpiUtGetDescriptorName (Descriptor));
@ -875,6 +880,7 @@ AcpiUtDumpAllocations (
Element = Element->Next;
}
Exit:
(void) AcpiUtReleaseMutex (ACPI_MTX_MEMORY);
/* Print summary */

2
source/include/acdisasm.h
View File

@ -271,6 +271,7 @@ typedef enum
ACPI_DMT_PCCT,
ACPI_DMT_PMTT,
ACPI_DMT_PPTT,
ACPI_DMT_SDEI,
ACPI_DMT_SLIC,
ACPI_DMT_SRAT,
@ -527,6 +528,7 @@ extern ACPI_DMTABLE_INFO AcpiDmTableInfoS3ptHdr[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoS3pt0[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoS3pt1[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoSbst[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoSdei[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoSlic[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoSlit[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoSpcr[];

17
source/include/acdispat.h
View File

@ -409,6 +409,12 @@ AcpiDsInitializeObjects (
* dsobject - Parser/Interpreter interface - object initialization and conversion
*/
ACPI_STATUS
AcpiDsBuildInternalObject (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
ACPI_OPERAND_OBJECT **ObjDescPtr);
ACPI_STATUS
AcpiDsBuildInternalBufferObj (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
@ -436,6 +442,17 @@ AcpiDsCreateNode (
ACPI_PARSE_OBJECT *Op);
/*
* dspkginit - Package object initialization
*/
ACPI_STATUS
AcpiDsInitPackageElement (
UINT8 ObjectType,
ACPI_OPERAND_OBJECT *SourceObject,
ACPI_GENERIC_STATE *State,
void *Context);
/*
* dsutils - Parser/Interpreter interface utility routines
*/

2
source/include/aclocal.h
View File

@ -813,7 +813,7 @@ typedef struct acpi_update_state
typedef struct acpi_pkg_state
{
ACPI_STATE_COMMON
UINT16 Index;
UINT32 Index;
union acpi_operand_object *SourceObject;
union acpi_operand_object *DestObject;
struct acpi_walk_state *WalkState;

1
source/include/acnames.h
View File

@ -162,6 +162,7 @@
#define METHOD_NAME__CLS "_CLS"
#define METHOD_NAME__CRS "_CRS"
#define METHOD_NAME__DDN "_DDN"
#define METHOD_NAME__DMA "_DMA"
#define METHOD_NAME__HID "_HID"
#define METHOD_NAME__INI "_INI"
#define METHOD_NAME__PLD "_PLD"

4
source/include/acobject.h
View File

@ -546,11 +546,12 @@ typedef struct acpi_object_reference
ACPI_OBJECT_COMMON_HEADER
UINT8 Class; /* Reference Class */
UINT8 TargetType; /* Used for Index Op */
UINT8 Reserved;
UINT8 Resolved; /* Reference has been resolved to a value */
void *Object; /* NameOp=>HANDLE to obj, IndexOp=>ACPI_OPERAND_OBJECT */
ACPI_NAMESPACE_NODE *Node; /* RefOf or Namepath */
union acpi_operand_object **Where; /* Target of Index */
UINT8 *IndexPointer; /* Used for Buffers and Strings */
UINT8 *Aml; /* Used for deferred resolution of the ref */
UINT32 Value; /* Used for Local/Arg/Index/DdbHandle */
} ACPI_OBJECT_REFERENCE;
@ -571,7 +572,6 @@ typedef enum
} ACPI_REFERENCE_CLASSES;
/*
* Extra object is used as additional storage for types that
* have AML code in their declarations (TermArgs) that must be

4
source/include/acpi.h
View File

@ -162,14 +162,14 @@
* Note: The order of these include files is important.
*/
#include "platform/acenv.h" /* Environment-specific items */
#include "acnames.h" /* Common ACPI names and strings */
#include "actypes.h" /* ACPICA data types and structures */
#include "platform/acenvex.h" /* Extra environment-specific items */
#include "acnames.h" /* Common ACPI names and strings */
#include "acexcep.h" /* ACPICA exceptions */
#include "actbl.h" /* ACPI table definitions */
#include "acoutput.h" /* Error output and Debug macros */
#include "acrestyp.h" /* Resource Descriptor structs */
#include "acpiosxf.h" /* OSL interfaces (ACPICA-to-OS) */
#include "acpixf.h" /* ACPI core subsystem external interfaces */
#include "platform/acenvex.h" /* Extra environment-specific items */
#endif /* __ACPI_H__ */

2
source/include/acpixf.h
View File

@ -154,7 +154,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20170629
#define ACPI_CA_VERSION 0x20170728
#include "acconfig.h"
#include "actypes.h"

16
source/include/actbl2.h
View File

@ -186,6 +186,7 @@
#define ACPI_SIG_MCHI "MCHI" /* Management Controller Host Interface table */
#define ACPI_SIG_MSDM "MSDM" /* Microsoft Data Management Table */
#define ACPI_SIG_MTMR "MTMR" /* MID Timer table */
#define ACPI_SIG_SDEI "SDEI" /* Software Delegated Exception Interface Table */
#define ACPI_SIG_SLIC "SLIC" /* Software Licensing Description Table */
#define ACPI_SIG_SPCR "SPCR" /* Serial Port Console Redirection table */
#define ACPI_SIG_SPMI "SPMI" /* Server Platform Management Interface table */
@ -1422,6 +1423,21 @@ typedef struct acpi_mtmr_entry
} ACPI_MTMR_ENTRY;
/*******************************************************************************
*
* SDEI - Software Delegated Exception Interface Descriptor Table
*
* Conforms to "Software Delegated Exception Interface (SDEI)" ARM DEN0054A,
* May 8th, 2017. Copyright 2017 ARM Ltd.
*
******************************************************************************/
typedef struct acpi_table_sdei
{
ACPI_TABLE_HEADER Header; /* Common ACPI table header */
} ACPI_TABLE_SDEI;
/*******************************************************************************
*

8
source/include/actypes.h
View File

@ -276,6 +276,7 @@ typedef UINT64 ACPI_PHYSICAL_ADDRESS;
#define ACPI_MAX_PTR ACPI_UINT64_MAX
#define ACPI_SIZE_MAX ACPI_UINT64_MAX
#define ACPI_USE_NATIVE_DIVIDE /* Has native 64-bit integer support */
#define ACPI_USE_NATIVE_MATH64 /* Has native 64-bit integer support */
/*
* In the case of the Itanium Processor Family (IPF), the hardware does not
@ -675,6 +676,13 @@ typedef UINT64 ACPI_INTEGER;
#define ACPI_VALIDATE_RSDP_SIG(a) (!strncmp (ACPI_CAST_PTR (char, (a)), ACPI_SIG_RSDP, 8))
#define ACPI_MAKE_RSDP_SIG(dest) (memcpy (ACPI_CAST_PTR (char, (dest)), ACPI_SIG_RSDP, 8))
/*
* Algorithm to obtain access bit width.
* Can be used with AccessWidth of ACPI_GENERIC_ADDRESS and AccessSize of
* ACPI_RESOURCE_GENERIC_REGISTER.
*/
#define ACPI_ACCESS_BIT_WIDTH(size) (1 << ((size) + 2))
/*******************************************************************************
*

20
source/include/acutils.h
View File

@ -845,7 +845,7 @@ ACPI_GENERIC_STATE *
AcpiUtCreatePkgState (
void *InternalObject,
void *ExternalObject,
UINT16 Index);
UINT32 Index);
ACPI_STATUS
AcpiUtCreateUpdateStateAndPush (
@ -879,6 +879,24 @@ AcpiUtShortDivide (
UINT64 *OutQuotient,
UINT32 *OutRemainder);
ACPI_STATUS
AcpiUtShortMultiply (
UINT64 InMultiplicand,
UINT32 Multiplier,
UINT64 *Outproduct);
ACPI_STATUS
AcpiUtShortShiftLeft (
UINT64 Operand,
UINT32 Count,
UINT64 *OutResult);
ACPI_STATUS
AcpiUtShortShiftRight (
UINT64 Operand,
UINT32 Count,
UINT64 *OutResult);
/*
* utmisc

1
source/include/platform/accygwin.h
View File

@ -180,6 +180,7 @@
#define COMPILER_DEPENDENT_INT64 long long
#define COMPILER_DEPENDENT_UINT64 unsigned long long
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#endif
#ifndef __cdecl

1
source/include/platform/acdragonfly.h
View File

@ -159,6 +159,7 @@
#else
#define ACPI_MACHINE_WIDTH 32
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#endif
#define ACPI_UINTPTR_T uintptr_t

70
source/include/platform/acefi.h
View File

@ -152,11 +152,24 @@
#ifndef __ACEFI_H__
#define __ACEFI_H__
/*
* Single threaded environment where Mutex/Event/Sleep are fake. This model is
* sufficient for pre-boot AcpiExec.
*/
#ifndef DEBUGGER_THREADING
#define DEBUGGER_THREADING DEBUGGER_SINGLE_THREADED
#endif /* !DEBUGGER_THREADING */
/* EDK2 EFI environemnt */
#if defined(_EDK2_EFI)
#define _GNU_EFI
#ifdef USE_STDLIB
#define ACPI_USE_STANDARD_HEADERS
#define ACPI_USE_SYSTEM_CLIBRARY
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#endif
#endif
@ -194,8 +207,10 @@
#endif
#ifndef USE_STDLIB
#define UINTN uint64_t
#define INTN int64_t
#endif
#define ACPI_EFI_ERR(a) (0x8000000000000000 | a)
@ -203,8 +218,10 @@
#define ACPI_MACHINE_WIDTH 32
#ifndef USE_STDLIB
#define UINTN uint32_t
#define INTN int32_t
#endif
#define ACPI_EFI_ERR(a) (0x80000000 | a)
@ -326,26 +343,59 @@ UINT64 efi_call10(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
#endif
/* GNU EFI definitions */
#if defined(_GNU_EFI)
/* EFI math64 definitions */
#if defined(_GNU_EFI) || defined(_EDK2_EFI)
/*
* Math helpers
* Math helpers, GNU EFI provided a platform independent 64-bit math
* support.
*/
#define ACPI_DIV_64_BY_32(n_hi, n_lo, d32, q32, r32) \
#ifndef ACPI_DIV_64_BY_32
#define ACPI_DIV_64_BY_32(n_hi, n_lo, d32, q32, r32) \
do { \
UINT64 __n = ((UINT64) n_hi) << 32 | (n_lo); \
(q32) = (UINT32) DivU64x32 ((__n), (d32), &(r32)); \
} while (0)
#endif
#ifndef ACPI_MUL_64_BY_32
#define ACPI_MUL_64_BY_32(n_hi, n_lo, m32, p32, c32) \
do { \
UINT64 __n = ((UINT64) n_hi) << 32 | (n_lo); \
(q32) = DivU64x32 ((__n), (d32), &(r32)); \
UINT64 __p = MultU64x32 (__n, (m32)); \
(p32) = (UINT32) __p; \
(c32) = (UINT32) (__p >> 32); \
} while (0)
#endif
#ifndef ACPI_SHIFT_LEFT_64_by_32
#define ACPI_SHIFT_LEFT_64_BY_32(n_hi, n_lo, s32) \
do { \
UINT64 __n = ((UINT64) n_hi) << 32 | (n_lo); \
UINT64 __r = LShiftU64 (__n, (s32)); \
(n_lo) = (UINT32) __r; \
(n_hi) = (UINT32) (__r >> 32); \
} while (0)
#endif
#ifndef ACPI_SHIFT_RIGHT_64_BY_32
#define ACPI_SHIFT_RIGHT_64_BY_32(n_hi, n_lo, s32) \
do { \
UINT64 __n = ((UINT64) n_hi) << 32 | (n_lo); \
UINT64 __r = RShiftU64 (__n, (s32)); \
(n_lo) = (UINT32) __r; \
(n_hi) = (UINT32) (__r >> 32); \
} while (0)
#endif
#ifndef ACPI_SHIFT_RIGHT_64
#define ACPI_SHIFT_RIGHT_64(n_hi, n_lo) \
do { \
(n_lo) >>= 1; \
(n_lo) |= (((n_hi) & 1) << 31); \
(n_hi) >>= 1; \
} while (0)
#endif
#endif
struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE;
@ -353,17 +403,21 @@ struct _ACPI_SIMPLE_INPUT_INTERFACE;
struct _ACPI_EFI_FILE_IO_INTERFACE;
struct _ACPI_EFI_FILE_HANDLE;
struct _ACPI_EFI_BOOT_SERVICES;
struct _ACPI_EFI_RUNTIME_SERVICES;
struct _ACPI_EFI_SYSTEM_TABLE;
struct _ACPI_EFI_PCI_IO;
extern struct _ACPI_EFI_SYSTEM_TABLE *ST;
extern struct _ACPI_EFI_BOOT_SERVICES *BS;
extern struct _ACPI_EFI_RUNTIME_SERVICES *RT;
#ifndef USE_STDLIB
typedef union acpi_efi_file ACPI_EFI_FILE;
#define FILE ACPI_EFI_FILE
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
#endif
#endif /* __ACEFI_H__ */

103
source/include/platform/acefiex.h
View File

@ -595,6 +595,11 @@ ACPI_EFI_STATUS
ACPI_EFI_HANDLE ImageHandle);
typedef
ACPI_EFI_STATUS
(ACPI_EFI_API *ACPI_EFI_STALL) (
UINTN Microseconds);
typedef
ACPI_EFI_STATUS
(ACPI_EFI_API *ACPI_EFI_SET_WATCHDOG_TIMER) (
@ -664,6 +669,27 @@ ACPI_EFI_STATUS
VOID *Buffer);
/*
* EFI Time
*/
typedef struct {
UINT32 Resolution;
UINT32 Accuracy;
BOOLEAN SetsToZero;
} ACPI_EFI_TIME_CAPABILITIES;
typedef
ACPI_EFI_STATUS
(ACPI_EFI_API *ACPI_EFI_GET_TIME) (
ACPI_EFI_TIME *Time,
ACPI_EFI_TIME_CAPABILITIES *Capabilities);
typedef
ACPI_EFI_STATUS
(ACPI_EFI_API *ACPI_EFI_SET_TIME) (
ACPI_EFI_TIME *Time);
/*
* Protocol handler functions
*/
@ -890,12 +916,11 @@ typedef struct _ACPI_EFI_BOOT_SERVICES {
#if 0
ACPI_EFI_EXIT_BOOT_SERVICES ExitBootServices;
ACPI_EFI_GET_NEXT_MONOTONIC_COUNT GetNextMonotonicCount;
ACPI_EFI_STALL Stall;
#else
ACPI_EFI_UNKNOWN_INTERFACE ExitBootServices;
ACPI_EFI_UNKNOWN_INTERFACE GetNextMonotonicCount;
ACPI_EFI_UNKNOWN_INTERFACE Stall;
#endif
ACPI_EFI_STALL Stall;
ACPI_EFI_SET_WATCHDOG_TIMER SetWatchdogTimer;
#if 0
@ -928,6 +953,54 @@ typedef struct _ACPI_EFI_BOOT_SERVICES {
} ACPI_EFI_BOOT_SERVICES;
/*
* EFI Runtime Services Table
*/
#define ACPI_EFI_RUNTIME_SERVICES_SIGNATURE 0x56524553544e5552
#define ACPI_EFI_RUNTIME_SERVICES_REVISION (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION)
typedef struct _ACPI_EFI_RUNTIME_SERVICES {
ACPI_EFI_TABLE_HEADER Hdr;
ACPI_EFI_GET_TIME GetTime;
ACPI_EFI_SET_TIME SetTime;
#if 0
ACPI_EFI_GET_WAKEUP_TIME GetWakeupTime;
ACPI_EFI_SET_WAKEUP_TIME SetWakeupTime;
#else
ACPI_EFI_UNKNOWN_INTERFACE GetWakeupTime;
ACPI_EFI_UNKNOWN_INTERFACE SetWakeupTime;
#endif
#if 0
ACPI_EFI_SET_VIRTUAL_ADDRESS_MAP SetVirtualAddressMap;
ACPI_EFI_CONVERT_POINTER ConvertPointer;
#else
ACPI_EFI_UNKNOWN_INTERFACE SetVirtualAddressMap;
ACPI_EFI_UNKNOWN_INTERFACE ConvertPointer;
#endif
#if 0
ACPI_EFI_GET_VARIABLE GetVariable;
ACPI_EFI_GET_NEXT_VARIABLE_NAME GetNextVariableName;
ACPI_EFI_SET_VARIABLE SetVariable;
#else
ACPI_EFI_UNKNOWN_INTERFACE GetVariable;
ACPI_EFI_UNKNOWN_INTERFACE GetNextVariableName;
ACPI_EFI_UNKNOWN_INTERFACE SetVariable;
#endif
#if 0
ACPI_EFI_GET_NEXT_HIGH_MONO_COUNT GetNextHighMonotonicCount;
ACPI_EFI_RESET_SYSTEM ResetSystem;
#else
ACPI_EFI_UNKNOWN_INTERFACE GetNextHighMonotonicCount;
ACPI_EFI_UNKNOWN_INTERFACE ResetSystem;
#endif
} ACPI_EFI_RUNTIME_SERVICES;
/*
* EFI System Table
*/
@ -964,11 +1037,7 @@ typedef struct _ACPI_EFI_SYSTEM_TABLE {
ACPI_EFI_HANDLE StandardErrorHandle;
ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE *StdErr;
#if 0
ACPI_EFI_RUNTIME_SERVICES *RuntimeServices;
#else
ACPI_EFI_HANDLE *RuntimeServices;
#endif
ACPI_EFI_BOOT_SERVICES *BootServices;
UINTN NumberOfTableEntries;
@ -1051,19 +1120,34 @@ union acpi_efi_file {
};
/* GNU EFI definitions */
/* EFI definitions */
#if defined(_GNU_EFI)
#if defined(_GNU_EFI) || defined(_EDK2_EFI)
/*
* This is needed to hide platform specific code from ACPICA
*/
UINT64
UINT64 ACPI_EFI_API
DivU64x32 (
UINT64 Dividend,
UINTN Divisor,
UINTN *Remainder);
UINT64 ACPI_EFI_API
MultU64x32 (
UINT64 Multiplicand,
UINTN Multiplier);
UINT64 ACPI_EFI_API
LShiftU64 (
UINT64 Operand,
UINTN Count);
UINT64 ACPI_EFI_API
RShiftU64 (
UINT64 Operand,
UINTN Count);
/*
* EFI specific prototypes
*/
@ -1077,7 +1161,6 @@ acpi_main (
int argc,
char *argv[]);
#endif
extern ACPI_EFI_GUID AcpiGbl_LoadedImageProtocol;

1
source/include/platform/acfreebsd.h
View File

@ -169,6 +169,7 @@
#define ACPI_USE_DO_WHILE_0
#define ACPI_USE_LOCAL_CACHE
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#define ACPI_USE_SYSTEM_CLIBRARY
#ifdef _KERNEL

4
source/include/platform/acgcc.h
View File

@ -192,4 +192,8 @@ typedef __builtin_va_list va_list;
#define COMPILER_VA_MACRO 1
/* GCC supports native multiply/shift on 32-bit platforms */
#define ACPI_USE_NATIVE_MATH64
#endif /* __ACGCC_H__ */

1
source/include/platform/achaiku.h
View File

@ -166,6 +166,7 @@ struct mutex;
#define ACPI_MUTEX struct mutex *
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
/* #define ACPI_THREAD_ID thread_id */

2
source/include/platform/aclinux.h
View File

@ -237,6 +237,7 @@
/* Host-dependent types and defines for in-kernel ACPICA */
#define ACPI_MACHINE_WIDTH BITS_PER_LONG
#define ACPI_USE_NATIVE_MATH64
#define ACPI_EXPORT_SYMBOL(symbol) EXPORT_SYMBOL(symbol);
#define strtoul simple_strtoul
@ -325,6 +326,7 @@
#define COMPILER_DEPENDENT_INT64 long long
#define COMPILER_DEPENDENT_UINT64 unsigned long long
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#endif
#ifndef __cdecl

84
source/include/platform/acmsvc.h
View File

@ -161,30 +161,6 @@
* out if these are actually defined.
*/
/*
* Map low I/O functions for MS. This allows us to disable MS language
* extensions for maximum portability.
*/
#define open _open
#define read _read
#define write _write
#define close _close
#define stat _stat
#define fstat _fstat
#define mkdir _mkdir
#define snprintf _snprintf
#if _MSC_VER <= 1200 /* Versions below VC++ 6 */
#define vsnprintf _vsnprintf
#endif
#define O_RDONLY _O_RDONLY
#define O_BINARY _O_BINARY
#define O_CREAT _O_CREAT
#define O_WRONLY _O_WRONLY
#define O_TRUNC _O_TRUNC
#define S_IREAD _S_IREAD
#define S_IWRITE _S_IWRITE
#define S_IFDIR _S_IFDIR
/* Eliminate warnings for "old" (non-secure) versions of clib functions */
#ifndef _CRT_SECURE_NO_WARNINGS
@ -217,11 +193,11 @@
/* Do not maintain the architecture specific stuffs for the EFI ports */
#if !defined(_EDK2_EFI) && !defined(_GNU_EFI)
#ifndef _LINT
#if defined(__i386__) && !defined(_GNU_EFI) && !defined(_EDK2_EFI)
/*
* Math helper functions
*/
#ifndef ACPI_DIV_64_BY_32
#define ACPI_DIV_64_BY_32(n_hi, n_lo, d32, q32, r32) \
{ \
__asm mov edx, n_hi \
@ -230,27 +206,53 @@
__asm mov q32, eax \
__asm mov r32, edx \
}
#endif
#ifndef ACPI_MUL_64_BY_32
#define ACPI_MUL_64_BY_32(n_hi, n_lo, m32, p32, c32) \
{ \
__asm mov edx, n_hi \
__asm mov eax, n_lo \
__asm mul m32 \
__asm mov p32, eax \
__asm mov c32, edx \
}
#endif
#ifndef ACPI_SHIFT_LEFT_64_BY_32
#define ACPI_SHIFT_LEFT_64_BY_32(n_hi, n_lo, s32) \
{ \
__asm mov edx, n_hi \
__asm mov eax, n_lo \
__asm mov ecx, s32 \
__asm and ecx, 31 \
__asm shld edx, eax, cl \
__asm shl eax, cl \
__asm mov n_hi, edx \
__asm mov n_lo, eax \
}
#endif
#ifndef ACPI_SHIFT_RIGHT_64_BY_32
#define ACPI_SHIFT_RIGHT_64_BY_32(n_hi, n_lo, s32) \
{ \
__asm mov edx, n_hi \
__asm mov eax, n_lo \
__asm mov ecx, s32 \
__asm and ecx, 31 \
__asm shrd eax, edx, cl \
__asm shr edx, cl \
__asm mov n_hi, edx \
__asm mov n_lo, eax \
}
#endif
#ifndef ACPI_SHIFT_RIGHT_64
#define ACPI_SHIFT_RIGHT_64(n_hi, n_lo) \
{ \
__asm shr n_hi, 1 \
__asm rcr n_lo, 1 \
}
#else
/* Fake versions to make lint happy */
#define ACPI_DIV_64_BY_32(n_hi, n_lo, d32, q32, r32) \
{ \
q32 = n_hi / d32; \
r32 = n_lo / d32; \
}
#define ACPI_SHIFT_RIGHT_64(n_hi, n_lo) \
{ \
n_hi >>= 1; \
n_lo >>= 1; \
}
#endif
#endif

2
source/include/platform/acnetbsd.h
View File

@ -178,6 +178,7 @@
#define asm __asm
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#define ACPI_SYSTEM_XFACE
#define ACPI_EXTERNAL_XFACE
@ -215,5 +216,6 @@
/* Always use NetBSD code over our local versions */
#define ACPI_USE_SYSTEM_CLIBRARY
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#endif /* __ACNETBSD_H__ */

1
source/include/platform/acos2.h
View File

@ -164,6 +164,7 @@
#define COMPILER_DEPENDENT_INT64 long long
#define COMPILER_DEPENDENT_UINT64 unsigned long long
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#define ACPI_SYSTEM_XFACE APIENTRY
#define ACPI_EXTERNAL_XFACE APIENTRY

1
source/include/platform/acqnx.h
View File

@ -174,5 +174,6 @@
#define __cdecl
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#endif /* __ACQNX_H__ */

26
source/include/platform/acwin.h
View File

@ -156,6 +156,8 @@
#define ACPI_USE_SYSTEM_CLIBRARY
#define ACPI_MACHINE_WIDTH 32
#define ACPI_USE_NATIVE_DIVIDE
#define ACPI_USE_NATIVE_MATH64
#ifdef ACPI_DEFINE_ALTERNATE_TYPES
/*
@ -170,6 +172,30 @@ typedef unsigned int u32;
typedef COMPILER_DEPENDENT_UINT64 u64;
#endif
/*
* Map low I/O functions for MS. This allows us to disable MS language
* extensions for maximum portability.
*/
#define open _open
#define read _read
#define write _write
#define close _close
#define stat _stat
#define fstat _fstat
#define mkdir _mkdir
#define snprintf _snprintf
#if _MSC_VER <= 1200 /* Versions below VC++ 6 */
#define vsnprintf _vsnprintf
#endif
#define O_RDONLY _O_RDONLY
#define O_BINARY _O_BINARY
#define O_CREAT _O_CREAT
#define O_WRONLY _O_WRONLY
#define O_TRUNC _O_TRUNC
#define S_IREAD _S_IREAD
#define S_IWRITE _S_IWRITE
#define S_IFDIR _S_IFDIR
/*
* Handle platform- and compiler-specific assembly language differences.

24
source/include/platform/acwin64.h
View File

@ -157,6 +157,30 @@
#define ACPI_MACHINE_WIDTH 64
/*
* Map low I/O functions for MS. This allows us to disable MS language
* extensions for maximum portability.
*/
#define open _open
#define read _read
#define write _write
#define close _close
#define stat _stat
#define fstat _fstat
#define mkdir _mkdir
#define snprintf _snprintf
#if _MSC_VER <= 1200 /* Versions below VC++ 6 */
#define vsnprintf _vsnprintf
#endif
#define O_RDONLY _O_RDONLY
#define O_BINARY _O_BINARY
#define O_CREAT _O_CREAT
#define O_WRONLY _O_WRONLY
#define O_TRUNC _O_TRUNC
#define S_IREAD _S_IREAD
#define S_IWRITE _S_IWRITE
#define S_IFDIR _S_IFDIR
/*
* Handle platform- and compiler-specific assembly language differences.
*

93
source/os_specific/service_layers/oslinuxtbl.c
View File

@ -988,7 +988,7 @@ OslListBiosTables (
/* Skip NULL entries in RSDT/XSDT */
if (!TableAddress)
if (TableAddress == 0)
{
continue;
}
@ -1041,7 +1041,8 @@ OslGetBiosTable (
UINT8 NumberOfTables;
UINT8 ItemSize;
UINT32 CurrentInstance = 0;
ACPI_PHYSICAL_ADDRESS TableAddress = 0;
ACPI_PHYSICAL_ADDRESS TableAddress;
ACPI_PHYSICAL_ADDRESS FirstTableAddress = 0;
UINT32 TableLength = 0;
ACPI_STATUS Status = AE_OK;
UINT32 i;
@ -1055,10 +1056,10 @@ OslGetBiosTable (
ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT) ||
ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
{
if (Instance > 0)
{
return (AE_LIMIT);
}
FindNextInstance:
TableAddress = 0;
/*
* Get the appropriate address, either 32-bit or 64-bit. Be very
@ -1067,28 +1068,34 @@ OslGetBiosTable (
*/
if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT))
{
if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XDSDT) &&
Gbl_Fadt->XDsdt)
if (CurrentInstance < 2)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XDsdt;
}
else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_DSDT) &&
Gbl_Fadt->Dsdt)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Dsdt;
if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XDSDT) &&
Gbl_Fadt->XDsdt && CurrentInstance == 0)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XDsdt;
}
else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_DSDT) &&
Gbl_Fadt->Dsdt != FirstTableAddress)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Dsdt;
}
}
}
else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
{
if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XFACS) &&
Gbl_Fadt->XFacs)
if (CurrentInstance < 2)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XFacs;
}
else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_FACS) &&
Gbl_Fadt->Facs)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Facs;
if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XFACS) &&
Gbl_Fadt->XFacs && CurrentInstance == 0)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XFacs;
}
else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_FACS) &&
Gbl_Fadt->Facs != FirstTableAddress)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Facs;
}
}
}
else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_XSDT))
@ -1097,16 +1104,32 @@ OslGetBiosTable (
{
return (AE_BAD_SIGNATURE);
}
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Rsdp.XsdtPhysicalAddress;
if (CurrentInstance == 0)
{
TableAddress =
(ACPI_PHYSICAL_ADDRESS) Gbl_Rsdp.XsdtPhysicalAddress;
}
}
else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_RSDT))
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Rsdp.RsdtPhysicalAddress;
if (CurrentInstance == 0)
{
TableAddress =
(ACPI_PHYSICAL_ADDRESS) Gbl_Rsdp.RsdtPhysicalAddress;
}
}
else
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_RsdpAddress;
Signature = ACPI_SIG_RSDP;
if (CurrentInstance == 0)
{
TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_RsdpAddress;
Signature = ACPI_SIG_RSDP;
}
}
if (TableAddress == 0)
{
goto ExitFindTable;
}
/* Now we can get the requested special table */
@ -1118,6 +1141,20 @@ OslGetBiosTable (
}
TableLength = ApGetTableLength (MappedTable);
if (FirstTableAddress == 0)
{
FirstTableAddress = TableAddress;
}
/* Match table instance */
if (CurrentInstance != Instance)
{
OslUnmapTable (MappedTable);
MappedTable = NULL;
CurrentInstance++;
goto FindNextInstance;
}
}
else /* Case for a normal ACPI table */
{
@ -1155,7 +1192,7 @@ OslGetBiosTable (
/* Skip NULL entries in RSDT/XSDT */
if (!TableAddress)
if (TableAddress == 0)
{
continue;
}
@ -1190,6 +1227,8 @@ OslGetBiosTable (
}
}
ExitFindTable:
if (!MappedTable)
{
return (AE_LIMIT);

2
source/tools/acpidump/apfiles.c
View File

@ -175,7 +175,7 @@ static int
ApIsExistingFile (
char *Pathname)
{
#ifndef _GNU_EFI
#if !defined(_GNU_EFI) && !defined(_EDK2_EFI)
struct stat StatInfo;

2
source/tools/acpidump/apmain.c
View File

@ -440,7 +440,7 @@ ApDoOptions (
*
******************************************************************************/
#ifndef _GNU_EFI
#if !defined(_GNU_EFI) && !defined(_EDK2_EFI)
int ACPI_SYSTEM_XFACE
main (
int argc,

1
source/tools/acpihelp/ahaslkey.c
View File

@ -295,6 +295,7 @@ const AH_DIRECTIVE_INFO Gbl_PreprocessorDirectives[] =
{"__PATH__", "Return the full pathname of the current ASL file"},
{"__LINE__", "Return the current line number within the current ASL file"},
{"__DATE__", "Return the current date"},
{"__METHOD__", "Return the declared name of the current control method"},
{"__IASL__", "Permanently defined for the iASL compiler"},
{NULL, NULL}
};

2
source/tools/efihello/efihello.c
View File

@ -169,7 +169,7 @@ static char LineBuffer[LINE_SIZE];
*
******************************************************************************/
#ifndef _GNU_EFI
#if !defined(_GNU_EFI) && !defined(_EDK2_EFI)
int ACPI_SYSTEM_XFACE
main (
int argc,

2
tests/misc/grammar.asl
View File

@ -946,7 +946,7 @@ DefinitionBlock (
Notify (\_PR.CPU0, 0)
}
Method (_ERR, 2)
Method (_ERR, 3)
{
Increment (ERRS)
Store ("Run-time exception:", Debug)