upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-05-28 04:12:45 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge ACPICA 20160930.

Browse source
This commit is contained in:
Jung-uk Kim 2016-10-04 20:27:15 +00:00
commit 493deb390b
123 changed files with 5134 additions and 4724 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
sys/arm64/acpica/OsdEnvironment.c
View file

@ -33,6 +33,7 @@ __FBSDID("$FreeBSD$");
#include <sys/sysctl.h>
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/aclocal.h>
#include <contrib/dev/acpica/include/actables.h>
static u_long acpi_root_phys;

1
sys/conf/files
View file

@ -480,6 +480,7 @@ contrib/dev/acpica/components/utilities/utpredef.c optional acpi
contrib/dev/acpica/components/utilities/utresrc.c optional acpi
contrib/dev/acpica/components/utilities/utstate.c optional acpi
contrib/dev/acpica/components/utilities/utstring.c optional acpi
contrib/dev/acpica/components/utilities/utstrtoul64.c optional acpi
contrib/dev/acpica/components/utilities/utuuid.c optional acpi acpi_debug
contrib/dev/acpica/components/utilities/utxface.c optional acpi
contrib/dev/acpica/components/utilities/utxferror.c optional acpi

6
sys/contrib/dev/acpica/acpica_prep.sh
View file

@ -23,7 +23,7 @@ stripfiles="Makefile README accygwin.h acdragonfly.h acdragonflyex.h \
acmacosx.h acmsvc.h acmsvcex.h acnetbsd.h acos2.h acqnx.h \
acwin.h acwin64.h acwinex.h new_table.txt osbsdtbl.c osefitbl.c \
osefixf.c osfreebsdtbl.c oslinuxtbl.c osunixdir.c osunixmap.c \
oswindir.c oswintbl.c oswinxf.c readme.txt utclib.c"
oswindir.c oswintbl.c oswinxf.c readme.txt utclib.c utprint.c"
# include files to canonify
src_headers="acapps.h acbuffer.h acclib.h accommon.h acconfig.h \
@ -87,6 +87,6 @@ rm -rf ${wrk}
# assist the developer in generating a diff
echo "Directories you may want to 'svn diff':"
echo " sys/contrib/dev/acpica sys/dev/acpica \\"
echo " sys/amd64/acpica sys/i386/acpica sys/x86/acpica \\"
echo " sys/amd64/include sys/i386/include include \\"
echo " sys/amd64/acpica sys/arm64/acpica sys/i386/acpica sys/x86/acpica \\"
echo " sys/amd64/include sys/arm64/include sys/i386/include include \\"
echo " sys/boot sys/conf sys/modules/acpi usr.sbin/acpi"

246
sys/contrib/dev/acpica/changes.txt
View file

@ -1,8 +1,250 @@
----------------------------------------
30 September 2016. Summary of changes for version 20160930:
1) ACPICA kernel-resident subsystem:
Fixed a regression in the internal AcpiTbFindTable function where a non
AE_OK exception could inadvertently be returned even if the function did
not fail. This problem affects the following operators:
DataTableRegion
LoadTable
Fixed a regression in the LoadTable operator where a load to any
namespace location other than the root no longer worked properly.
Increased the maximum loop count value that will result in the
AE_AML_INFINITE_LOOP exception. This is a mechanism that is intended to
prevent infinite loops within the AML interpreter and thus the host OS
kernel. The value is increased from 0xFFFF to 0xFFFFF loops (65,535 to
1,048,575).
Moved the AcpiGbl_MaxLoopIterations configuration variable to the public
acpixf.h file. This allows hosts to easily configure the maximum loop
count at runtime.
Removed an illegal character in the strtoul64.c file. This character
caused errors with some C compilers.
Example Code and Data Size: These are the sizes for the OS-independent
acpica.lib produced by the Microsoft Visual C++ 9.0 32-bit compiler. The
debug version of the code includes the debug output trace mechanism and
has a much larger code and data size.
Current Release:
Non-Debug Version: 140.4K Code, 58.1K Data, 198.5K Total
Debug Version: 200.7K Code, 82.1K Data, 282.8K Total
Previous Release:
Non-Debug Version: 140.0K Code, 58.1K Data, 198.1K Total
Debug Version: 200.3K Code, 82.1K Data, 282.4K Total
2) iASL Compiler/Disassembler and Tools:
Disassembler: Fixed a problem with the conversion of Else{If{ blocks into
the simpler ASL ElseIf keyword. During the conversion, a trailing If
block could be lost and missing from the disassembled output.
iASL: Fixed a missing parser rule for the ObjectType operator. For ASL+,
the missing rule caused a parse error when using the Index operator as an
operand to ObjectType. This construct now compiles properly. Example:
ObjectType(PKG1[4]).
iASL: Correctly handle unresolved symbols in the hardware map file (-lm
option). Previously, unresolved symbols could cause a protection fault.
Such symbols are now marked as unresolved in the map file.
iASL: Implemented support to allow control method invocations as an
operand to the ASL DeRefOf operator. Example:
DeRefOf(MTH1(Local0))
Disassembler: Improved support for the ToPLD ASL macro. Detection of a
possible _PLD buffer now includes examination of both the normal buffer
length (16 or 20) as well as the surrounding AML package length.
Disassembler: Fixed a problem with the decoding of complex expressions
within the Divide operator for ASL+. For the case where both the quotient
and remainder targets are specified, the entire statement cannot be
disassembled. Previously, the output incorrectly contained a mix of ASL-
and ASL+ operators. This mixed statement causes a syntax error when
compiled. Example:
Divide (Add (INT1, 6), 128, RSLT, QUOT) // was incorrectly
disassembled to:
Divide (INT1 + 6, 128, RSLT, QUOT)
iASL/Tools: Added support to process AML and non-AML ACPI tables
consistently. For the disassembler and AcpiExec, allow all types of ACPI
tables (AML and data tables). For the iASL -e option, allow only AML
tables (DSDT/SSDT).
----------------------------------------
31 August 2016. Summary of changes for version 20160831:
1) ACPICA kernel-resident subsystem:
Improve support for the so-called "module-level code", which is defined
to be math, logical and control AML opcodes that appear outside of any
control method. This change improves the support by adding more opcodes
that can be executed in the manner. Some other issues have been solved,
and the ASL grammar changes to support such code under all scope
operators (Device, etc.) are complete. Lv Zheng.
UEFI support: these OSL functions have been implemented. This is an
additional step toward supporting the AcpiExec utility natively (with
full hardware access) under UEFI. Marcelo Ferreira.
AcpiOsReadPciConfiguration
AcpiOsWritePciConfiguration
Fixed a possible mutex error during control method auto-serialization. Lv
Zheng.
Updated support for the Generic Address Structure by fully implementing
all GAS fields when a 32-bit address is expanded to a 64-bit GAS. Lv
Zheng.
Updated the return value for the internal _OSI method. Instead of
0xFFFFFFFF, the "Ones" value is now returned, which is 0xFFFFFFFFFFFFFFFF
for 64-bit ACPI tables. This fixes an incompatibility with other ACPI
implementations, and will be reflected and clarified in the next version
of the ACPI specification.
Implemented two new table events that can be passed to an ACPICA table
handler. These events are used to indicate a table installation or
uninstallation. These events are used in addition to existed table load
and unload events. Lv Zheng.
Implemented a cleanup for all internal string-to-integer conversions.
Consolidate multiple versions of this functionality and limit possible
bases to either 10 or 16 to simplify the code. Adds a new file,
utstrtoul64.
Cleanup the inclusion order of the various compiler-specific headers.
This simplifies build configuration management. The compiler-specific
headers are now split out from the host-specific headers. Lv Zheng.
Example Code and Data Size: These are the sizes for the OS-independent
acpica.lib produced by the Microsoft Visual C++ 9.0 32-bit compiler. The
debug version of the code includes the debug output trace mechanism and
has a much larger code and data size.
Current Release:
Non-Debug Version: 140.1K Code, 58.1K Data, 198.1K Total
Debug Version: 200.3K Code, 82.1K Data, 282.4K Total
2) iASL Compiler/Disassembler and Tools:
iASL/AcpiExec: Added a command line option to display the build date/time
of the tool (-vd). This can be useful to verify that the correct version
of the tools are being used.
AML Debugger: Implemented a new subcommand ("execute predef") to execute
all predefined control methods and names within the current namespace.
This can be useful for debugging problems with ACPI tables and the ACPI
namespace.
----------------------------------------
29 July 2016. Summary of changes for version 20160729:
1) ACPICA kernel-resident subsystem:
Implemented basic UEFI support for the various ACPICA tools. This
includes:
1) An OSL to implement the various AcpiOs* interfaces on UEFI.
2) Support to obtain the ACPI tables on UEFI.
3) Local implementation of required C library functions not available on
UEFI.
4) A front-end (main) function for the tools for UEFI-related
initialization.
The initial deployment of this support is the AcpiDump utility executing
as an UEFI application via EDK2 (EDKII, "UEFI Firmware Development Kit").
Current environments supported are Linux/Unix. MSVC generation is not
supported at this time. See the generate/efi/README file for build
instructions. Lv Zheng.
Future plans include porting the AcpiExec utility to execute natively on
the platform with I/O and memory access. This will allow viewing/dump of
the platform namespace and native execution of ACPI control methods that
access the actual hardware. To fully implement this support, the OSL
functions below must be implemented with UEFI interfaces. Any community
help in the implementation of these functions would be appreciated:
AcpiOsReadPort
AcpiOsWritePort
AcpiOsReadMemory
AcpiOsWriteMemory
AcpiOsReadPciConfiguration
AcpiOsWritePciConfiguration
Restructured and standardized the C library configuration for ACPICA,
resulting in the various configuration options below. This includes a
global restructuring of the compiler-dependent and platform-dependent
include files. These changes may affect the existing platform-dependent
configuration files on some hosts. Lv Zheng.
The current C library configuration options appear below. For any issues,
it may be helpful to examine the existing compiler-dependent and
platform-dependent files as examples. Lv Zheng.
1) Linux kernel:
ACPI_USE_STANDARD_HEADERS=n in order not to use system-provided C
library.
ACPI_USE_SYSTEM_CLIBRARY=y in order not to use ACPICA mini C library.
2) Unix/Windows/BSD applications:
ACPI_USE_STANDARD_HEADERS=y in order to use system-provided C
library.
ACPI_USE_SYSTEM_CLIBRARY=y in order not to use ACPICA mini C library.
3) UEFI applications:
ACPI_USE_STANDARD_HEADERS=n in order not to use system-provided C
library.
ACPI_USE_SYSTEM_CLIBRARY=n in order to use ACPICA mini C library.
4) UEFI applications (EDK2/StdLib):
ACPI_USE_STANDARD_HEADERS=y in order to use EDK2 StdLib C library.
ACPI_USE_SYSTEM_CLIBRARY=y in order to use EDK2 StdLib C library.
AML interpreter: "module-level code" support. Allows for execution of so-
called "executable" AML code (math/logical operations, etc.) outside of
control methods not just at the module level (top level) but also within
any scope declared outside of a control method - Scope{}, Device{},
Processor{}, PowerResource{}, and ThermalZone{}. Lv Zheng.
Simplified the configuration of the "maximum AML loops" global option by
adding a global public variable, "AcpiGbl_MaxLoopIterations" which can be
modified at runtime.
Example Code and Data Size: These are the sizes for the OS-independent
acpica.lib produced by the Microsoft Visual C++ 9.0 32-bit compiler. The
debug version of the code includes the debug output trace mechanism and
has a much larger code and data size.
Current Release:
Non-Debug Version: 139.1K Code, 22.9K Data, 162.0K Total
Debug Version: 199.0K Code, 81.8K Data, 280.8K Total
2) iASL Compiler/Disassembler and Tools:
iASL: Add full support for the RASF ACPI table (RAS Features Table).
Includes disassembler, data table compiler, and header support.
iASL Expand "module-level code" support. Allows for
compilation/disassembly of so-called "executable" AML code (math/logical
operations, etc.) outside of control methods not just at the module level
(top level) but also within any scope declared outside of a control
method - Scope{}, Device{}, Processor{}, PowerResource{}, and
ThermalZone{}.
AcpiDump: Added support for dumping all SSDTs on newer versions of
Windows. These tables are now easily available -- SSDTs are not available
through the registry on older versions.
----------------------------------------
27 May 2016. Summary of changes for version 20160527:
This release is available at https://acpica.org/downloads
1) ACPICA kernel-resident subsystem:

19
sys/contrib/dev/acpica/common/acfileio.c
View file

@ -43,10 +43,9 @@
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acapps.h>
#include <contrib/dev/acpica/include/actables.h>
#include <contrib/dev/acpica/include/acutils.h>
#include <errno.h>
#include <contrib/dev/acpica/include/acapps.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("acfileio")
@ -98,7 +97,7 @@ AcGetAllTablesFromFile (
File = fopen (Filename, "rb");
if (!File)
{
perror ("Could not open input file");
fprintf (stderr, "Could not open input file: %s\n", Filename);
if (errno == ENOENT)
{
return (AE_NOT_EXIST);
@ -263,12 +262,14 @@ AcGetOneTableFromFile (
return (Status);
}
if (GetOnlyAmlTables)
{
/* Table must be an AML table (DSDT/SSDT) or FADT */
if (!ACPI_COMPARE_NAME (TableHeader.Signature, ACPI_SIG_FADT) &&
!AcpiUtIsAmlTable (&TableHeader))
/*
* Table must be an AML table (DSDT/SSDT).
* Used for iASL -e option only.
*/
if (!AcpiUtIsAmlTable (&TableHeader))
{
fprintf (stderr,
" %s: Table [%4.4s] is not an AML table - ignoring\n",
@ -280,7 +281,7 @@ AcGetOneTableFromFile (
/* Allocate a buffer for the entire table */
Table = AcpiOsAllocate ((size_t) TableHeader.Length);
Table = AcpiOsAllocate ((ACPI_SIZE) TableHeader.Length);
if (!Table)
{
return (AE_NO_MEMORY);
@ -388,7 +389,7 @@ AcValidateTableHeader (
long TableOffset)
{
ACPI_TABLE_HEADER TableHeader;
size_t Actual;
ACPI_SIZE Actual;
long OriginalOffset;
UINT32 FileSize;
UINT32 i;

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

@ -47,8 +47,6 @@
#include <contrib/dev/acpica/include/acparser.h>
#include <contrib/dev/acpica/include/acdebug.h>
#include <stdio.h>
/*
* This is an os-independent implementation of line-editing services needed
* by the AcpiExec utility. It uses getchar() and putchar() and the existing

2
sys/contrib/dev/acpica/common/adisasm.c
View file

@ -49,8 +49,6 @@
#include <contrib/dev/acpica/include/acparser.h>
#include <contrib/dev/acpica/include/acapps.h>
#include <stdio.h>
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("adisasm")

1
sys/contrib/dev/acpica/common/ahtable.c
View file

@ -124,6 +124,7 @@ const AH_TABLE AcpiSupportedTables[] =
{ACPI_SIG_NFIT, "NVDIMM Firmware Interface Table"},
{ACPI_SIG_PCCT, "Platform Communications Channel Table"},
{ACPI_SIG_PMTT, "Platform Memory Topology Table"},
{ACPI_SIG_RASF, "RAS Features Table"},
{ACPI_RSDP_NAME,"Root System Description Pointer"},
{ACPI_SIG_RSDT, "Root System Description Table"},
{ACPI_SIG_S3PT, "S3 Performance Table"},

13
sys/contrib/dev/acpica/common/cmfsize.c
View file

@ -44,7 +44,6 @@
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acapps.h>
#include <stdio.h>
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("cmfsize")
@ -74,19 +73,19 @@ CmGetFileSize (
/* Save the current file pointer, seek to EOF to obtain file size */
CurrentOffset = AcpiOsGetFileOffset (File);
CurrentOffset = ftell (File);
if (CurrentOffset < 0)
{
goto OffsetError;
}
Status = AcpiOsSetFileOffset (File, 0, ACPI_FILE_END);
Status = fseek (File, 0, SEEK_END);
if (ACPI_FAILURE (Status))
{
goto SeekError;
}
FileSize = AcpiOsGetFileOffset (File);
FileSize = ftell (File);
if (FileSize < 0)
{
goto OffsetError;
@ -94,7 +93,7 @@ CmGetFileSize (
/* Restore original file pointer */
Status = AcpiOsSetFileOffset (File, CurrentOffset, ACPI_FILE_BEGIN);
Status = fseek (File, CurrentOffset, SEEK_SET);
if (ACPI_FAILURE (Status))
{
goto SeekError;
@ -104,10 +103,10 @@ CmGetFileSize (
OffsetError:
AcpiLogError ("Could not get file offset");
fprintf (stderr, "Could not get file offset\n");
return (ACPI_UINT32_MAX);
SeekError:
AcpiLogError ("Could not set file offset");
fprintf (stderr, "Could not set file offset\n");
return (ACPI_UINT32_MAX);
}

7
sys/contrib/dev/acpica/common/dmtable.c
View file

@ -358,6 +358,7 @@ const ACPI_DMTABLE_DATA AcpiDmTableData[] =
{ACPI_SIG_NFIT, AcpiDmTableInfoNfit, AcpiDmDumpNfit, DtCompileNfit, TemplateNfit},
{ACPI_SIG_PCCT, AcpiDmTableInfoPcct, AcpiDmDumpPcct, DtCompilePcct, TemplatePcct},
{ACPI_SIG_PMTT, NULL, AcpiDmDumpPmtt, DtCompilePmtt, TemplatePmtt},
{ACPI_SIG_RASF, AcpiDmTableInfoRasf, NULL, NULL, TemplateRasf},
{ACPI_SIG_RSDT, NULL, AcpiDmDumpRsdt, DtCompileRsdt, TemplateRsdt},
{ACPI_SIG_S3PT, NULL, NULL, NULL, TemplateS3pt},
{ACPI_SIG_SBST, AcpiDmTableInfoSbst, NULL, NULL, TemplateSbst},
@ -844,6 +845,11 @@ AcpiDmDumpTable (
ByteLength = 10;
break;
case ACPI_DMT_BUF12:
ByteLength = 12;
break;
case ACPI_DMT_BUF16:
case ACPI_DMT_UUID:
@ -1006,6 +1012,7 @@ AcpiDmDumpTable (
case ACPI_DMT_BUF7:
case ACPI_DMT_BUF10:
case ACPI_DMT_BUF12:
case ACPI_DMT_BUF16:
case ACPI_DMT_BUF128:
/*

4
sys/contrib/dev/acpica/common/dmtables.c
View file

@ -42,14 +42,12 @@
*/
#include <contrib/dev/acpica/compiler/aslcompiler.h>
#include <contrib/dev/acpica/include/acapps.h>
#include <contrib/dev/acpica/include/acdispat.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/actables.h>
#include <contrib/dev/acpica/include/acparser.h>
#include <contrib/dev/acpica/include/acapps.h>
#include <stdio.h>
#include <time.h>
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("dmtables")

186
sys/contrib/dev/acpica/common/dmtbdump.c
View file

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

41
sys/contrib/dev/acpica/common/dmtbinfo.c
View file

@ -106,6 +106,7 @@
#define ACPI_NFIT_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_NFIT,f)
#define ACPI_PCCT_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_PCCT,f)
#define ACPI_PMTT_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_PMTT,f)
#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_SLIT_OFFSET(f) (UINT16) ACPI_OFFSET (ACPI_TABLE_SLIT,f)
@ -399,7 +400,7 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoFacs[] =
*
******************************************************************************/
/* ACPI 1.0 FADT (Version 1) */
/* FADT version 1 (ACPI 1.0) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt1[] =
{
@ -485,18 +486,7 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoFadt1[] =
ACPI_DMT_TERMINATOR
};
/* ACPI 1.0 MS Extensions (FADT version 2) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt2[] =
{
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (ResetRegister), "Reset Register", 0},
{ACPI_DMT_UINT8, ACPI_FADT_OFFSET (ResetValue), "Value to cause reset", 0},
{ACPI_DMT_UINT16, ACPI_FADT_OFFSET (ArmBootFlags), "Reserved", 0},
{ACPI_DMT_UINT8, ACPI_FADT_OFFSET (MinorRevision), "Reserved", 0},
ACPI_DMT_TERMINATOR
};
/* ACPI 2.0+ Extensions (FADT version 3, 4, and 5) */
/* FADT version 3 (ACPI 2.0) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt3[] =
{
@ -520,16 +510,23 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoFadt3[] =
ACPI_DMT_TERMINATOR
};
/* ACPI 5.0 Extensions (FADT version 5) */
/* FADT version 4 (ACPI 3.0 and ACPI 4.0) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt4[] =
{
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (SleepControl), "Sleep Control Register", 0},
ACPI_DMT_TERMINATOR
};
/* FADT version 5 (ACPI 5.0) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt5[] =
{
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (SleepControl), "Sleep Control Register", 0},
{ACPI_DMT_GAS, ACPI_FADT_OFFSET (SleepStatus), "Sleep Status Register", 0},
ACPI_DMT_TERMINATOR
};
/* ACPI 6.0 Extensions (FADT version 6) */
/* FADT version 6 (ACPI 6.0) */
ACPI_DMTABLE_INFO AcpiDmTableInfoFadt6[] =
{
@ -2438,6 +2435,18 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoPmtt2[] =
};
/*******************************************************************************
*
* RASF - RAS Feature table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoRasf[] =
{
{ACPI_DMT_BUF12, ACPI_RASF_OFFSET (ChannelId[0]), "Channel ID", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* S3PT - S3 Performance Table

4
sys/contrib/dev/acpica/common/getopt.c
View file

@ -57,7 +57,7 @@
#include <contrib/dev/acpica/include/acapps.h>
#define ACPI_OPTION_ERROR(msg, badchar) \
if (AcpiGbl_Opterr) {AcpiLogError ("%s%c\n", msg, badchar);}
if (AcpiGbl_Opterr) {fprintf (stderr, "%s%c\n", msg, badchar);}
int AcpiGbl_Opterr = 1;
@ -101,7 +101,7 @@ AcpiGetoptArgument (
}
else if (++AcpiGbl_Optind >= argc)
{
ACPI_OPTION_ERROR ("Option requires an argument: -", 'v');
ACPI_OPTION_ERROR ("\nOption requires an argument", 0);
CurrentCharPtr = 1;
return (-1);

7
sys/contrib/dev/acpica/compiler/aslcompiler.h
View file

@ -62,7 +62,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
@ -912,7 +911,7 @@ LkFindUnreferencedObjects (
void);
/*
* aslmain - startup
* aslhelp - help screens
*/
void
Usage (
@ -922,6 +921,10 @@ void
AslFilenameHelp (
void);
void
AslDisassemblyHelp (
void);
/*
* aslnamesp - namespace output file generation

33
sys/contrib/dev/acpica/compiler/aslcstyle.y
View file

@ -82,6 +82,13 @@ NoEcho('
* 13) = += -= *= /= %= <<= >>= &= ^= |=
*/
/*******************************************************************************
*
* Basic operations for math and logical expressions.
*
******************************************************************************/
Expression
/* Unary operators */
@ -140,33 +147,43 @@ Expression
| TermArg PARSEOP_EXP_LOGICAL_OR {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);}
TermArg {$$ = TrLinkChildren ($<n>3,2,$1,$4);}
/* Parentheses */
/* Parentheses */
| '(' TermArg ')' { $$ = $2;}
/* Index term -- "= BUF1[5]" on right-hand side of an equals (source) */
/* Index term -- "= BUF1[5]" on right-hand side of an equals (source) */
| SuperName PARSEOP_EXP_INDEX_LEFT TermArg PARSEOP_EXP_INDEX_RIGHT
{$$ = TrCreateLeafNode (PARSEOP_INDEX);
| SuperName PARSEOP_EXP_INDEX_LEFT
TermArg PARSEOP_EXP_INDEX_RIGHT {$$ = TrCreateLeafNode (PARSEOP_INDEX);
TrLinkChildren ($$,3,$1,$3,TrCreateNullTarget ());}
;
/* Index term -- "BUF1[5] = " on left-hand side of an equals (target) */
/* Index term -- "BUF1[5] = " on left-hand side of an equals (target) */
IndexExpTerm
: SuperName PARSEOP_EXP_INDEX_LEFT TermArg PARSEOP_EXP_INDEX_RIGHT
{$$ = TrCreateLeafNode (PARSEOP_INDEX);
: SuperName PARSEOP_EXP_INDEX_LEFT
TermArg PARSEOP_EXP_INDEX_RIGHT {$$ = TrCreateLeafNode (PARSEOP_INDEX);
TrLinkChildren ($$,3,$1,$3,TrCreateNullTarget ());}
;
/*******************************************************************************
*
* All assignment-type operations -- math and logical. Includes simple
* assignment and compound assignments.
*
******************************************************************************/
EqualsTerm
/* All assignment-type operations */
/* Simple Store() operation */
: SuperName PARSEOP_EXP_EQUALS
TermArg {$$ = TrCreateAssignmentNode ($1, $3);}
/* Compound assignments -- Add (operand, operand, target) */
| TermArg PARSEOP_EXP_ADD_EQ {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);}
TermArg {$$ = TrLinkChildren ($<n>3,3,$1,$4,
TrSetNodeFlags (TrCreateTargetOperand ($1, NULL), NODE_IS_TARGET));}

220
sys/contrib/dev/acpica/compiler/aslhelp.c Normal file
View file

@ -0,0 +1,220 @@
/******************************************************************************
*
* Module Name: aslhelp - iASL help screens
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2016, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <contrib/dev/acpica/compiler/aslcompiler.h>
#include <contrib/dev/acpica/include/acapps.h>
#define _COMPONENT ACPI_COMPILER
ACPI_MODULE_NAME ("aslhelp")
/*******************************************************************************
*
* FUNCTION: Usage
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Display option help message.
* Optional items in square brackets.
*
******************************************************************************/
void
Usage (
void)
{
printf ("%s\n\n", ASL_COMPLIANCE);
ACPI_USAGE_HEADER ("iasl [Options] [Files]");
printf ("\nGeneral:\n");
ACPI_OPTION ("-@ <file>", "Specify command file");
ACPI_OPTION ("-I <dir>", "Specify additional include directory");
ACPI_OPTION ("-p <prefix>", "Specify path/filename prefix for all output files");
ACPI_OPTION ("-v", "Display compiler version");
ACPI_OPTION ("-vd", "Display compiler build date and time");
ACPI_OPTION ("-vo", "Enable optimization comments");
ACPI_OPTION ("-vs", "Disable signon");
printf ("\nHelp:\n");
ACPI_OPTION ("-h", "This message");
ACPI_OPTION ("-hc", "Display operators allowed in constant expressions");
ACPI_OPTION ("-hd", "Info for obtaining and disassembling binary ACPI tables");
ACPI_OPTION ("-hf", "Display help for output filename generation");
ACPI_OPTION ("-hr", "Display ACPI reserved method names");
ACPI_OPTION ("-ht", "Display currently supported ACPI table names");
printf ("\nPreprocessor:\n");
ACPI_OPTION ("-D <symbol>", "Define symbol for preprocessor use");
ACPI_OPTION ("-li", "Create preprocessed output file (*.i)");
ACPI_OPTION ("-P", "Preprocess only and create preprocessor output file (*.i)");
ACPI_OPTION ("-Pn", "Disable preprocessor");
printf ("\nErrors, Warnings, and Remarks:\n");
ACPI_OPTION ("-va", "Disable all errors/warnings/remarks");
ACPI_OPTION ("-ve", "Report only errors (ignore warnings and remarks)");
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 ("-w <1|2|3>", "Set warning reporting level");
ACPI_OPTION ("-we", "Report warnings as errors");
printf ("\nAML Code Generation (*.aml):\n");
ACPI_OPTION ("-oa", "Disable all optimizations (compatibility mode)");
ACPI_OPTION ("-of", "Disable constant folding");
ACPI_OPTION ("-oi", "Disable integer optimization to Zero/One/Ones");
ACPI_OPTION ("-on", "Disable named reference string optimization");
ACPI_OPTION ("-ot", "Disable typechecking");
ACPI_OPTION ("-cr", "Disable Resource Descriptor error checking");
ACPI_OPTION ("-in", "Ignore NoOp operators");
ACPI_OPTION ("-r <revision>", "Override table header Revision (1-255)");
printf ("\nListings:\n");
ACPI_OPTION ("-l", "Create mixed listing file (ASL source and AML) (*.lst)");
ACPI_OPTION ("-lm", "Create hardware summary map file (*.map)");
ACPI_OPTION ("-ln", "Create namespace file (*.nsp)");
ACPI_OPTION ("-ls", "Create combined source file (expanded includes) (*.src)");
ACPI_OPTION ("-lx", "Create cross-reference file (*.xrf)");
printf ("\nFirmware Support - C Output:\n");
ACPI_OPTION ("-tc", "Create hex AML table in C (*.hex)");
ACPI_OPTION ("-sc", "Create named hex AML arrays in C (*.c)");
ACPI_OPTION ("-ic", "Create include file in C for -sc symbols (*.h)");
ACPI_OPTION ("-so", "Create namespace AML offset table in C (*.offset.h)");
printf ("\nFirmware Support - Assembler Output:\n");
ACPI_OPTION ("-ta", "Create hex AML table in assembler (*.hex)");
ACPI_OPTION ("-sa", "Create named hex AML arrays in assembler (*.asm)");
ACPI_OPTION ("-ia", "Create include file in assembler for -sa symbols (*.inc)");
printf ("\nFirmware Support - ASL Output:\n");
ACPI_OPTION ("-ts", "Create hex AML table in ASL (Buffer object) (*.hex)");
printf ("\nData Table Compiler:\n");
ACPI_OPTION ("-G", "Compile custom table that contains generic operators");
ACPI_OPTION ("-T <sig list>|ALL", "Create ACPI table template/example files");
ACPI_OPTION ("-T <count>", "Emit DSDT and <count> SSDTs to same file");
ACPI_OPTION ("-vt", "Create verbose template files (full disassembly)");
printf ("\nAML Disassembler:\n");
ACPI_OPTION ("-d <f1 f2 ...>", "Disassemble or decode binary ACPI tables to file (*.dsl)");
ACPI_OPTION ("", " (Optional, file type is automatically detected)");
ACPI_OPTION ("-da <f1 f2 ...>", "Disassemble multiple tables from single namespace");
ACPI_OPTION ("-db", "Do not translate Buffers to Resource Templates");
ACPI_OPTION ("-dc <f1 f2 ...>", "Disassemble AML and immediately compile it");
ACPI_OPTION ("", " (Obtain DSDT from current system if no input file)");
ACPI_OPTION ("-df", "Force disassembler to assume table contains valid AML");
ACPI_OPTION ("-dl", "Emit legacy ASL code only (no C-style operators)");
ACPI_OPTION ("-e <f1 f2 ...>", "Include ACPI table(s) for external symbol resolution");
ACPI_OPTION ("-fe <file>", "Specify external symbol declaration file");
ACPI_OPTION ("-in", "Ignore NoOp opcodes");
ACPI_OPTION ("-l", "Disassemble to mixed ASL and AML code");
ACPI_OPTION ("-vt", "Dump binary table data in hex format within output file");
printf ("\nDebug Options:\n");
ACPI_OPTION ("-bf", "Create debug file (full output) (*.txt)");
ACPI_OPTION ("-bs", "Create debug file (parse tree only) (*.txt)");
ACPI_OPTION ("-bp <depth>", "Prune ASL parse tree");
ACPI_OPTION ("-bt <type>", "Object type to be pruned from the parse tree");
ACPI_OPTION ("-f", "Ignore errors, force creation of AML output file(s)");
ACPI_OPTION ("-m <size>", "Set internal line buffer size (in Kbytes)");
ACPI_OPTION ("-n", "Parse only, no output generation");
ACPI_OPTION ("-oc", "Display compile times and statistics");
ACPI_OPTION ("-x <level>", "Set debug level for trace output");
ACPI_OPTION ("-z", "Do not insert new compiler ID for DataTables");
}
/*******************************************************************************
*
* FUNCTION: FilenameHelp
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Display help message for output filename generation
*
******************************************************************************/
void
AslFilenameHelp (
void)
{
printf ("\nAML output filename generation:\n");
printf (" Output filenames are generated by appending an extension to a common\n");
printf (" filename prefix. The filename prefix is obtained via one of the\n");
printf (" following methods (in priority order):\n");
printf (" 1) The -p option specifies the prefix\n");
printf (" 2) The prefix of the AMLFileName in the ASL Definition Block\n");
printf (" 3) The prefix of the input filename\n");
printf ("\n");
}
/*******************************************************************************
*
* FUNCTION: AslDisassemblyHelp
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Display help message for obtaining and disassembling AML/ASL
* files.
*
******************************************************************************/
void
AslDisassemblyHelp (
void)
{
printf ("\nObtaining binary ACPI tables and disassembling to ASL source code.\n\n");
printf ("Use the following ACPICA toolchain:\n");
printf (" AcpiDump: Dump all ACPI tables to a hex ascii file\n");
printf (" AcpiXtract: Extract one or more binary ACPI tables from AcpiDump output\n");
printf (" iASL -d <file>: Disassemble a binary ACPI table to ASL source code\n");
printf ("\n");
}

286
sys/contrib/dev/acpica/compiler/aslhelpers.y Normal file
View file

@ -0,0 +1,286 @@
NoEcho('
/******************************************************************************
*
* Module Name: aslhelpers.y - helper and option terms
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2016, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
')
/*******************************************************************************
*
* ASL Helper Terms
*
******************************************************************************/
OptionalBusMasterKeyword
: ',' {$$ = TrCreateLeafNode (
PARSEOP_BUSMASTERTYPE_MASTER);}
| ',' PARSEOP_BUSMASTERTYPE_MASTER {$$ = TrCreateLeafNode (
PARSEOP_BUSMASTERTYPE_MASTER);}
| ',' PARSEOP_BUSMASTERTYPE_NOTMASTER {$$ = TrCreateLeafNode (
PARSEOP_BUSMASTERTYPE_NOTMASTER);}
;
OptionalAccessAttribTerm
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' ByteConstExpr {$$ = $2;}
| ',' AccessAttribKeyword {$$ = $2;}
;
OptionalAccessSize
: {$$ = TrCreateValuedLeafNode (
PARSEOP_BYTECONST, 0);}
| ',' {$$ = TrCreateValuedLeafNode (
PARSEOP_BYTECONST, 0);}
| ',' ByteConstExpr {$$ = $2;}
;
OptionalAddressingMode
: ',' {$$ = NULL;}
| ',' AddressingModeKeyword {$$ = $2;}
;
OptionalAddressRange
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' AddressKeyword {$$ = $2;}
;
OptionalBitsPerByte
: ',' {$$ = NULL;}
| ',' BitsPerByteKeyword {$$ = $2;}
;
OptionalBuffer_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' RawDataBufferTerm {$$ = $2;}
;
OptionalByteConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' ByteConstExpr {$$ = $2;}
;
OptionalDecodeType
: ',' {$$ = NULL;}
| ',' DecodeKeyword {$$ = $2;}
;
OptionalDevicePolarity
: ',' {$$ = NULL;}
| ',' DevicePolarityKeyword {$$ = $2;}
;
OptionalDWordConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' DWordConstExpr {$$ = $2;}
;
OptionalEndian
: ',' {$$ = NULL;}
| ',' EndianKeyword {$$ = $2;}
;
OptionalFlowControl
: ',' {$$ = NULL;}
| ',' FlowControlKeyword {$$ = $2;}
;
OptionalIoRestriction
: ',' {$$ = NULL;}
| ',' IoRestrictionKeyword {$$ = $2;}
;
OptionalListString
: {$$ = TrCreateValuedLeafNode (
PARSEOP_STRING_LITERAL,
ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
| ',' {$$ = TrCreateValuedLeafNode (
PARSEOP_STRING_LITERAL,
ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
| ',' TermArg {$$ = $2;}
;
OptionalMaxType
: ',' {$$ = NULL;}
| ',' MaxKeyword {$$ = $2;}
;
OptionalMemType
: ',' {$$ = NULL;}
| ',' MemTypeKeyword {$$ = $2;}
;
OptionalMinType
: ',' {$$ = NULL;}
| ',' MinKeyword {$$ = $2;}
;
OptionalNameString
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' NameString {$$ = $2;}
;
OptionalNameString_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' NameString {$$ = $2;}
;
OptionalNameString_First
: {$$ = TrCreateLeafNode (
PARSEOP_ZERO);}
| NameString {$$ = $1;}
;
OptionalObjectTypeKeyword
: {$$ = TrCreateLeafNode (
PARSEOP_OBJECTTYPE_UNK);}
| ',' ObjectTypeKeyword {$$ = $2;}
;
OptionalParityType
: ',' {$$ = NULL;}
| ',' ParityTypeKeyword {$$ = $2;}
;
OptionalQWordConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' QWordConstExpr {$$ = $2;}
;
OptionalRangeType
: ',' {$$ = NULL;}
| ',' RangeTypeKeyword {$$ = $2;}
;
OptionalReadWriteKeyword
: {$$ = TrCreateLeafNode (
PARSEOP_READWRITETYPE_BOTH);}
| PARSEOP_READWRITETYPE_BOTH {$$ = TrCreateLeafNode (
PARSEOP_READWRITETYPE_BOTH);}
| PARSEOP_READWRITETYPE_READONLY {$$ = TrCreateLeafNode (
PARSEOP_READWRITETYPE_READONLY);}
;
OptionalResourceType_First
: {$$ = TrCreateLeafNode (
PARSEOP_RESOURCETYPE_CONSUMER);}
| ResourceTypeKeyword {$$ = $1;}
;
OptionalResourceType
: {$$ = TrCreateLeafNode (
PARSEOP_RESOURCETYPE_CONSUMER);}
| ',' {$$ = TrCreateLeafNode (
PARSEOP_RESOURCETYPE_CONSUMER);}
| ',' ResourceTypeKeyword {$$ = $2;}
;
OptionalSlaveMode
: ',' {$$ = NULL;}
| ',' SlaveModeKeyword {$$ = $2;}
;
OptionalShareType
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' ShareTypeKeyword {$$ = $2;}
;
OptionalShareType_First
: {$$ = NULL;}
| ShareTypeKeyword {$$ = $1;}
;
OptionalStopBits
: ',' {$$ = NULL;}
| ',' StopBitsKeyword {$$ = $2;}
;
OptionalStringData
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' StringData {$$ = $2;}
;
OptionalTranslationType_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' TranslationKeyword {$$ = $2;}
;
OptionalType
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' TypeKeyword {$$ = $2;}
;
OptionalType_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' TypeKeyword {$$ = $2;}
;
OptionalWireMode
: ',' {$$ = NULL;}
| ',' WireModeKeyword {$$ = $2;}
;
OptionalWordConstExpr
: ',' {$$ = NULL;}
| ',' WordConstExpr {$$ = $2;}
;
OptionalXferSize
: {$$ = TrCreateValuedLeafNode (
PARSEOP_XFERSIZE_32, 2);}
| ',' {$$ = TrCreateValuedLeafNode (
PARSEOP_XFERSIZE_32, 2);}
| ',' XferSizeKeyword {$$ = $2;}
;

352
sys/contrib/dev/acpica/compiler/aslkeywords.y Normal file
View file

@ -0,0 +1,352 @@
NoEcho('
/******************************************************************************
*
* Module Name: aslkeywords.y - Rules for resource descriptor keywords
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2016, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
')
/*******************************************************************************
*
* ASL Parameter Keyword Terms
*
******************************************************************************/
AccessAttribKeyword
: PARSEOP_ACCESSATTRIB_BLOCK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);}
| PARSEOP_ACCESSATTRIB_BLOCK_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);}
| PARSEOP_ACCESSATTRIB_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);}
| PARSEOP_ACCESSATTRIB_QUICK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );}
| PARSEOP_ACCESSATTRIB_SND_RCV {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);}
| PARSEOP_ACCESSATTRIB_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);}
| PARSEOP_ACCESSATTRIB_WORD_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);}
| PARSEOP_ACCESSATTRIB_MULTIBYTE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_MULTIBYTE);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_BYTES '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_BYTES);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_PROCESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_PROCESS);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
;
AccessTypeKeyword
: PARSEOP_ACCESSTYPE_ANY {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_ANY);}
| PARSEOP_ACCESSTYPE_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BYTE);}
| PARSEOP_ACCESSTYPE_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_WORD);}
| PARSEOP_ACCESSTYPE_DWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_DWORD);}
| PARSEOP_ACCESSTYPE_QWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_QWORD);}
| PARSEOP_ACCESSTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BUF);}
;
AddressingModeKeyword
: PARSEOP_ADDRESSINGMODE_7BIT {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_7BIT);}
| PARSEOP_ADDRESSINGMODE_10BIT {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_10BIT);}
;
AddressKeyword
: PARSEOP_ADDRESSTYPE_MEMORY {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);}
| PARSEOP_ADDRESSTYPE_RESERVED {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);}
| PARSEOP_ADDRESSTYPE_NVS {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);}
| PARSEOP_ADDRESSTYPE_ACPI {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);}
;
AddressSpaceKeyword
: ByteConst {$$ = UtCheckIntegerRange ($1, 0x0A, 0xFF);}
| RegionSpaceKeyword {}
;
BitsPerByteKeyword
: PARSEOP_BITSPERBYTE_FIVE {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_FIVE);}
| PARSEOP_BITSPERBYTE_SIX {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SIX);}
| PARSEOP_BITSPERBYTE_SEVEN {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SEVEN);}
| PARSEOP_BITSPERBYTE_EIGHT {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_EIGHT);}
| PARSEOP_BITSPERBYTE_NINE {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_NINE);}
;
ClockPhaseKeyword
: PARSEOP_CLOCKPHASE_FIRST {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_FIRST);}
| PARSEOP_CLOCKPHASE_SECOND {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_SECOND);}
;
ClockPolarityKeyword
: PARSEOP_CLOCKPOLARITY_LOW {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_LOW);}
| PARSEOP_CLOCKPOLARITY_HIGH {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_HIGH);}
;
DecodeKeyword
: PARSEOP_DECODETYPE_POS {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);}
| PARSEOP_DECODETYPE_SUB {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);}
;
DevicePolarityKeyword
: PARSEOP_DEVICEPOLARITY_LOW {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_LOW);}
| PARSEOP_DEVICEPOLARITY_HIGH {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_HIGH);}
;
DMATypeKeyword
: PARSEOP_DMATYPE_A {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);}
| PARSEOP_DMATYPE_COMPATIBILITY {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);}
| PARSEOP_DMATYPE_B {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);}
| PARSEOP_DMATYPE_F {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);}
;
EndianKeyword
: PARSEOP_ENDIAN_LITTLE {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_LITTLE);}
| PARSEOP_ENDIAN_BIG {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_BIG);}
;
FlowControlKeyword
: PARSEOP_FLOWCONTROL_HW {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_HW);}
| PARSEOP_FLOWCONTROL_NONE {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_NONE);}
| PARSEOP_FLOWCONTROL_SW {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_SW);}
;
InterruptLevel
: PARSEOP_INTLEVEL_ACTIVEBOTH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEBOTH);}
| PARSEOP_INTLEVEL_ACTIVEHIGH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);}
| PARSEOP_INTLEVEL_ACTIVELOW {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);}
;
InterruptTypeKeyword
: PARSEOP_INTTYPE_EDGE {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);}
| PARSEOP_INTTYPE_LEVEL {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);}
;
IODecodeKeyword
: PARSEOP_IODECODETYPE_16 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);}
| PARSEOP_IODECODETYPE_10 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);}
;
IoRestrictionKeyword
: PARSEOP_IORESTRICT_IN {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_IN);}
| PARSEOP_IORESTRICT_OUT {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_OUT);}
| PARSEOP_IORESTRICT_NONE {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_NONE);}
| PARSEOP_IORESTRICT_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_PRESERVE);}
;
LockRuleKeyword
: PARSEOP_LOCKRULE_LOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);}
| PARSEOP_LOCKRULE_NOLOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);}
;
MatchOpKeyword
: PARSEOP_MATCHTYPE_MTR {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);}
| PARSEOP_MATCHTYPE_MEQ {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);}
| PARSEOP_MATCHTYPE_MLE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLE);}
| PARSEOP_MATCHTYPE_MLT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLT);}
| PARSEOP_MATCHTYPE_MGE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGE);}
| PARSEOP_MATCHTYPE_MGT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGT);}
;
MaxKeyword
: PARSEOP_MAXTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);}
| PARSEOP_MAXTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);}
;
MemTypeKeyword
: PARSEOP_MEMTYPE_CACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);}
| PARSEOP_MEMTYPE_WRITECOMBINING {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);}
| PARSEOP_MEMTYPE_PREFETCHABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);}
| PARSEOP_MEMTYPE_NONCACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);}
;
MinKeyword
: PARSEOP_MINTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_FIXED);}
| PARSEOP_MINTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_NOTFIXED);}
;
ObjectTypeKeyword
: PARSEOP_OBJECTTYPE_UNK {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
| PARSEOP_OBJECTTYPE_INT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);}
| PARSEOP_OBJECTTYPE_STR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);}
| PARSEOP_OBJECTTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);}
| PARSEOP_OBJECTTYPE_PKG {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);}
| PARSEOP_OBJECTTYPE_FLD {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);}
| PARSEOP_OBJECTTYPE_DEV {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);}
| PARSEOP_OBJECTTYPE_EVT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);}
| PARSEOP_OBJECTTYPE_MTH {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);}
| PARSEOP_OBJECTTYPE_MTX {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);}
| PARSEOP_OBJECTTYPE_OPR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);}
| PARSEOP_OBJECTTYPE_POW {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);}
| PARSEOP_OBJECTTYPE_PRO {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);}
| PARSEOP_OBJECTTYPE_THZ {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);}
| PARSEOP_OBJECTTYPE_BFF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);}
| PARSEOP_OBJECTTYPE_DDB {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);}
;
ParityTypeKeyword
: PARSEOP_PARITYTYPE_SPACE {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_SPACE);}
| PARSEOP_PARITYTYPE_MARK {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_MARK);}
| PARSEOP_PARITYTYPE_ODD {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_ODD);}
| PARSEOP_PARITYTYPE_EVEN {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_EVEN);}
| PARSEOP_PARITYTYPE_NONE {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_NONE);}
;
PinConfigByte
: PinConfigKeyword {$$ = $1;}
| ByteConstExpr {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
;
PinConfigKeyword
: PARSEOP_PIN_NOPULL {$$ = TrCreateLeafNode (PARSEOP_PIN_NOPULL);}
| PARSEOP_PIN_PULLDOWN {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDOWN);}
| PARSEOP_PIN_PULLUP {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLUP);}
| PARSEOP_PIN_PULLDEFAULT {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDEFAULT);}
;
PldKeyword
: PARSEOP_PLD_REVISION {$$ = TrCreateLeafNode (PARSEOP_PLD_REVISION);}
| PARSEOP_PLD_IGNORECOLOR {$$ = TrCreateLeafNode (PARSEOP_PLD_IGNORECOLOR);}
| PARSEOP_PLD_RED {$$ = TrCreateLeafNode (PARSEOP_PLD_RED);}
| PARSEOP_PLD_GREEN {$$ = TrCreateLeafNode (PARSEOP_PLD_GREEN);}
| PARSEOP_PLD_BLUE {$$ = TrCreateLeafNode (PARSEOP_PLD_BLUE);}
| PARSEOP_PLD_WIDTH {$$ = TrCreateLeafNode (PARSEOP_PLD_WIDTH);}
| PARSEOP_PLD_HEIGHT {$$ = TrCreateLeafNode (PARSEOP_PLD_HEIGHT);}
| PARSEOP_PLD_USERVISIBLE {$$ = TrCreateLeafNode (PARSEOP_PLD_USERVISIBLE);}
| PARSEOP_PLD_DOCK {$$ = TrCreateLeafNode (PARSEOP_PLD_DOCK);}
| PARSEOP_PLD_LID {$$ = TrCreateLeafNode (PARSEOP_PLD_LID);}
| PARSEOP_PLD_PANEL {$$ = TrCreateLeafNode (PARSEOP_PLD_PANEL);}
| PARSEOP_PLD_VERTICALPOSITION {$$ = TrCreateLeafNode (PARSEOP_PLD_VERTICALPOSITION);}
| PARSEOP_PLD_HORIZONTALPOSITION {$$ = TrCreateLeafNode (PARSEOP_PLD_HORIZONTALPOSITION);}
| PARSEOP_PLD_SHAPE {$$ = TrCreateLeafNode (PARSEOP_PLD_SHAPE);}
| PARSEOP_PLD_GROUPORIENTATION {$$ = TrCreateLeafNode (PARSEOP_PLD_GROUPORIENTATION);}
| PARSEOP_PLD_GROUPTOKEN {$$ = TrCreateLeafNode (PARSEOP_PLD_GROUPTOKEN);}
| PARSEOP_PLD_GROUPPOSITION {$$ = TrCreateLeafNode (PARSEOP_PLD_GROUPPOSITION);}
| PARSEOP_PLD_BAY {$$ = TrCreateLeafNode (PARSEOP_PLD_BAY);}
| PARSEOP_PLD_EJECTABLE {$$ = TrCreateLeafNode (PARSEOP_PLD_EJECTABLE);}
| PARSEOP_PLD_EJECTREQUIRED {$$ = TrCreateLeafNode (PARSEOP_PLD_EJECTREQUIRED);}
| PARSEOP_PLD_CABINETNUMBER {$$ = TrCreateLeafNode (PARSEOP_PLD_CABINETNUMBER);}
| PARSEOP_PLD_CARDCAGENUMBER {$$ = TrCreateLeafNode (PARSEOP_PLD_CARDCAGENUMBER);}
| PARSEOP_PLD_REFERENCE {$$ = TrCreateLeafNode (PARSEOP_PLD_REFERENCE);}
| PARSEOP_PLD_ROTATION {$$ = TrCreateLeafNode (PARSEOP_PLD_ROTATION);}
| PARSEOP_PLD_ORDER {$$ = TrCreateLeafNode (PARSEOP_PLD_ORDER);}
| PARSEOP_PLD_RESERVED {$$ = TrCreateLeafNode (PARSEOP_PLD_RESERVED);}
| PARSEOP_PLD_VERTICALOFFSET {$$ = TrCreateLeafNode (PARSEOP_PLD_VERTICALOFFSET);}
| PARSEOP_PLD_HORIZONTALOFFSET {$$ = TrCreateLeafNode (PARSEOP_PLD_HORIZONTALOFFSET);}
;
RangeTypeKeyword
: PARSEOP_RANGETYPE_ISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ISAONLY);}
| PARSEOP_RANGETYPE_NONISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_NONISAONLY);}
| PARSEOP_RANGETYPE_ENTIRE {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ENTIRE);}
;
RegionSpaceKeyword
: PARSEOP_REGIONSPACE_IO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);}
| PARSEOP_REGIONSPACE_MEM {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);}
| PARSEOP_REGIONSPACE_PCI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);}
| PARSEOP_REGIONSPACE_EC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);}
| PARSEOP_REGIONSPACE_SMBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);}
| PARSEOP_REGIONSPACE_CMOS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);}
| PARSEOP_REGIONSPACE_PCIBAR {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);}
| PARSEOP_REGIONSPACE_IPMI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);}
| PARSEOP_REGIONSPACE_GPIO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GPIO);}
| PARSEOP_REGIONSPACE_GSBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GSBUS);}
| PARSEOP_REGIONSPACE_PCC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCC);}
| PARSEOP_REGIONSPACE_FFIXEDHW {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_FFIXEDHW);}
;
ResourceTypeKeyword
: PARSEOP_RESOURCETYPE_CONSUMER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
| PARSEOP_RESOURCETYPE_PRODUCER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);}
;
SerializeRuleKeyword
: PARSEOP_SERIALIZERULE_SERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);}
| PARSEOP_SERIALIZERULE_NOTSERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);}
;
ShareTypeKeyword
: PARSEOP_SHARETYPE_SHARED {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHARED);}
| PARSEOP_SHARETYPE_EXCLUSIVE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVE);}
| PARSEOP_SHARETYPE_SHAREDWAKE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHAREDWAKE);}
| PARSEOP_SHARETYPE_EXCLUSIVEWAKE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVEWAKE);}
;
SlaveModeKeyword
: PARSEOP_SLAVEMODE_CONTROLLERINIT {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_CONTROLLERINIT);}
| PARSEOP_SLAVEMODE_DEVICEINIT {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_DEVICEINIT);}
;
StopBitsKeyword
: PARSEOP_STOPBITS_TWO {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_TWO);}
| PARSEOP_STOPBITS_ONEPLUSHALF {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONEPLUSHALF);}
| PARSEOP_STOPBITS_ONE {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONE);}
| PARSEOP_STOPBITS_ZERO {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ZERO);}
;
TranslationKeyword
: PARSEOP_TRANSLATIONTYPE_SPARSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);}
| PARSEOP_TRANSLATIONTYPE_DENSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);}
;
TypeKeyword
: PARSEOP_TYPE_TRANSLATION {$$ = TrCreateLeafNode (PARSEOP_TYPE_TRANSLATION);}
| PARSEOP_TYPE_STATIC {$$ = TrCreateLeafNode (PARSEOP_TYPE_STATIC);}
;
UpdateRuleKeyword
: PARSEOP_UPDATERULE_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);}
| PARSEOP_UPDATERULE_ONES {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);}
| PARSEOP_UPDATERULE_ZEROS {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);}
;
WireModeKeyword
: PARSEOP_WIREMODE_FOUR {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_FOUR);}
| PARSEOP_WIREMODE_THREE {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_THREE);}
;
XferSizeKeyword
: PARSEOP_XFERSIZE_8 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_8, 0);}
| PARSEOP_XFERSIZE_16 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_16, 1);}
| PARSEOP_XFERSIZE_32 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
| PARSEOP_XFERSIZE_64 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_64, 3);}
| PARSEOP_XFERSIZE_128 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_128, 4);}
| PARSEOP_XFERSIZE_256 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_256, 5);}
;
XferTypeKeyword
: PARSEOP_XFERTYPE_8 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);}
| PARSEOP_XFERTYPE_8_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);}
| PARSEOP_XFERTYPE_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);}
;

324
sys/contrib/dev/acpica/compiler/aslmain.c
View file

@ -76,137 +76,112 @@ AslInitialize (
/*******************************************************************************
*
* FUNCTION: Usage
* FUNCTION: main
*
* PARAMETERS: None
* PARAMETERS: Standard argc/argv
*
* RETURN: None
* RETURN: Program termination code
*
* DESCRIPTION: Display option help message.
* Optional items in square brackets.
* DESCRIPTION: C main routine for the iASL Compiler/Disassembler. Process
* command line options and begin the compile/disassembly for each file on
* the command line (wildcards supported).
*
******************************************************************************/
void
Usage (
void)
int ACPI_SYSTEM_XFACE
main (
int argc,
char **argv)
{
printf ("%s\n\n", ASL_COMPLIANCE);
ACPI_USAGE_HEADER ("iasl [Options] [Files]");
printf ("\nGeneral:\n");
ACPI_OPTION ("-@ <file>", "Specify command file");
ACPI_OPTION ("-I <dir>", "Specify additional include directory");
ACPI_OPTION ("-T <sig list>|ALL", "Create ACPI table template/example files");
ACPI_OPTION ("-T <count>", "Emit DSDT and <count> SSDTs to same file");
ACPI_OPTION ("-p <prefix>", "Specify path/filename prefix for all output files");
ACPI_OPTION ("-v", "Display compiler version");
ACPI_OPTION ("-vo", "Enable optimization comments");
ACPI_OPTION ("-vs", "Disable signon");
printf ("\nHelp:\n");
ACPI_OPTION ("-h", "This message");
ACPI_OPTION ("-hc", "Display operators allowed in constant expressions");
ACPI_OPTION ("-hf", "Display help for output filename generation");
ACPI_OPTION ("-hr", "Display ACPI reserved method names");
ACPI_OPTION ("-ht", "Display currently supported ACPI table names");
printf ("\nPreprocessor:\n");
ACPI_OPTION ("-D <symbol>", "Define symbol for preprocessor use");
ACPI_OPTION ("-li", "Create preprocessed output file (*.i)");
ACPI_OPTION ("-P", "Preprocess only and create preprocessor output file (*.i)");
ACPI_OPTION ("-Pn", "Disable preprocessor");
printf ("\nErrors, Warnings, and Remarks:\n");
ACPI_OPTION ("-va", "Disable all errors/warnings/remarks");
ACPI_OPTION ("-ve", "Report only errors (ignore warnings and remarks)");
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 ("-w1 -w2 -w3", "Set warning reporting level");
ACPI_OPTION ("-we", "Report warnings as errors");
printf ("\nAML Code Generation (*.aml):\n");
ACPI_OPTION ("-oa", "Disable all optimizations (compatibility mode)");
ACPI_OPTION ("-of", "Disable constant folding");
ACPI_OPTION ("-oi", "Disable integer optimization to Zero/One/Ones");
ACPI_OPTION ("-on", "Disable named reference string optimization");
ACPI_OPTION ("-ot", "Disable typechecking");
ACPI_OPTION ("-cr", "Disable Resource Descriptor error checking");
ACPI_OPTION ("-in", "Ignore NoOp operators");
ACPI_OPTION ("-r <revision>", "Override table header Revision (1-255)");
printf ("\nOptional Source Code Output Files:\n");
ACPI_OPTION ("-sc -sa", "Create source file in C or assembler (*.c or *.asm)");
ACPI_OPTION ("-ic -ia", "Create include file in C or assembler (*.h or *.inc)");
ACPI_OPTION ("-tc -ta -ts", "Create hex AML table in C, assembler, or ASL (*.hex)");
ACPI_OPTION ("-so", "Create offset table in C (*.offset.h)");
printf ("\nOptional Listing Files:\n");
ACPI_OPTION ("-l", "Create mixed listing file (ASL source and AML) (*.lst)");
ACPI_OPTION ("-lm", "Create hardware summary map file (*.map)");
ACPI_OPTION ("-ln", "Create namespace file (*.nsp)");
ACPI_OPTION ("-ls", "Create combined source file (expanded includes) (*.src)");
ACPI_OPTION ("-lx", "Create cross-reference file (*.xrf)");
printf ("\nData Table Compiler:\n");
ACPI_OPTION ("-G", "Compile custom table that contains generic operators");
ACPI_OPTION ("-vt", "Create verbose template files (full disassembly)");
printf ("\nAML Disassembler:\n");
ACPI_OPTION ("-d <f1 f2 ...>", "Disassemble or decode binary ACPI tables to file (*.dsl)");
ACPI_OPTION ("", " (Optional, file type is automatically detected)");
ACPI_OPTION ("-da <f1 f2 ...>", "Disassemble multiple tables from single namespace");
ACPI_OPTION ("-db", "Do not translate Buffers to Resource Templates");
ACPI_OPTION ("-dc <f1 f2 ...>", "Disassemble AML and immediately compile it");
ACPI_OPTION ("", " (Obtain DSDT from current system if no input file)");
ACPI_OPTION ("-df", "Force disassembler to assume table contains valid AML");
ACPI_OPTION ("-dl", "Emit legacy ASL code only (no C-style operators)");
ACPI_OPTION ("-e <f1 f2 ...>", "Include ACPI table(s) for external symbol resolution");
ACPI_OPTION ("-fe <file>", "Specify external symbol declaration file");
ACPI_OPTION ("-in", "Ignore NoOp opcodes");
ACPI_OPTION ("-l", "Disassemble to mixed ASL and AML code");
ACPI_OPTION ("-vt", "Dump binary table data in hex format within output file");
printf ("\nDebug Options:\n");
ACPI_OPTION ("-bf", "Create debug file (full output) (*.txt)");
ACPI_OPTION ("-bs", "Create debug file (parse tree only) (*.txt)");
ACPI_OPTION ("-bp <depth>", "Prune ASL parse tree");
ACPI_OPTION ("-bt <type>", "Object type to be pruned from the parse tree");
ACPI_OPTION ("-f", "Ignore errors, force creation of AML output file(s)");
ACPI_OPTION ("-m <size>", "Set internal line buffer size (in Kbytes)");
ACPI_OPTION ("-n", "Parse only, no output generation");
ACPI_OPTION ("-oc", "Display compile times and statistics");
ACPI_OPTION ("-x <level>", "Set debug level for trace output");
ACPI_OPTION ("-z", "Do not insert new compiler ID for DataTables");
}
ACPI_STATUS Status;
int Index1;
int Index2;
int ReturnStatus = 0;
/*******************************************************************************
*
* FUNCTION: FilenameHelp
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Display help message for output filename generation
*
******************************************************************************/
/*
* Big-endian machines are not currently supported. ACPI tables must
* be little-endian, and support for big-endian machines needs to
* be implemented.
*/
if (UtIsBigEndianMachine ())
{
fprintf (stderr,
"iASL is not currently supported on big-endian machines.\n");
return (-1);
}
void
AslFilenameHelp (
void)
{
AcpiOsInitialize ();
ACPI_DEBUG_INITIALIZE (); /* For debug version only */
printf ("\nAML output filename generation:\n");
printf (" Output filenames are generated by appending an extension to a common\n");
printf (" filename prefix. The filename prefix is obtained via one of the\n");
printf (" following methods (in priority order):\n");
printf (" 1) The -p option specifies the prefix\n");
printf (" 2) The prefix of the AMLFileName in the ASL Definition Block\n");
printf (" 3) The prefix of the input filename\n");
printf ("\n");
/* Initialize preprocessor and compiler before command line processing */
signal (SIGINT, AslSignalHandler);
AcpiGbl_ExternalFileList = NULL;
AcpiDbgLevel = 0;
PrInitializePreprocessor ();
AslInitialize ();
Index1 = Index2 =
AslCommandLine (argc, argv);
/* Allocate the line buffer(s), must be after command line */
Gbl_LineBufferSize /= 2;
UtExpandLineBuffers ();
/* Perform global actions first/only */
if (Gbl_DisassembleAll)
{
while (argv[Index1])
{
Status = AcpiDmAddToExternalFileList (argv[Index1]);
if (ACPI_FAILURE (Status))
{
return (-1);
}
Index1++;
}
}
/* Process each pathname/filename in the list, with possible wildcards */
while (argv[Index2])
{
/*
* If -p not specified, we will use the input filename as the
* output filename prefix
*/
if (Gbl_UseDefaultAmlFilename)
{
Gbl_OutputFilenamePrefix = argv[Index2];
UtConvertBackslashes (Gbl_OutputFilenamePrefix);
}
Status = AslDoOneFile (argv[Index2]);
if (ACPI_FAILURE (Status))
{
ReturnStatus = -1;
goto CleanupAndExit;
}
Index2++;
}
CleanupAndExit:
UtFreeLineBuffers ();
AslParserCleanup ();
if (AcpiGbl_ExternalFileList)
{
AcpiDmClearExternalFileList();
}
return (ReturnStatus);
}
@ -292,112 +267,3 @@ AslInitialize (
Gbl_Files[ASL_FILE_STDERR].Handle = stderr;
Gbl_Files[ASL_FILE_STDERR].Filename = "STDERR";
}
/*******************************************************************************
*
* FUNCTION: main
*
* PARAMETERS: Standard argc/argv
*
* RETURN: Program termination code
*
* DESCRIPTION: C main routine for the Asl Compiler. Handle command line
* options and begin the compile for each file on the command line
*
******************************************************************************/
int ACPI_SYSTEM_XFACE
main (
int argc,
char **argv)
{
ACPI_STATUS Status;
int Index1;
int Index2;
int ReturnStatus = 0;
/*
* Big-endian machines are not currently supported. ACPI tables must
* be little-endian, and support for big-endian machines needs to
* be implemented.
*/
if (UtIsBigEndianMachine ())
{
fprintf (stderr,
"iASL is not currently supported on big-endian machines.\n");
return (-1);
}
AcpiOsInitialize ();
ACPI_DEBUG_INITIALIZE (); /* For debug version only */
/* Initialize preprocessor and compiler before command line processing */
signal (SIGINT, AslSignalHandler);
AcpiGbl_ExternalFileList = NULL;
AcpiDbgLevel = 0;
PrInitializePreprocessor ();
AslInitialize ();
Index1 = Index2 = AslCommandLine (argc, argv);
/* Allocate the line buffer(s), must be after command line */
Gbl_LineBufferSize /= 2;
UtExpandLineBuffers ();
/* Perform global actions first/only */
if (Gbl_DisassembleAll)
{
while (argv[Index1])
{
Status = AcpiDmAddToExternalFileList (argv[Index1]);
if (ACPI_FAILURE (Status))
{
return (-1);
}
Index1++;
}
}
/* Process each pathname/filename in the list, with possible wildcards */
while (argv[Index2])
{
/*
* If -p not specified, we will use the input filename as the
* output filename prefix
*/
if (Gbl_UseDefaultAmlFilename)
{
Gbl_OutputFilenamePrefix = argv[Index2];
UtConvertBackslashes (Gbl_OutputFilenamePrefix);
}
Status = AslDoOneFile (argv[Index2]);
if (ACPI_FAILURE (Status))
{
ReturnStatus = -1;
goto CleanupAndExit;
}
Index2++;
}
CleanupAndExit:
UtFreeLineBuffers ();
AslParserCleanup ();
if (AcpiGbl_ExternalFileList)
{
AcpiDmClearExternalFileList();
}
return (ReturnStatus);
}

6
sys/contrib/dev/acpica/compiler/aslmaputils.c
View file

@ -80,6 +80,12 @@ MpGetHidFromParseTree (
Op = HidNode->Op;
if (!Op)
{
/* Object is not resolved, probably an External */
return ("Unresolved Symbol - referenced but not defined in this table");
}
switch (Op->Asl.ParseOpcode)
{

14
sys/contrib/dev/acpica/compiler/asloperands.c
View file

@ -351,6 +351,20 @@ OpnDoFieldCommon (
NewBitOffset = (UINT32) PkgLengthNode->Asl.Value.Integer;
CurrentBitOffset += NewBitOffset;
if ((NewBitOffset == 0) &&
(Next->Asl.ParseOpcode == PARSEOP_RESERVED_BYTES))
{
/*
* Unnamed field with a bit length of zero. We can
* safely just ignore this. However, we will not ignore
* a named field of zero length, we don't want to just
* toss out a name.
*/
Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
break;
}
/* Save the current AccessAs value for error checking later */
switch (AccessType)

2
sys/contrib/dev/acpica/compiler/aslopt.c
View file

@ -133,7 +133,7 @@ OptSearchToRoot (
* not match, and we cannot use this optimization.
*/
Path = &(((char *) TargetPath->Pointer)[
TargetPath->Length - ACPI_NAME_SIZE]),
TargetPath->Length - ACPI_NAME_SIZE]);
ScopeInfo.Scope.Node = CurrentNode;
/* Lookup the NameSeg using SEARCH_PARENT (search-to-root) */

35
sys/contrib/dev/acpica/compiler/asloptions.c
View file

@ -70,6 +70,9 @@ AslDoResponseFile (
#define ASL_TOKEN_SEPARATORS " \t\n"
#define ASL_SUPPORTED_OPTIONS "@:a:b|c|d^D:e:f^gh^i|I:l^m:no|p:P^r:s|t|T+G^v^w|x:z"
static char ASL_BUILD_DATE[] = __DATE__;
static char ASL_BUILD_TIME[] = __TIME__;
/*******************************************************************************
*
@ -275,11 +278,25 @@ AslDoOptions (
{
case '^':
/* Get the required argument */
if (AcpiGetoptArgument (argc, argv))
{
return (-1);
}
Gbl_DoCompile = FALSE;
break;
case 'a':
/* Get the required argument */
if (AcpiGetoptArgument (argc, argv))
{
return (-1);
}
Gbl_DoCompile = FALSE;
Gbl_DisassembleAll = TRUE;
break;
@ -390,6 +407,11 @@ AslDoOptions (
UtDisplayConstantOpcodes ();
exit (0);
case 'd':
AslDisassemblyHelp ();
exit (0);
case 'f':
AslFilenameHelp ();
@ -539,6 +561,13 @@ AslDoOptions (
Gbl_CompileTimesFlag = TRUE;
break;
case 'd':
/* Disable disassembler code optimizations */
AcpiGbl_DoDisassemblerOptimizations = FALSE;
break;
case 'e':
/* iASL: Disable External opcode generation */
@ -698,6 +727,12 @@ AslDoOptions (
Gbl_NoErrors = TRUE;
break;
case 'd':
printf ("%s Build date/time: %s %s\n",
ASL_COMPILER_NAME, ASL_BUILD_DATE, ASL_BUILD_TIME);
exit (0);
case 'e':
/* Disable all warning/remark messages (errors only) */

6
sys/contrib/dev/acpica/compiler/aslparser.y
View file

@ -66,6 +66,7 @@ void *
AslLocalAllocate (
unsigned int Size);
/* Bison/yacc configuration */
#define static
@ -99,7 +100,7 @@ AslLocalAllocate (
* These shift/reduce conflicts are expected. There should be zero
* reduce/reduce conflicts.
*/
%expect 101
%expect 102
/*! [Begin] no source code translation */
@ -122,8 +123,11 @@ m4_include(asltypes.y)
/* Production rules */
m4_include(aslrules.y)
m4_include(aslprimaries.y)
m4_include(aslcstyle.y)
m4_include(aslkeywords.y)
m4_include(aslresources.y)
m4_include(aslhelpers.y)
%%
/*! [End] no source code translation !*/

1160
sys/contrib/dev/acpica/compiler/aslprimaries.y Normal file
View file

File diff suppressed because it is too large Load diff

621
sys/contrib/dev/acpica/compiler/aslresources.y
View file

@ -44,313 +44,6 @@ NoEcho('
')
/*******************************************************************************
*
* ASL Parameter Keyword Terms
*
******************************************************************************/
AccessAttribKeyword
: PARSEOP_ACCESSATTRIB_BLOCK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);}
| PARSEOP_ACCESSATTRIB_BLOCK_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);}
| PARSEOP_ACCESSATTRIB_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);}
| PARSEOP_ACCESSATTRIB_QUICK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );}
| PARSEOP_ACCESSATTRIB_SND_RCV {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);}
| PARSEOP_ACCESSATTRIB_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);}
| PARSEOP_ACCESSATTRIB_WORD_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);}
| PARSEOP_ACCESSATTRIB_MULTIBYTE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_MULTIBYTE);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_BYTES '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_BYTES);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ACCESSATTRIB_RAW_PROCESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_PROCESS);}
ByteConst
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
;
AccessTypeKeyword
: PARSEOP_ACCESSTYPE_ANY {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_ANY);}
| PARSEOP_ACCESSTYPE_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BYTE);}
| PARSEOP_ACCESSTYPE_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_WORD);}
| PARSEOP_ACCESSTYPE_DWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_DWORD);}
| PARSEOP_ACCESSTYPE_QWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_QWORD);}
| PARSEOP_ACCESSTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BUF);}
;
AddressingModeKeyword
: PARSEOP_ADDRESSINGMODE_7BIT {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_7BIT);}
| PARSEOP_ADDRESSINGMODE_10BIT {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_10BIT);}
;
AddressKeyword
: PARSEOP_ADDRESSTYPE_MEMORY {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);}
| PARSEOP_ADDRESSTYPE_RESERVED {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);}
| PARSEOP_ADDRESSTYPE_NVS {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);}
| PARSEOP_ADDRESSTYPE_ACPI {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);}
;
AddressSpaceKeyword
: ByteConst {$$ = UtCheckIntegerRange ($1, 0x0A, 0xFF);}
| RegionSpaceKeyword {}
;
BitsPerByteKeyword
: PARSEOP_BITSPERBYTE_FIVE {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_FIVE);}
| PARSEOP_BITSPERBYTE_SIX {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SIX);}
| PARSEOP_BITSPERBYTE_SEVEN {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SEVEN);}
| PARSEOP_BITSPERBYTE_EIGHT {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_EIGHT);}
| PARSEOP_BITSPERBYTE_NINE {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_NINE);}
;
ClockPhaseKeyword
: PARSEOP_CLOCKPHASE_FIRST {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_FIRST);}
| PARSEOP_CLOCKPHASE_SECOND {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_SECOND);}
;
ClockPolarityKeyword
: PARSEOP_CLOCKPOLARITY_LOW {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_LOW);}
| PARSEOP_CLOCKPOLARITY_HIGH {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_HIGH);}
;
DecodeKeyword
: PARSEOP_DECODETYPE_POS {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);}
| PARSEOP_DECODETYPE_SUB {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);}
;
DevicePolarityKeyword
: PARSEOP_DEVICEPOLARITY_LOW {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_LOW);}
| PARSEOP_DEVICEPOLARITY_HIGH {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_HIGH);}
;
DMATypeKeyword
: PARSEOP_DMATYPE_A {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);}
| PARSEOP_DMATYPE_COMPATIBILITY {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);}
| PARSEOP_DMATYPE_B {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);}
| PARSEOP_DMATYPE_F {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);}
;
EndianKeyword
: PARSEOP_ENDIAN_LITTLE {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_LITTLE);}
| PARSEOP_ENDIAN_BIG {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_BIG);}
;
FlowControlKeyword
: PARSEOP_FLOWCONTROL_HW {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_HW);}
| PARSEOP_FLOWCONTROL_NONE {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_NONE);}
| PARSEOP_FLOWCONTROL_SW {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_SW);}
;
InterruptLevel
: PARSEOP_INTLEVEL_ACTIVEBOTH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEBOTH);}
| PARSEOP_INTLEVEL_ACTIVEHIGH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);}
| PARSEOP_INTLEVEL_ACTIVELOW {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);}
;
InterruptTypeKeyword
: PARSEOP_INTTYPE_EDGE {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);}
| PARSEOP_INTTYPE_LEVEL {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);}
;
IODecodeKeyword
: PARSEOP_IODECODETYPE_16 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);}
| PARSEOP_IODECODETYPE_10 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);}
;
IoRestrictionKeyword
: PARSEOP_IORESTRICT_IN {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_IN);}
| PARSEOP_IORESTRICT_OUT {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_OUT);}
| PARSEOP_IORESTRICT_NONE {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_NONE);}
| PARSEOP_IORESTRICT_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_PRESERVE);}
;
LockRuleKeyword
: PARSEOP_LOCKRULE_LOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);}
| PARSEOP_LOCKRULE_NOLOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);}
;
MatchOpKeyword
: PARSEOP_MATCHTYPE_MTR {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);}
| PARSEOP_MATCHTYPE_MEQ {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);}
| PARSEOP_MATCHTYPE_MLE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLE);}
| PARSEOP_MATCHTYPE_MLT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLT);}
| PARSEOP_MATCHTYPE_MGE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGE);}
| PARSEOP_MATCHTYPE_MGT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGT);}
;
MaxKeyword
: PARSEOP_MAXTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);}
| PARSEOP_MAXTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);}
;
MemTypeKeyword
: PARSEOP_MEMTYPE_CACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);}
| PARSEOP_MEMTYPE_WRITECOMBINING {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);}
| PARSEOP_MEMTYPE_PREFETCHABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);}
| PARSEOP_MEMTYPE_NONCACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);}
;
MinKeyword
: PARSEOP_MINTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_FIXED);}
| PARSEOP_MINTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_NOTFIXED);}
;
ObjectTypeKeyword
: PARSEOP_OBJECTTYPE_UNK {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
| PARSEOP_OBJECTTYPE_INT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);}
| PARSEOP_OBJECTTYPE_STR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);}
| PARSEOP_OBJECTTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);}
| PARSEOP_OBJECTTYPE_PKG {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);}
| PARSEOP_OBJECTTYPE_FLD {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);}
| PARSEOP_OBJECTTYPE_DEV {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);}
| PARSEOP_OBJECTTYPE_EVT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);}
| PARSEOP_OBJECTTYPE_MTH {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);}
| PARSEOP_OBJECTTYPE_MTX {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);}
| PARSEOP_OBJECTTYPE_OPR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);}
| PARSEOP_OBJECTTYPE_POW {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);}
| PARSEOP_OBJECTTYPE_PRO {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);}
| PARSEOP_OBJECTTYPE_THZ {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);}
| PARSEOP_OBJECTTYPE_BFF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);}
| PARSEOP_OBJECTTYPE_DDB {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);}
;
ParityTypeKeyword
: PARSEOP_PARITYTYPE_SPACE {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_SPACE);}
| PARSEOP_PARITYTYPE_MARK {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_MARK);}
| PARSEOP_PARITYTYPE_ODD {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_ODD);}
| PARSEOP_PARITYTYPE_EVEN {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_EVEN);}
| PARSEOP_PARITYTYPE_NONE {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_NONE);}
;
PinConfigByte
: PinConfigKeyword {$$ = $1;}
| ByteConstExpr {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
;
PinConfigKeyword
: PARSEOP_PIN_NOPULL {$$ = TrCreateLeafNode (PARSEOP_PIN_NOPULL);}
| PARSEOP_PIN_PULLDOWN {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDOWN);}
| PARSEOP_PIN_PULLUP {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLUP);}
| PARSEOP_PIN_PULLDEFAULT {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDEFAULT);}
;
PldKeyword
: PARSEOP_PLD_REVISION {$$ = TrCreateLeafNode (PARSEOP_PLD_REVISION);}
| PARSEOP_PLD_IGNORECOLOR {$$ = TrCreateLeafNode (PARSEOP_PLD_IGNORECOLOR);}
| PARSEOP_PLD_RED {$$ = TrCreateLeafNode (PARSEOP_PLD_RED);}
| PARSEOP_PLD_GREEN {$$ = TrCreateLeafNode (PARSEOP_PLD_GREEN);}
| PARSEOP_PLD_BLUE {$$ = TrCreateLeafNode (PARSEOP_PLD_BLUE);}
| PARSEOP_PLD_WIDTH {$$ = TrCreateLeafNode (PARSEOP_PLD_WIDTH);}
| PARSEOP_PLD_HEIGHT {$$ = TrCreateLeafNode (PARSEOP_PLD_HEIGHT);}
| PARSEOP_PLD_USERVISIBLE {$$ = TrCreateLeafNode (PARSEOP_PLD_USERVISIBLE);}
| PARSEOP_PLD_DOCK {$$ = TrCreateLeafNode (PARSEOP_PLD_DOCK);}
| PARSEOP_PLD_LID {$$ = TrCreateLeafNode (PARSEOP_PLD_LID);}
| PARSEOP_PLD_PANEL {$$ = TrCreateLeafNode (PARSEOP_PLD_PANEL);}
| PARSEOP_PLD_VERTICALPOSITION {$$ = TrCreateLeafNode (PARSEOP_PLD_VERTICALPOSITION);}
| PARSEOP_PLD_HORIZONTALPOSITION {$$ = TrCreateLeafNode (PARSEOP_PLD_HORIZONTALPOSITION);}
| PARSEOP_PLD_SHAPE {$$ = TrCreateLeafNode (PARSEOP_PLD_SHAPE);}
| PARSEOP_PLD_GROUPORIENTATION {$$ = TrCreateLeafNode (PARSEOP_PLD_GROUPORIENTATION);}
| PARSEOP_PLD_GROUPTOKEN {$$ = TrCreateLeafNode (PARSEOP_PLD_GROUPTOKEN);}
| PARSEOP_PLD_GROUPPOSITION {$$ = TrCreateLeafNode (PARSEOP_PLD_GROUPPOSITION);}
| PARSEOP_PLD_BAY {$$ = TrCreateLeafNode (PARSEOP_PLD_BAY);}
| PARSEOP_PLD_EJECTABLE {$$ = TrCreateLeafNode (PARSEOP_PLD_EJECTABLE);}
| PARSEOP_PLD_EJECTREQUIRED {$$ = TrCreateLeafNode (PARSEOP_PLD_EJECTREQUIRED);}
| PARSEOP_PLD_CABINETNUMBER {$$ = TrCreateLeafNode (PARSEOP_PLD_CABINETNUMBER);}
| PARSEOP_PLD_CARDCAGENUMBER {$$ = TrCreateLeafNode (PARSEOP_PLD_CARDCAGENUMBER);}
| PARSEOP_PLD_REFERENCE {$$ = TrCreateLeafNode (PARSEOP_PLD_REFERENCE);}
| PARSEOP_PLD_ROTATION {$$ = TrCreateLeafNode (PARSEOP_PLD_ROTATION);}
| PARSEOP_PLD_ORDER {$$ = TrCreateLeafNode (PARSEOP_PLD_ORDER);}
| PARSEOP_PLD_RESERVED {$$ = TrCreateLeafNode (PARSEOP_PLD_RESERVED);}
| PARSEOP_PLD_VERTICALOFFSET {$$ = TrCreateLeafNode (PARSEOP_PLD_VERTICALOFFSET);}
| PARSEOP_PLD_HORIZONTALOFFSET {$$ = TrCreateLeafNode (PARSEOP_PLD_HORIZONTALOFFSET);}
;
RangeTypeKeyword
: PARSEOP_RANGETYPE_ISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ISAONLY);}
| PARSEOP_RANGETYPE_NONISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_NONISAONLY);}
| PARSEOP_RANGETYPE_ENTIRE {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ENTIRE);}
;
RegionSpaceKeyword
: PARSEOP_REGIONSPACE_IO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);}
| PARSEOP_REGIONSPACE_MEM {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);}
| PARSEOP_REGIONSPACE_PCI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);}
| PARSEOP_REGIONSPACE_EC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);}
| PARSEOP_REGIONSPACE_SMBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);}
| PARSEOP_REGIONSPACE_CMOS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);}
| PARSEOP_REGIONSPACE_PCIBAR {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);}
| PARSEOP_REGIONSPACE_IPMI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);}
| PARSEOP_REGIONSPACE_GPIO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GPIO);}
| PARSEOP_REGIONSPACE_GSBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GSBUS);}
| PARSEOP_REGIONSPACE_PCC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCC);}
| PARSEOP_REGIONSPACE_FFIXEDHW {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_FFIXEDHW);}
;
ResourceTypeKeyword
: PARSEOP_RESOURCETYPE_CONSUMER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
| PARSEOP_RESOURCETYPE_PRODUCER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);}
;
SerializeRuleKeyword
: PARSEOP_SERIALIZERULE_SERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);}
| PARSEOP_SERIALIZERULE_NOTSERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);}
;
ShareTypeKeyword
: PARSEOP_SHARETYPE_SHARED {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHARED);}
| PARSEOP_SHARETYPE_EXCLUSIVE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVE);}
| PARSEOP_SHARETYPE_SHAREDWAKE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHAREDWAKE);}
| PARSEOP_SHARETYPE_EXCLUSIVEWAKE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVEWAKE);}
;
SlaveModeKeyword
: PARSEOP_SLAVEMODE_CONTROLLERINIT {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_CONTROLLERINIT);}
| PARSEOP_SLAVEMODE_DEVICEINIT {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_DEVICEINIT);}
;
StopBitsKeyword
: PARSEOP_STOPBITS_TWO {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_TWO);}
| PARSEOP_STOPBITS_ONEPLUSHALF {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONEPLUSHALF);}
| PARSEOP_STOPBITS_ONE {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONE);}
| PARSEOP_STOPBITS_ZERO {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ZERO);}
;
TranslationKeyword
: PARSEOP_TRANSLATIONTYPE_SPARSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);}
| PARSEOP_TRANSLATIONTYPE_DENSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);}
;
TypeKeyword
: PARSEOP_TYPE_TRANSLATION {$$ = TrCreateLeafNode (PARSEOP_TYPE_TRANSLATION);}
| PARSEOP_TYPE_STATIC {$$ = TrCreateLeafNode (PARSEOP_TYPE_STATIC);}
;
UpdateRuleKeyword
: PARSEOP_UPDATERULE_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);}
| PARSEOP_UPDATERULE_ONES {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);}
| PARSEOP_UPDATERULE_ZEROS {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);}
;
WireModeKeyword
: PARSEOP_WIREMODE_FOUR {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_FOUR);}
| PARSEOP_WIREMODE_THREE {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_THREE);}
;
XferSizeKeyword
: PARSEOP_XFERSIZE_8 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_8, 0);}
| PARSEOP_XFERSIZE_16 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_16, 1);}
| PARSEOP_XFERSIZE_32 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
| PARSEOP_XFERSIZE_64 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_64, 3);}
| PARSEOP_XFERSIZE_128 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_128, 4);}
| PARSEOP_XFERSIZE_256 {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_256, 5);}
;
XferTypeKeyword
: PARSEOP_XFERTYPE_8 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);}
| PARSEOP_XFERTYPE_8_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);}
| PARSEOP_XFERTYPE_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);}
;
/*******************************************************************************
*
@ -363,15 +56,20 @@ XferTypeKeyword
* Also, insert the EndTag at the end of the template.
*/
ResourceTemplateTerm
: PARSEOP_RESOURCETEMPLATE '(' ')'
: PARSEOP_RESOURCETEMPLATE OptionalParentheses
'{'
ResourceMacroList '}' {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,4,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
$5,
$4,
TrCreateLeafNode (PARSEOP_ENDTAG));}
;
OptionalParentheses
: {$$ = NULL;}
| '(' ')' {$$ = NULL;}
;
ResourceMacroList
: {$$ = NULL;}
| ResourceMacroList
@ -446,7 +144,8 @@ DWordIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
')' {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
| PARSEOP_DWORDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -469,7 +168,8 @@ DWordMemoryTerm
OptionalNameString
OptionalAddressRange
OptionalType_Last
')' {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
')' {$$ = TrLinkChildren ($<n>3,16,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
| PARSEOP_DWORDMEMORY '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -490,7 +190,8 @@ DWordSpaceTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
')' {$$ = TrLinkChildren ($<n>3,14,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
| PARSEOP_DWORDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -518,7 +219,8 @@ ExtendedIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);}
')' {$$ = TrLinkChildren ($<n>3,14,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);}
| PARSEOP_EXTENDEDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -540,7 +242,8 @@ ExtendedMemoryTerm
OptionalNameString
OptionalAddressRange
OptionalType_Last
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);}
')' {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);}
| PARSEOP_EXTENDEDMEMORY '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -560,7 +263,8 @@ ExtendedSpaceTerm
',' QWordConstExpr
OptionalQWordConstExpr
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,13,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);}
')' {$$ = TrLinkChildren ($<n>3,13,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);}
| PARSEOP_EXTENDEDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -599,7 +303,8 @@ GpioIntTerm
OptionalNameString /* 15: DescriptorName */
OptionalBuffer_Last /* 16: VendorData */
')' '{'
DWordConstExpr '}' {$$ = TrLinkChildren ($<n>3,11,$4,$6,$7,$9,$10,$12,$13,$14,$15,$16,$19);}
DWordConstExpr '}' {$$ = TrLinkChildren ($<n>3,11,
$4,$6,$7,$9,$10,$12,$13,$14,$15,$16,$19);}
| PARSEOP_GPIO_INT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -617,7 +322,8 @@ GpioIoTerm
OptionalNameString /* 14: DescriptorName */
OptionalBuffer_Last /* 15: VendorData */
')' '{'
DWordList '}' {$$ = TrLinkChildren ($<n>3,11,$4,$6,$7,$8,$9,$11,$12,$13,$14,$15,$18);}
DWordList '}' {$$ = TrLinkChildren ($<n>3,11,
$4,$6,$7,$8,$9,$11,$12,$13,$14,$15,$18);}
| PARSEOP_GPIO_IO '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -633,7 +339,8 @@ I2cSerialBusTerm
OptionalResourceType /* 12: ResourceType */
OptionalNameString /* 13: DescriptorName */
OptionalBuffer_Last /* 14: VendorData */
')' {$$ = TrLinkChildren ($<n>3,10,$4,$5,$7,$8,$10,$11,$12,$13,
')' {$$ = TrLinkChildren ($<n>3,10,
$4,$5,$7,$8,$10,$11,$12,$13,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$14);}
| PARSEOP_I2C_SERIALBUS '('
error ')' {$$ = AslDoError(); yyclearin;}
@ -651,8 +358,8 @@ I2cSerialBusTermV2
OptionalNameString /* 13: DescriptorName */
OptionalShareType /* 14: Share */
OptionalBuffer_Last /* 15: VendorData */
')' {$$ = TrLinkChildren ($<n>3,10,$4,$5,$7,$8,$10,$11,$12,$13,
$14,$15);}
')' {$$ = TrLinkChildren ($<n>3,10,
$4,$5,$7,$8,$10,$11,$12,$13,$14,$15);}
| PARSEOP_I2C_SERIALBUS_V2 '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -667,7 +374,8 @@ InterruptTerm
OptionalStringData
OptionalNameString_Last
')' '{'
DWordList '}' {$$ = TrLinkChildren ($<n>3,8,$4,$6,$8,$9,$10,$11,$12,$15);}
DWordList '}' {$$ = TrLinkChildren ($<n>3,8,
$4,$6,$8,$9,$10,$11,$12,$15);}
| PARSEOP_INTERRUPT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -760,7 +468,8 @@ QWordIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
')' {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
| PARSEOP_QWORDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -783,7 +492,8 @@ QWordMemoryTerm
OptionalNameString
OptionalAddressRange
OptionalType_Last
')' {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
')' {$$ = TrLinkChildren ($<n>3,16,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
| PARSEOP_QWORDMEMORY '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -804,7 +514,8 @@ QWordSpaceTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
')' {$$ = TrLinkChildren ($<n>3,14,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
| PARSEOP_QWORDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -837,7 +548,8 @@ SpiSerialBusTerm
OptionalResourceType /* 19: ResourceType */
OptionalNameString /* 20: DescriptorName */
OptionalBuffer_Last /* 21: VendorData */
')' {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,
')' {$$ = TrLinkChildren ($<n>3,14,
$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$21);}
| PARSEOP_SPI_SERIALBUS '('
error ')' {$$ = AslDoError(); yyclearin;}
@ -859,8 +571,8 @@ SpiSerialBusTermV2
OptionalNameString /* 20: DescriptorName */
OptionalShareType /* 21: Share */
OptionalBuffer_Last /* 22: VendorData */
')' {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,
$21,$22);}
')' {$$ = TrLinkChildren ($<n>3,14,
$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,$21,$22);}
| PARSEOP_SPI_SERIALBUS_V2 '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -899,7 +611,8 @@ UartSerialBusTerm
OptionalResourceType /* 19: ResourceType */
OptionalNameString /* 20: DescriptorName */
OptionalBuffer_Last /* 21: VendorData */
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,
')' {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$21);}
| PARSEOP_UART_SERIALBUS '('
error ')' {$$ = AslDoError(); yyclearin;}
@ -922,8 +635,8 @@ UartSerialBusTermV2
OptionalNameString /* 20: DescriptorName */
OptionalShareType /* 21: Share */
OptionalBuffer_Last /* 22: VendorData */
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,
$21,$22);}
')' {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,$21,$22);}
| PARSEOP_UART_SERIALBUS_V2 '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -960,7 +673,8 @@ WordBusNumberTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,12,$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);}
')' {$$ = TrLinkChildren ($<n>3,12,
$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);}
| PARSEOP_WORDBUSNUMBER '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -982,7 +696,8 @@ WordIOTerm
OptionalNameString
OptionalType
OptionalTranslationType_Last
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
')' {$$ = TrLinkChildren ($<n>3,15,
$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
| PARSEOP_WORDIO '('
error ')' {$$ = AslDoError(); yyclearin;}
;
@ -1003,246 +718,8 @@ WordSpaceTerm
OptionalByteConstExpr
OptionalStringData
OptionalNameString_Last
')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
')' {$$ = TrLinkChildren ($<n>3,14,
$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
| PARSEOP_WORDSPACE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
/******* Object References ***********************************************/
/* Allow IO, DMA, IRQ Resource macro names to also be used as identifiers */
NameString
: NameSeg {}
| PARSEOP_NAMESTRING {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) AslCompilerlval.s);}
| PARSEOP_IO {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");}
| PARSEOP_DMA {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");}
| PARSEOP_IRQ {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");}
;
NameSeg
: PARSEOP_NAMESEG {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG, (ACPI_NATIVE_INT) AslCompilerlval.s);}
;
/*******************************************************************************
*
* ASL Helper Terms
*
******************************************************************************/
OptionalBusMasterKeyword
: ',' {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
| ',' PARSEOP_BUSMASTERTYPE_MASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
| ',' PARSEOP_BUSMASTERTYPE_NOTMASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_NOTMASTER);}
;
OptionalAccessAttribTerm
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' ByteConstExpr {$$ = $2;}
| ',' AccessAttribKeyword {$$ = $2;}
;
OptionalAccessSize
: {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
| ',' {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
| ',' ByteConstExpr {$$ = $2;}
;
OptionalAddressingMode
: ',' {$$ = NULL;}
| ',' AddressingModeKeyword {$$ = $2;}
;
OptionalAddressRange
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' AddressKeyword {$$ = $2;}
;
OptionalBitsPerByte
: ',' {$$ = NULL;}
| ',' BitsPerByteKeyword {$$ = $2;}
;
OptionalBuffer_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' RawDataBufferTerm {$$ = $2;}
;
OptionalByteConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' ByteConstExpr {$$ = $2;}
;
OptionalDecodeType
: ',' {$$ = NULL;}
| ',' DecodeKeyword {$$ = $2;}
;
OptionalDevicePolarity
: ',' {$$ = NULL;}
| ',' DevicePolarityKeyword {$$ = $2;}
;
OptionalDWordConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' DWordConstExpr {$$ = $2;}
;
OptionalEndian
: ',' {$$ = NULL;}
| ',' EndianKeyword {$$ = $2;}
;
OptionalFlowControl
: ',' {$$ = NULL;}
| ',' FlowControlKeyword {$$ = $2;}
;
OptionalIoRestriction
: ',' {$$ = NULL;}
| ',' IoRestrictionKeyword {$$ = $2;}
;
OptionalListString
: {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
| ',' {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
| ',' TermArg {$$ = $2;}
;
OptionalMaxType
: ',' {$$ = NULL;}
| ',' MaxKeyword {$$ = $2;}
;
OptionalMemType
: ',' {$$ = NULL;}
| ',' MemTypeKeyword {$$ = $2;}
;
OptionalMinType
: ',' {$$ = NULL;}
| ',' MinKeyword {$$ = $2;}
;
OptionalNameString
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' NameString {$$ = $2;}
;
OptionalNameString_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' NameString {$$ = $2;}
;
OptionalNameString_First
: {$$ = TrCreateLeafNode (PARSEOP_ZERO);}
| NameString {$$ = $1;}
;
OptionalObjectTypeKeyword
: {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
| ',' ObjectTypeKeyword {$$ = $2;}
;
OptionalParityType
: ',' {$$ = NULL;}
| ',' ParityTypeKeyword {$$ = $2;}
;
OptionalQWordConstExpr
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' QWordConstExpr {$$ = $2;}
;
OptionalRangeType
: ',' {$$ = NULL;}
| ',' RangeTypeKeyword {$$ = $2;}
;
OptionalReadWriteKeyword
: {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
| PARSEOP_READWRITETYPE_BOTH {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
| PARSEOP_READWRITETYPE_READONLY {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_READONLY);}
;
OptionalResourceType_First
: {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
| ResourceTypeKeyword {$$ = $1;}
;
OptionalResourceType
: {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
| ',' {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
| ',' ResourceTypeKeyword {$$ = $2;}
;
OptionalSlaveMode
: ',' {$$ = NULL;}
| ',' SlaveModeKeyword {$$ = $2;}
;
OptionalShareType
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' ShareTypeKeyword {$$ = $2;}
;
OptionalShareType_First
: {$$ = NULL;}
| ShareTypeKeyword {$$ = $1;}
;
OptionalStopBits
: ',' {$$ = NULL;}
| ',' StopBitsKeyword {$$ = $2;}
;
OptionalStringData
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' StringData {$$ = $2;}
;
OptionalTranslationType_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' TranslationKeyword {$$ = $2;}
;
OptionalType
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' TypeKeyword {$$ = $2;}
;
OptionalType_Last
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' TypeKeyword {$$ = $2;}
;
OptionalWireMode
: ',' {$$ = NULL;}
| ',' WireModeKeyword {$$ = $2;}
;
OptionalWordConstExpr
: ',' {$$ = NULL;}
| ',' WordConstExpr {$$ = $2;}
;
OptionalXferSize
: {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
| ',' {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
| ',' XferSizeKeyword {$$ = $2;}
;

1208
sys/contrib/dev/acpica/compiler/aslrules.y
View file

File diff suppressed because it is too large Load diff

15
sys/contrib/dev/acpica/compiler/aslstubs.c
View file

@ -47,6 +47,7 @@
#include <contrib/dev/acpica/include/acevents.h>
#include <contrib/dev/acpica/include/acinterp.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/acparser.h>
#define _COMPONENT ACPI_COMPILER
ACPI_MODULE_NAME ("aslstubs")
@ -70,6 +71,13 @@ AcpiNsInitializeObjects (
return (AE_OK);
}
ACPI_STATUS
AcpiPsExecuteTable (
ACPI_EVALUATE_INFO *Info)
{
return (AE_OK);
}
ACPI_STATUS
AcpiHwReadPort (
ACPI_IO_ADDRESS Address,
@ -156,6 +164,13 @@ AcpiEvDeleteGpeBlock (
return (AE_OK);
}
void
AcpiEvUpdateGpes (
ACPI_OWNER_ID TableOwnerId)
{
return;
}
ACPI_STATUS
AcpiEvAcquireGlobalLock (
UINT16 Timeout)

42
sys/contrib/dev/acpica/compiler/asltokens.y
View file

@ -53,6 +53,16 @@ NoEcho('
*
*****************************************************************************/
/*
* Most tokens are defined to return <i>, which is a UINT64.
*
* These tokens return <s>, a pointer to the associated lexed string:
*
* PARSEOP_NAMESEG
* PARSEOP_NAMESTRING
* PARSEOP_STRING_LITERAL
* PARSEOP_STRUCTURE_NAMESTRING
*/
%token <i> PARSEOP_ACCESSAS
%token <i> PARSEOP_ACCESSATTRIB_BLOCK
%token <i> PARSEOP_ACCESSATTRIB_BLOCK_CALL
@ -466,12 +476,42 @@ NoEcho('
%token <i> PARSEOP_FPRINTF
%token <i> PARSEOP_FOR
/* Structures */
%token <i> PARSEOP_STRUCTURE
%token <s> PARSEOP_STRUCTURE_NAMESTRING
%token <i> PARSEOP_STRUCTURE_TAG
%token <i> PARSEOP_STRUCTURE_ELEMENT
%token <i> PARSEOP_STRUCTURE_INSTANCE
%token <i> PARSEOP_STRUCTURE_REFERENCE
%token <i> PARSEOP_STRUCTURE_POINTER
/* Top level */
%token <i> PARSEOP_ASL_CODE
/*******************************************************************************
*
* Tokens below are not in the aslmap.c file
*
******************************************************************************/
/* Tokens below this are not in the aslmap.c file */
/* Specific parentheses tokens are not used at this time */
/* PARSEOP_EXP_PAREN_OPEN */
/* PARSEOP_EXP_PAREN_CLOSE */
/* ASL+ variable creation */
%token <i> PARSEOP_INTEGER_TYPE
%token <i> PARSEOP_STRING_TYPE
%token <i> PARSEOP_BUFFER_TYPE
%token <i> PARSEOP_PACKAGE_TYPE
%token <i> PARSEOP_REFERENCE_TYPE
%token <i> PARSEOP_ASL_CODE
/*
* Special functions. These should probably stay at the end of this

51
sys/contrib/dev/acpica/compiler/asltypes.y
View file

@ -278,7 +278,6 @@ NoEcho('
%type <n> PackageElement
%type <n> PackageList
%type <n> PackageTerm
%type <n> VarPackageLengthTerm
/* Macros */
@ -350,9 +349,9 @@ NoEcho('
%type <n> OptionalAddressRange
%type <n> OptionalBitsPerByte
%type <n> OptionalBuffer_Last
%type <n> OptionalBufferLength
%type <n> OptionalByteConstExpr
%type <n> OptionalCount
%type <n> OptionalDataCount
%type <n> OptionalDecodeType
%type <n> OptionalDevicePolarity
%type <n> OptionalDWordConstExpr
@ -369,6 +368,7 @@ NoEcho('
%type <n> OptionalObjectTypeKeyword
%type <n> OptionalParameterTypePackage
%type <n> OptionalParameterTypesPackage
%type <n> OptionalParentheses
%type <n> OptionalParityType
%type <n> OptionalPredicate
%type <n> OptionalQWordConstExpr
@ -393,8 +393,53 @@ NoEcho('
%type <n> OptionalXferSize
/*
* C-style expression parser
* ASL+ (C-style) parser
*/
/* Expressions and symbolic operators */
%type <n> Expression
%type <n> EqualsTerm
%type <n> IndexExpTerm
/* ASL+ Named object declaration support */
/*
%type <n> NameTermAslPlus
%type <n> BufferBegin
%type <n> BufferEnd
%type <n> PackageBegin
%type <n> PackageEnd
%type <n> OptionalLength
*/
/* ASL+ Structure declarations */
/*
%type <n> StructureTerm
%type <n> StructureTermBegin
%type <n> StructureType
%type <n> StructureTag
%type <n> StructureElementList
%type <n> StructureElement
%type <n> StructureElementType
%type <n> OptionalStructureElementType
%type <n> StructureId
*/
/* Structure instantiantion */
/*
%type <n> StructureInstanceTerm
%type <n> StructureTagReference
%type <n> StructureInstanceEnd
*/
/* Pseudo-instantiantion for method Args/Locals */
/*
%type <n> MethodStructureTerm
%type <n> LocalStructureName
*/
/* Direct structure references via the Index operator */
/*
%type <n> StructureReference
%type <n> StructureIndexTerm
%type <n> StructurePointerTerm
%type <n> StructurePointerReference
%type <n> OptionalDefinePointer
*/

67
sys/contrib/dev/acpica/compiler/aslutils.c
View file

@ -889,7 +889,7 @@ UtAttachNamepathToOwner (
*
* FUNCTION: UtDoConstant
*
* PARAMETERS: String - Hex, Octal, or Decimal string
* PARAMETERS: String - Hexadecimal or decimal string
*
* RETURN: Converted Integer
*
@ -906,9 +906,7 @@ UtDoConstant (
char ErrBuf[64];
Status = AcpiUtStrtoul64 (String, ACPI_ANY_BASE,
ACPI_MAX64_BYTE_WIDTH, &Converted);
Status = AcpiUtStrtoul64 (String, ACPI_STRTOUL_64BIT, &Converted);
if (ACPI_FAILURE (Status))
{
sprintf (ErrBuf, "%s %s\n", "Conversion error:",
@ -918,64 +916,3 @@ UtDoConstant (
return (Converted);
}
#ifdef _OBSOLETE_FUNCTIONS
/* Removed 01/2016 */
/*******************************************************************************
*
* FUNCTION: UtConvertByteToHex
*
* PARAMETERS: RawByte - Binary data
* Buffer - Pointer to where the hex bytes will be
* stored
*
* RETURN: Ascii hex byte is stored in Buffer.
*
* DESCRIPTION: Perform hex-to-ascii translation. The return data is prefixed
* with "0x"
*
******************************************************************************/
void
UtConvertByteToHex (
UINT8 RawByte,
UINT8 *Buffer)
{
Buffer[0] = '0';
Buffer[1] = 'x';
Buffer[2] = (UINT8) AcpiUtHexToAsciiChar (RawByte, 4);
Buffer[3] = (UINT8) AcpiUtHexToAsciiChar (RawByte, 0);
}
/*******************************************************************************
*
* FUNCTION: UtConvertByteToAsmHex
*
* PARAMETERS: RawByte - Binary data
* Buffer - Pointer to where the hex bytes will be
* stored
*
* RETURN: Ascii hex byte is stored in Buffer.
*
* DESCRIPTION: Perform hex-to-ascii translation. The return data is prefixed
* with '0', and a trailing 'h' is added.
*
******************************************************************************/
void
UtConvertByteToAsmHex (
UINT8 RawByte,
UINT8 *Buffer)
{
Buffer[0] = '0';
Buffer[1] = (UINT8) AcpiUtHexToAsciiChar (RawByte, 4);
Buffer[2] = (UINT8) AcpiUtHexToAsciiChar (RawByte, 0);
Buffer[3] = 'h';
}
#endif /* OBSOLETE_FUNCTIONS */

6
sys/contrib/dev/acpica/compiler/aslxref.c
View file

@ -826,16 +826,18 @@ XfNamespaceLocateBegin (
/*
* A reference to a method within one of these opcodes is not an
* invocation of the method, it is simply a reference to the method.
*
* September 2016: Removed DeRefOf from this list
*/
if ((Op->Asl.Parent) &&
((Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_REFOF) ||
(Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_DEREFOF) ||
((Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_REFOF) ||
(Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_PACKAGE) ||
(Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE)||
(Op->Asl.Parent->Asl.ParseOpcode == PARSEOP_OBJECTTYPE)))
{
return_ACPI_STATUS (AE_OK);
}
/*
* There are two types of method invocation:
* 1) Invocation with arguments -- the parser recognizes this

6
sys/contrib/dev/acpica/compiler/dtcompiler.h
View file

@ -373,11 +373,6 @@ DtFatal (
DT_FIELD *FieldObject,
char *ExtraMessage);
ACPI_STATUS
DtStrtoul64 (
char *String,
UINT64 *ReturnInteger);
char*
DtGetFieldValue (
DT_FIELD *Field);
@ -609,6 +604,7 @@ extern const unsigned char TemplateMtmr[];
extern const unsigned char TemplateNfit[];
extern const unsigned char TemplatePcct[];
extern const unsigned char TemplatePmtt[];
extern const unsigned char TemplateRasf[];
extern const unsigned char TemplateRsdt[];
extern const unsigned char TemplateS3pt[];
extern const unsigned char TemplateSbst[];

51
sys/contrib/dev/acpica/compiler/dtfield.c
View file

@ -370,10 +370,10 @@ DtCompileInteger (
* FUNCTION: DtNormalizeBuffer
*
* PARAMETERS: Buffer - Input buffer
* Count - Output the count of hex number in
* Count - Output the count of hex numbers in
* the Buffer
*
* RETURN: The normalized buffer, freed by caller
* RETURN: The normalized buffer, must be freed by caller
*
* DESCRIPTION: [1A,2B,3C,4D] or 1A, 2B, 3C, 4D will be normalized
* to 1A 2B 3C 4D
@ -457,36 +457,38 @@ DtCompileBuffer (
DT_FIELD *Field,
UINT32 ByteLength)
{
char *Substring;
ACPI_STATUS Status;
char Hex[3];
UINT64 Value;
UINT32 i;
UINT32 Count;
UINT32 i;
/* Allow several different types of value separators */
StringValue = DtNormalizeBuffer (StringValue, &Count);
Substring = StringValue;
Hex[2] = 0;
for (i = 0; i < Count; i++)
/* Each element of StringValue is now three chars (2 hex + 1 space) */
for (i = 0; i < Count; i++, Substring += 3)
{
/* Each element of StringValue is three chars */
/* Check for byte value too long */
Hex[0] = StringValue[(3 * i)];
Hex[1] = StringValue[(3 * i) + 1];
/* Convert one hex byte */
Value = 0;
Status = DtStrtoul64 (Hex, &Value);
if (ACPI_FAILURE (Status))
if (*(&Substring[2]) &&
(*(&Substring[2]) != ' '))
{
DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, MsgBuffer);
DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, Substring);
goto Exit;
}
Buffer[i] = (UINT8) Value;
/* Convert two ASCII characters to one hex byte */
Status = AcpiUtAsciiToHexByte (Substring, &Buffer[i]);
if (ACPI_FAILURE (Status))
{
DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, Substring);
goto Exit;
}
}
Exit:
@ -499,13 +501,13 @@ Exit:
*
* FUNCTION: DtCompileFlag
*
* PARAMETERS: Buffer - Output buffer
* Field - Field to be compiled
* Info - Flag info
* PARAMETERS: Buffer - Output buffer
* Field - Field to be compiled
* Info - Flag info
*
* RETURN:
* RETURN: None
*
* DESCRIPTION: Compile a flag
* DESCRIPTION: Compile a flag field. Handles flags up to 64 bits.
*
*****************************************************************************/
@ -521,7 +523,8 @@ DtCompileFlag (
ACPI_STATUS Status;
Status = DtStrtoul64 (Field->Value, &Value);
Status = AcpiUtStrtoul64 (Field->Value,
(ACPI_STRTOUL_64BIT | ACPI_STRTOUL_BASE16), &Value);
if (ACPI_FAILURE (Status))
{
DtError (ASL_ERROR, ASL_MSG_INVALID_HEX_INTEGER, Field, NULL);

6
sys/contrib/dev/acpica/compiler/dtparser.y
View file

@ -169,15 +169,15 @@ Expression
/* Default base for a non-prefixed integer is 16 */
| EXPOP_NUMBER { AcpiUtStrtoul64 (DtParsertext, 16, ACPI_MAX64_BYTE_WIDTH, &$$);}
| EXPOP_NUMBER { AcpiUtStrtoul64 (DtParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);}
/* Standard hex number (0x1234) */
| EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (DtParsertext, 16, ACPI_MAX64_BYTE_WIDTH, &$$);}
| EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (DtParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);}
/* TBD: Decimal number with prefix (0d1234) - Not supported by strtoul64 at this time */
| EXPOP_DECIMAL_NUMBER { AcpiUtStrtoul64 (DtParsertext, 10, ACPI_MAX64_BYTE_WIDTH, &$$);}
| EXPOP_DECIMAL_NUMBER { AcpiUtStrtoul64 (DtParsertext, ACPI_STRTOUL_64BIT, &$$);}
;
%%

70
sys/contrib/dev/acpica/compiler/dttable.c
View file

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

10
sys/contrib/dev/acpica/compiler/dttemplate.h
View file

@ -906,6 +906,16 @@ const unsigned char TemplatePmtt[] =
0x00,0x00,0x00,0x00 /* 000000B0 "...." */
};
const unsigned char TemplateRasf[] =
{
0x52,0x41,0x53,0x46,0x30,0x00,0x00,0x00, /* 00000000 "RASF0..." */
0x01,0x31,0x49,0x4E,0x54,0x45,0x4C,0x20, /* 00000008 ".1INTEL " */
0x54,0x65,0x6D,0x70,0x6C,0x61,0x74,0x65, /* 00000010 "Template" */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x27,0x05,0x16,0x20,0x00,0x00,0x00,0x00, /* 00000020 "'.. ...." */
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 /* 00000028 "........" */
};
const unsigned char TemplateRsdp[] =
{
0x52,0x53,0x44,0x20,0x50,0x54,0x52,0x20, /* 00000000 "RSD PTR " */

93
sys/contrib/dev/acpica/compiler/dtutils.c
View file

@ -195,93 +195,6 @@ DtFatal (
}
/******************************************************************************
*
* FUNCTION: DtStrtoul64
*
* PARAMETERS: String - Null terminated string
* ReturnInteger - Where the converted integer is returned
*
* RETURN: Status
*
* DESCRIPTION: Simple conversion of a string hex integer constant to unsigned
* value. Assumes no leading "0x" for the constant.
*
* Portability note: The reason this function exists is because a 64-bit
* sscanf is not available in all environments.
*
*****************************************************************************/
ACPI_STATUS
DtStrtoul64 (
char *String,
UINT64 *ReturnInteger)
{
char *ThisChar = String;
UINT32 ThisDigit;
UINT64 ReturnValue = 0;
int DigitCount = 0;
/* Skip over any white space in the buffer */
while ((*ThisChar == ' ') || (*ThisChar == '\t'))
{
ThisChar++;
}
/* Skip leading zeros */
while ((*ThisChar) == '0')
{
ThisChar++;
}
/* Convert character-by-character */
while (*ThisChar)
{
if (isdigit ((int) *ThisChar))
{
/* Convert ASCII 0-9 to Decimal value */
ThisDigit = ((UINT8) *ThisChar) - '0';
}
else /* Letter */
{
ThisDigit = (UINT32) toupper ((int) *ThisChar);
if (!isxdigit ((int) ThisDigit))
{
/* Not A-F */
return (AE_BAD_CHARACTER);
}
/* Convert ASCII Hex char (A-F) to value */
ThisDigit = (ThisDigit - 'A') + 10;
}
/* Insert the 4-bit hex digit */
ReturnValue <<= 4;
ReturnValue += ThisDigit;
ThisChar++;
DigitCount++;
if (DigitCount > 16)
{
/* Value is too large (> 64 bits/8 bytes/16 hex digits) */
return (AE_LIMIT);
}
}
*ReturnInteger = ReturnValue;
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: DtGetFieldValue
@ -367,6 +280,7 @@ DtGetFieldType (
case ACPI_DMT_RAW_BUFFER:
case ACPI_DMT_BUF7:
case ACPI_DMT_BUF10:
case ACPI_DMT_BUF12:
case ACPI_DMT_BUF16:
case ACPI_DMT_BUF128:
case ACPI_DMT_PCI_PATH:
@ -616,6 +530,11 @@ DtGetFieldLength (
ByteLength = 10;
break;
case ACPI_DMT_BUF12:
ByteLength = 12;
break;
case ACPI_DMT_BUF16:
case ACPI_DMT_UUID:

4
sys/contrib/dev/acpica/compiler/prparser.y
View file

@ -182,11 +182,11 @@ Expression
/* Default base for a non-prefixed integer is 10 */
| EXPOP_NUMBER { AcpiUtStrtoul64 (PrParsertext, 10, ACPI_MAX64_BYTE_WIDTH, &$$);}
| EXPOP_NUMBER { AcpiUtStrtoul64 (PrParsertext, ACPI_STRTOUL_64BIT, &$$);}
/* Standard hex number (0x1234) */
| EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (PrParsertext, 16, ACPI_MAX64_BYTE_WIDTH, &$$);}
| EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (PrParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);}
;
%%

3
sys/contrib/dev/acpica/components/debugger/dbconvert.c
View file

@ -321,7 +321,8 @@ AcpiDbConvertToObject (
default:
Object->Type = ACPI_TYPE_INTEGER;
Status = AcpiUtStrtoul64 (String, 16, AcpiGbl_IntegerByteWidth,
Status = AcpiUtStrtoul64 (String,
(AcpiGbl_IntegerByteWidth | ACPI_STRTOUL_BASE16),
&Object->Integer.Value);
break;
}

79
sys/contrib/dev/acpica/components/debugger/dbexec.c
View file

@ -444,45 +444,52 @@ AcpiDbExecute (
ACPI_UINT32_MAX, AcpiDbExecutionWalk, NULL, NULL, NULL);
return;
}
else
NameString = ACPI_ALLOCATE (strlen (Name) + 1);
if (!NameString)
{
NameString = ACPI_ALLOCATE (strlen (Name) + 1);
if (!NameString)
{
return;
}
memset (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
strcpy (NameString, Name);
AcpiUtStrupr (NameString);
AcpiGbl_DbMethodInfo.Name = NameString;
AcpiGbl_DbMethodInfo.Args = Args;
AcpiGbl_DbMethodInfo.Types = Types;
AcpiGbl_DbMethodInfo.Flags = Flags;
ReturnObj.Pointer = NULL;
ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
ACPI_FREE (NameString);
return;
}
/* Get the NS node, determines existence also */
Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
&AcpiGbl_DbMethodInfo.Method);
if (ACPI_SUCCESS (Status))
{
Status = AcpiDbExecuteMethod (&AcpiGbl_DbMethodInfo,
&ReturnObj);
}
ACPI_FREE (NameString);
return;
}
memset (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
strcpy (NameString, Name);
AcpiUtStrupr (NameString);
/* Subcommand to Execute all predefined names in the namespace */
if (!strncmp (NameString, "PREDEF", 6))
{
AcpiDbEvaluatePredefinedNames ();
ACPI_FREE (NameString);
return;
}
AcpiGbl_DbMethodInfo.Name = NameString;
AcpiGbl_DbMethodInfo.Args = Args;
AcpiGbl_DbMethodInfo.Types = Types;
AcpiGbl_DbMethodInfo.Flags = Flags;
ReturnObj.Pointer = NULL;
ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
ACPI_FREE (NameString);
return;
}
/* Get the NS node, determines existence also */
Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
&AcpiGbl_DbMethodInfo.Method);
if (ACPI_SUCCESS (Status))
{
Status = AcpiDbExecuteMethod (&AcpiGbl_DbMethodInfo,
&ReturnObj);
}
ACPI_FREE (NameString);
/*
* Allow any handlers in separate threads to complete.
* (Such as Notify handlers invoked from AML executed above).

19
sys/contrib/dev/acpica/components/debugger/dbfileio.c
View file

@ -46,15 +46,15 @@
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acdebug.h>
#include <contrib/dev/acpica/include/actables.h>
#include <stdio.h>
#ifdef ACPI_APPLICATION
#include <contrib/dev/acpica/include/acapps.h>
#endif
#define _COMPONENT ACPI_CA_DEBUGGER
ACPI_MODULE_NAME ("dbfileio")
#ifdef ACPI_APPLICATION
#include <contrib/dev/acpica/include/acapps.h>
#ifdef ACPI_DEBUGGER
/*******************************************************************************
*
@ -73,8 +73,6 @@ AcpiDbCloseDebugFile (
void)
{
#ifdef ACPI_APPLICATION
if (AcpiGbl_DebugFile)
{
fclose (AcpiGbl_DebugFile);
@ -83,7 +81,6 @@ AcpiDbCloseDebugFile (
AcpiOsPrintf ("Debug output file %s closed\n",
AcpiGbl_DbDebugFilename);
}
#endif
}
@ -104,8 +101,6 @@ AcpiDbOpenDebugFile (
char *Name)
{
#ifdef ACPI_APPLICATION
AcpiDbCloseDebugFile ();
AcpiGbl_DebugFile = fopen (Name, "w+");
if (!AcpiGbl_DebugFile)
@ -118,8 +113,6 @@ AcpiDbOpenDebugFile (
strncpy (AcpiGbl_DbDebugFilename, Name,
sizeof (AcpiGbl_DbDebugFilename));
AcpiGbl_DbOutputToFile = TRUE;
#endif
}
#endif
@ -169,8 +162,7 @@ AcpiDbLoadTables (
return (Status);
}
fprintf (stderr,
"Acpi table [%4.4s] successfully installed and loaded\n",
AcpiOsPrintf ("Acpi table [%4.4s] successfully installed and loaded\n",
Table->Signature);
TableListHead = TableListHead->Next;
@ -178,3 +170,4 @@ AcpiDbLoadTables (
return (AE_OK);
}
#endif

1
sys/contrib/dev/acpica/components/debugger/dbinput.c
View file

@ -298,6 +298,7 @@ static const ACPI_DB_COMMAND_HELP AcpiGbl_DbCommandHelp[] =
{1, " \"Ascii String\"", "String method argument\n"},
{1, " (Hex Byte List)", "Buffer method argument\n"},
{1, " [Package Element List]", "Package method argument\n"},
{5, " Execute predefined", "Execute all predefined (public) methods\n"},
{1, " Go", "Allow method to run to completion\n"},
{1, " Information", "Display info about the current method\n"},
{1, " Into", "Step into (not over) a method call\n"},

145
sys/contrib/dev/acpica/components/debugger/dbmethod.c
View file

@ -53,6 +53,15 @@
#define _COMPONENT ACPI_CA_DEBUGGER
ACPI_MODULE_NAME ("dbmethod")
/* Local prototypes */
static ACPI_STATUS
AcpiDbWalkForExecute (
ACPI_HANDLE ObjHandle,
UINT32 NestingLevel,
void *Context,
void **ReturnValue);
/*******************************************************************************
*
@ -414,3 +423,139 @@ AcpiDbDisassembleMethod (
AcpiUtReleaseOwnerId (&ObjDesc->Method.OwnerId);
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDbWalkForExecute
*
* PARAMETERS: Callback from WalkNamespace
*
* RETURN: Status
*
* DESCRIPTION: Batch execution module. Currently only executes predefined
* ACPI names.
*
******************************************************************************/
static ACPI_STATUS
AcpiDbWalkForExecute (
ACPI_HANDLE ObjHandle,
UINT32 NestingLevel,
void *Context,
void **ReturnValue)
{
ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
ACPI_DB_EXECUTE_WALK *Info = (ACPI_DB_EXECUTE_WALK *) Context;
ACPI_BUFFER ReturnObj;
ACPI_STATUS Status;
char *Pathname;
UINT32 i;
ACPI_DEVICE_INFO *ObjInfo;
ACPI_OBJECT_LIST ParamObjects;
ACPI_OBJECT Params[ACPI_METHOD_NUM_ARGS];
const ACPI_PREDEFINED_INFO *Predefined;
Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii);
if (!Predefined)
{
return (AE_OK);
}
if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)
{
return (AE_OK);
}
Pathname = AcpiNsGetExternalPathname (Node);
if (!Pathname)
{
return (AE_OK);
}
/* Get the object info for number of method parameters */
Status = AcpiGetObjectInfo (ObjHandle, &ObjInfo);
if (ACPI_FAILURE (Status))
{
return (Status);
}
ParamObjects.Pointer = NULL;
ParamObjects.Count = 0;
if (ObjInfo->Type == ACPI_TYPE_METHOD)
{
/* Setup default parameters */
for (i = 0; i < ObjInfo->ParamCount; i++)
{
Params[i].Type = ACPI_TYPE_INTEGER;
Params[i].Integer.Value = 1;
}
ParamObjects.Pointer = Params;
ParamObjects.Count = ObjInfo->ParamCount;
}
ACPI_FREE (ObjInfo);
ReturnObj.Pointer = NULL;
ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
/* Do the actual method execution */
AcpiGbl_MethodExecuting = TRUE;
Status = AcpiEvaluateObject (Node, NULL, &ParamObjects, &ReturnObj);
AcpiOsPrintf ("%-32s returned %s\n", Pathname, AcpiFormatException (Status));
AcpiGbl_MethodExecuting = FALSE;
ACPI_FREE (Pathname);
/* Ignore status from method execution */
Status = AE_OK;
/* Update count, check if we have executed enough methods */
Info->Count++;
if (Info->Count >= Info->MaxCount)
{
Status = AE_CTRL_TERMINATE;
}
return (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiDbEvaluatePredefinedNames
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Namespace batch execution. Execute predefined names in the
* namespace, up to the max count, if specified.
*
******************************************************************************/
void
AcpiDbEvaluatePredefinedNames (
void)
{
ACPI_DB_EXECUTE_WALK Info;
Info.Count = 0;
Info.MaxCount = ACPI_UINT32_MAX;
/* Search all nodes in namespace */
(void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
AcpiDbWalkForExecute, NULL, (void *) &Info, NULL);
AcpiOsPrintf ("Evaluated %u predefined names in the namespace\n", Info.Count);
}

68
sys/contrib/dev/acpica/components/disassembler/dmbuffer.c
View file

@ -529,7 +529,8 @@ AcpiDmIsStringBuffer (
*
* PARAMETERS: Op - Buffer Object to be examined
*
* RETURN: TRUE if buffer contains a ASCII string, FALSE otherwise
* RETURN: TRUE if buffer appears to contain data produced via the
* ToPLD macro, FALSE otherwise
*
* DESCRIPTION: Determine if a buffer Op contains a _PLD structure
*
@ -541,12 +542,60 @@ AcpiDmIsPldBuffer (
{
ACPI_NAMESPACE_NODE *Node;
ACPI_PARSE_OBJECT *SizeOp;
ACPI_PARSE_OBJECT *ByteListOp;
ACPI_PARSE_OBJECT *ParentOp;
UINT64 BufferSize;
UINT64 InitializerSize;
/* Buffer size is the buffer argument */
/*
* Get the BufferSize argument - Buffer(BufferSize)
* If the buffer was generated by the ToPld macro, it must
* be a BYTE constant.
*/
SizeOp = Op->Common.Value.Arg;
if (SizeOp->Common.AmlOpcode != AML_BYTE_OP)
{
return (FALSE);
}
/* Check the declared BufferSize, two possibilities */
BufferSize = SizeOp->Common.Value.Integer;
if ((BufferSize != ACPI_PLD_REV1_BUFFER_SIZE) &&
(BufferSize != ACPI_PLD_REV2_BUFFER_SIZE))
{
return (FALSE);
}
/*
* Check the initializer list length. This is the actual
* number of bytes in the buffer as counted by the AML parser.
* The declared BufferSize can be larger than the actual length.
* However, for the ToPLD macro, the BufferSize will be the same
* as the initializer list length.
*/
ByteListOp = SizeOp->Common.Next;
if (!ByteListOp)
{
return (FALSE); /* Zero-length buffer case */
}
InitializerSize = ByteListOp->Common.Value.Integer;
if ((InitializerSize != ACPI_PLD_REV1_BUFFER_SIZE) &&
(InitializerSize != ACPI_PLD_REV2_BUFFER_SIZE))
{
return (FALSE);
}
/* Final size check */
if (BufferSize != InitializerSize)
{
return (FALSE);
}
/* Now examine the buffer parent */
ParentOp = Op->Common.Parent;
if (!ParentOp)
@ -571,8 +620,17 @@ AcpiDmIsPldBuffer (
return (FALSE);
}
/* Check for proper form: Name(_PLD, Package() {Buffer() {}}) */
/*
* Check for proper form: Name(_PLD, Package() {ToPLD()})
*
* Note: All other forms such as
* Return (Package() {ToPLD()})
* Local0 = ToPLD()
* etc. are not converted back to the ToPLD macro, because
* there is really no deterministic way to disassemble the buffer
* back to the ToPLD macro, other than trying to find the "_PLD"
* name
*/
if (ParentOp->Common.AmlOpcode == AML_PACKAGE_OP)
{
ParentOp = ParentOp->Common.Parent;

91
sys/contrib/dev/acpica/components/disassembler/dmcstyle.c
View file

@ -98,6 +98,9 @@ AcpiDmCheckForSymbolicOpcode (
ACPI_PARSE_OBJECT *Child1;
ACPI_PARSE_OBJECT *Child2;
ACPI_PARSE_OBJECT *Target;
ACPI_PARSE_OBJECT *GrandChild1;
ACPI_PARSE_OBJECT *GrandChild2;
ACPI_PARSE_OBJECT *GrandTarget = NULL;
/* Exit immediately if ASL+ not enabled */
@ -107,6 +110,14 @@ AcpiDmCheckForSymbolicOpcode (
return (FALSE);
}
/* Check for a non-ASL+ statement, propagate the flag */
if (Op->Common.Parent->Common.DisasmFlags & ACPI_PARSEOP_LEGACY_ASL_ONLY)
{
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
/* Get the first operand */
Child1 = AcpiPsGetArg (Op, 0);
@ -323,6 +334,7 @@ AcpiDmCheckForSymbolicOpcode (
if (AcpiDmIsValidTarget (Target))
{
Child1->Common.OperatorSymbol = NULL;
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
@ -339,6 +351,13 @@ AcpiDmCheckForSymbolicOpcode (
if (!AcpiDmIsValidTarget (Target))
{
if (Op->Common.Parent->Common.AmlOpcode == AML_STORE_OP)
{
Op->Common.DisasmFlags = 0;
Child1->Common.OperatorSymbol = NULL;
return (FALSE);
}
/* Not a valid target (placeholder only, from parser) */
break;
}
@ -478,6 +497,69 @@ AcpiDmCheckForSymbolicOpcode (
/*
* Target is the 2nd operand.
* We know the target is valid, it is not optional.
*
* The following block implements "Ignore conversion if a store
* is followed by a math/bit operator that has no target". Used
* only for the ASL test suite.
*/
if (!AcpiGbl_DoDisassemblerOptimizations)
{
switch (Child1->Common.AmlOpcode)
{
/* This operator has two operands and two targets */
case AML_DIVIDE_OP:
GrandChild1 = Child1->Common.Value.Arg;
GrandChild2 = GrandChild1->Common.Next;
GrandTarget = GrandChild2->Common.Next;
if (GrandTarget && !AcpiDmIsValidTarget (GrandTarget))
{
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
GrandTarget = GrandTarget->Common.Next;
break;
case AML_ADD_OP:
case AML_SUBTRACT_OP:
case AML_MULTIPLY_OP:
case AML_MOD_OP:
case AML_SHIFT_LEFT_OP:
case AML_SHIFT_RIGHT_OP:
case AML_BIT_AND_OP:
case AML_BIT_OR_OP:
case AML_BIT_XOR_OP:
case AML_INDEX_OP:
/* These operators have two operands and a target */
GrandChild1 = Child1->Common.Value.Arg;
GrandChild2 = GrandChild1->Common.Next;
GrandTarget = GrandChild2->Common.Next;
break;
case AML_BIT_NOT_OP:
/* This operator has one operand and a target */
GrandChild1 = Child1->Common.Value.Arg;
GrandTarget = GrandChild1->Common.Next;
break;
default:
break;
}
if (GrandTarget && !AcpiDmIsValidTarget (GrandTarget))
{
Op->Common.DisasmFlags |= ACPI_PARSEOP_LEGACY_ASL_ONLY;
return (FALSE);
}
}
/*
* In the parse tree, simply swap the target with the
* source so that the target is processed first.
*/
@ -563,6 +645,7 @@ AcpiDmCloseOperator (
{
BOOLEAN IsCStyleOp = FALSE;
/* Always emit paren if ASL+ disassembly disabled */
if (!AcpiGbl_CstyleDisassembly)
@ -571,6 +654,14 @@ AcpiDmCloseOperator (
return;
}
/* Check for a non-ASL+ statement */
if (Op->Common.DisasmFlags & ACPI_PARSEOP_LEGACY_ASL_ONLY)
{
AcpiOsPrintf (")");
return;
}
/* Check if we need to add an additional closing paren */
switch (Op->Common.AmlOpcode)

66
sys/contrib/dev/acpica/components/disassembler/dmopcode.c
View file

@ -64,6 +64,10 @@ static void
AcpiDmConvertToElseIf (
ACPI_PARSE_OBJECT *Op);
static void
AcpiDmPromoteSubtree (
ACPI_PARSE_OBJECT *StartOp);
/*******************************************************************************
*
@ -1067,16 +1071,26 @@ AcpiDmConvertToElseIf (
* be the only blocks under the original Else.
*/
IfOp = OriginalElseOp->Common.Value.Arg;
if (!IfOp ||
(IfOp->Common.AmlOpcode != AML_IF_OP) ||
(IfOp->Asl.Next && (IfOp->Asl.Next->Common.AmlOpcode != AML_ELSE_OP)))
{
/* Not an Else..If sequence, cannot convert to ElseIf */
/* Not a proper Else..If sequence, cannot convert to ElseIf */
AcpiOsPrintf ("%s", "Else");
return;
}
/* Cannot have anything following the If...Else block */
ElseOp = IfOp->Common.Next;
if (ElseOp && ElseOp->Common.Next)
{
AcpiOsPrintf ("%s", "Else");
return;
}
/* Emit ElseIf, mark the IF as now an ELSEIF */
AcpiOsPrintf ("%s", "ElseIf");
@ -1100,7 +1114,10 @@ AcpiDmConvertToElseIf (
/* If an ELSE matches the IF, promote it also */
ElseOp->Common.Parent = OriginalElseOp->Common.Parent;
ElseOp->Common.Next = OriginalElseOp->Common.Next;
/* Promote the entire block under the ElseIf (All Next OPs) */
AcpiDmPromoteSubtree (OriginalElseOp);
}
else
{
@ -1122,3 +1139,48 @@ AcpiDmConvertToElseIf (
OriginalElseOp->Common.Next = IfOp;
}
/*******************************************************************************
*
* FUNCTION: AcpiDmPromoteSubtree
*
* PARAMETERS: StartOpOp - Original parent of the entire subtree
*
* RETURN: None
*
* DESCRIPTION: Promote an entire parse subtree up one level.
*
******************************************************************************/
static void
AcpiDmPromoteSubtree (
ACPI_PARSE_OBJECT *StartOp)
{
ACPI_PARSE_OBJECT *Op;
ACPI_PARSE_OBJECT *ParentOp;
/* New parent for subtree elements */
ParentOp = StartOp->Common.Parent;
/* First child starts the subtree */
Op = StartOp->Common.Value.Arg;
/* Walk the top-level elements of the subtree */
while (Op)
{
Op->Common.Parent = ParentOp;
if (!Op->Common.Next)
{
/* Last Op in list, update its next field */
Op->Common.Next = StartOp->Common.Next;
break;
}
Op = Op->Common.Next;
}
}

15
sys/contrib/dev/acpica/components/disassembler/dmresrcl.c
View file

@ -443,16 +443,17 @@ AcpiDmIoFlags2 (
UINT8 SpecificFlags)
{
/* _TTP */
AcpiOsPrintf (", %s",
AcpiGbl_TtpDecode [ACPI_EXTRACT_1BIT_FLAG (SpecificFlags, 4)]);
/* TRS is only used if TTP is TypeTranslation */
if (SpecificFlags & 0x10)
{
AcpiOsPrintf (", %s",
AcpiGbl_TrsDecode [ACPI_EXTRACT_1BIT_FLAG (SpecificFlags, 5)]);
}
/*
* TRS is only used if TTP is TypeTranslation. However, the disassembler
* always emits exactly what is in the AML.
*/
AcpiOsPrintf (", %s",
AcpiGbl_TrsDecode [ACPI_EXTRACT_1BIT_FLAG (SpecificFlags, 5)]);
}

6
sys/contrib/dev/acpica/components/disassembler/dmresrcl2.c
View file

@ -516,7 +516,7 @@ AcpiDmI2cSerialBusDescriptor (
ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
Resource->CommonSerialBus.TypeDataLength;
DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset),
DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
/* ResourceSourceIndex, ResourceUsage */
@ -601,7 +601,7 @@ AcpiDmSpiSerialBusDescriptor (
ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
Resource->CommonSerialBus.TypeDataLength;
DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset),
DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
/* ResourceSourceIndex, ResourceUsage */
@ -689,7 +689,7 @@ AcpiDmUartSerialBusDescriptor (
ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
Resource->CommonSerialBus.TypeDataLength;
DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset),
DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
/* ResourceSourceIndex, ResourceUsage */

14
sys/contrib/dev/acpica/components/dispatcher/dsmethod.c
View file

@ -107,12 +107,15 @@ AcpiDsAutoSerializeMethod (
"Method auto-serialization parse [%4.4s] %p\n",
AcpiUtGetNodeName (Node), Node));
AcpiExEnterInterpreter ();
/* Create/Init a root op for the method parse tree */
Op = AcpiPsAllocOp (AML_METHOD_OP, ObjDesc->Method.AmlStart);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
Status = AE_NO_MEMORY;
goto Unlock;
}
AcpiPsSetName (Op, Node->Name.Integer);
@ -124,7 +127,8 @@ AcpiDsAutoSerializeMethod (
if (!WalkState)
{
AcpiPsFreeOp (Op);
return_ACPI_STATUS (AE_NO_MEMORY);
Status = AE_NO_MEMORY;
goto Unlock;
}
Status = AcpiDsInitAmlWalk (WalkState, Op, Node,
@ -143,6 +147,8 @@ AcpiDsAutoSerializeMethod (
Status = AcpiPsParseAml (WalkState);
AcpiPsDeleteParseTree (Op);
Unlock:
AcpiExExitInterpreter ();
return_ACPI_STATUS (Status);
}
@ -810,7 +816,9 @@ AcpiDsTerminateControlMethod (
{
/* Delete any direct children of (created by) this method */
(void) AcpiExExitInterpreter ();
AcpiNsDeleteNamespaceSubtree (WalkState->MethodNode);
(void) AcpiExEnterInterpreter ();
/*
* Delete any objects that were created by this method
@ -821,7 +829,9 @@ AcpiDsTerminateControlMethod (
*/
if (MethodDesc->Method.InfoFlags & ACPI_METHOD_MODIFIED_NAMESPACE)
{
(void) AcpiExExitInterpreter ();
AcpiNsDeleteNamespaceByOwner (MethodDesc->Method.OwnerId);
(void) AcpiExEnterInterpreter ();
MethodDesc->Method.InfoFlags &=
~ACPI_METHOD_MODIFIED_NAMESPACE;
}

3
sys/contrib/dev/acpica/components/dispatcher/dswexec.c
View file

@ -144,7 +144,8 @@ AcpiDsGetPredicateValue (
* Result of predicate evaluation must be an Integer
* object. Implicitly convert the argument if necessary.
*/
Status = AcpiExConvertToInteger (ObjDesc, &LocalObjDesc, 16);
Status = AcpiExConvertToInteger (ObjDesc, &LocalObjDesc,
ACPI_STRTOUL_BASE16);
if (ACPI_FAILURE (Status))
{
goto Cleanup;

8
sys/contrib/dev/acpica/components/dispatcher/dswload2.c
View file

@ -624,16 +624,12 @@ AcpiDsLoad2EndOp (
{
return_ACPI_STATUS (Status);
}
AcpiExExitInterpreter ();
}
AcpiExExitInterpreter ();
Status = AcpiEvInitializeRegion (
AcpiNsGetAttachedObject (Node), FALSE);
if (WalkState->MethodNode)
{
AcpiExEnterInterpreter ();
}
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
{

67
sys/contrib/dev/acpica/components/events/evgpe.c
View file

@ -147,6 +147,70 @@ AcpiEvEnableGpe (
}
/*******************************************************************************
*
* FUNCTION: AcpiEvMaskGpe
*
* PARAMETERS: GpeEventInfo - GPE to be blocked/unblocked
* IsMasked - Whether the GPE is masked or not
*
* RETURN: Status
*
* DESCRIPTION: Unconditionally mask/unmask a GPE during runtime.
*
******************************************************************************/
ACPI_STATUS
AcpiEvMaskGpe (
ACPI_GPE_EVENT_INFO *GpeEventInfo,
BOOLEAN IsMasked)
{
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
UINT32 RegisterBit;
ACPI_FUNCTION_TRACE (EvMaskGpe);
GpeRegisterInfo = GpeEventInfo->RegisterInfo;
if (!GpeRegisterInfo)
{
return_ACPI_STATUS (AE_NOT_EXIST);
}
RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
/* Perform the action */
if (IsMasked)
{
if (RegisterBit & GpeRegisterInfo->MaskForRun)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
(void) AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_DISABLE);
ACPI_SET_BIT (GpeRegisterInfo->MaskForRun, (UINT8) RegisterBit);
}
else
{
if (!(RegisterBit & GpeRegisterInfo->MaskForRun))
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
ACPI_CLEAR_BIT (GpeRegisterInfo->MaskForRun, (UINT8) RegisterBit);
if (GpeEventInfo->RuntimeCount &&
!GpeEventInfo->DisableForDispatch)
{
(void) AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_ENABLE);
}
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiEvAddGpeReference
@ -715,6 +779,7 @@ AcpiEvFinishGpe (
* in the EventInfo.
*/
(void) AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_CONDITIONAL_ENABLE);
GpeEventInfo->DisableForDispatch = FALSE;
return (AE_OK);
}
@ -784,6 +849,8 @@ AcpiEvGpeDispatch (
}
}
GpeEventInfo->DisableForDispatch = TRUE;
/*
* Dispatch the GPE to either an installed handler or the control
* method associated with this GPE (_Lxx or _Exx). If a handler

7
sys/contrib/dev/acpica/components/events/evgpeinit.c
View file

@ -336,7 +336,9 @@ AcpiEvMatchGpeMethod (
ACPI_NAMESPACE_NODE *MethodNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
ACPI_GPE_WALK_INFO *WalkInfo = ACPI_CAST_PTR (ACPI_GPE_WALK_INFO, Context);
ACPI_GPE_EVENT_INFO *GpeEventInfo;
ACPI_STATUS Status;
UINT32 GpeNumber;
UINT8 TempGpeNumber;
char Name[ACPI_NAME_SIZE + 1];
UINT8 Type;
@ -395,8 +397,8 @@ AcpiEvMatchGpeMethod (
/* 4) The last two characters of the name are the hex GPE Number */
GpeNumber = strtoul (&Name[2], NULL, 16);
if (GpeNumber == ACPI_UINT32_MAX)
Status = AcpiUtAsciiToHexByte (&Name[2], &TempGpeNumber);
if (ACPI_FAILURE (Status))
{
/* Conversion failed; invalid method, just ignore it */
@ -408,6 +410,7 @@ AcpiEvMatchGpeMethod (
/* Ensure that we have a valid GPE number for this GPE block */
GpeNumber = (UINT32) TempGpeNumber;
GpeEventInfo = AcpiEvLowGetGpeInfo (GpeNumber, WalkInfo->GpeBlock);
if (!GpeEventInfo)
{

3
sys/contrib/dev/acpica/components/events/evrgnini.c
View file

@ -618,7 +618,8 @@ AcpiEvInitializeRegion (
*
* See AcpiNsExecModuleCode
*/
if (ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)
if (!AcpiGbl_ParseTableAsTermList &&
ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)
{
HandlerObj = ObjDesc->Method.Dispatch.Handler;
}

52
sys/contrib/dev/acpica/components/events/evxfgpe.c
View file

@ -271,11 +271,13 @@ AcpiSetGpe (
case ACPI_GPE_ENABLE:
Status = AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_ENABLE);
GpeEventInfo->DisableForDispatch = FALSE;
break;
case ACPI_GPE_DISABLE:
Status = AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_DISABLE);
GpeEventInfo->DisableForDispatch = TRUE;
break;
default:
@ -292,6 +294,56 @@ UnlockAndExit:
ACPI_EXPORT_SYMBOL (AcpiSetGpe)
/*******************************************************************************
*
* FUNCTION: AcpiMaskGpe
*
* PARAMETERS: GpeDevice - Parent GPE Device. NULL for GPE0/GPE1
* GpeNumber - GPE level within the GPE block
* IsMasked - Whether the GPE is masked or not
*
* RETURN: Status
*
* DESCRIPTION: Unconditionally mask/unmask the an individual GPE, ex., to
* prevent a GPE flooding.
*
******************************************************************************/
ACPI_STATUS
AcpiMaskGpe (
ACPI_HANDLE GpeDevice,
UINT32 GpeNumber,
BOOLEAN IsMasked)
{
ACPI_GPE_EVENT_INFO *GpeEventInfo;
ACPI_STATUS Status;
ACPI_CPU_FLAGS Flags;
ACPI_FUNCTION_TRACE (AcpiMaskGpe);
Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
/* Ensure that we have a valid GPE number */
GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
if (!GpeEventInfo)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
Status = AcpiEvMaskGpe (GpeEventInfo, IsMasked);
UnlockAndExit:
AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
return_ACPI_STATUS (Status);
}
ACPI_EXPORT_SYMBOL (AcpiMaskGpe)
/*******************************************************************************
*
* FUNCTION: AcpiMarkGpeForWake

3
sys/contrib/dev/acpica/components/executer/exconcat.c
View file

@ -164,7 +164,8 @@ AcpiExDoConcatenate (
{
case ACPI_TYPE_INTEGER:
Status = AcpiExConvertToInteger (LocalOperand1, &TempOperand1, 16);
Status = AcpiExConvertToInteger (LocalOperand1, &TempOperand1,
ACPI_STRTOUL_BASE16);
break;
case ACPI_TYPE_BUFFER:

136
sys/contrib/dev/acpica/components/executer/exconfig.c
View file

@ -59,7 +59,6 @@
static ACPI_STATUS
AcpiExAddTable (
UINT32 TableIndex,
ACPI_NAMESPACE_NODE *ParentNode,
ACPI_OPERAND_OBJECT **DdbHandle);
static ACPI_STATUS
@ -87,12 +86,9 @@ AcpiExRegionRead (
static ACPI_STATUS
AcpiExAddTable (
UINT32 TableIndex,
ACPI_NAMESPACE_NODE *ParentNode,
ACPI_OPERAND_OBJECT **DdbHandle)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_STATUS Status;
ACPI_OWNER_ID OwnerId;
ACPI_FUNCTION_TRACE (ExAddTable);
@ -110,42 +106,8 @@ AcpiExAddTable (
ObjDesc->Common.Flags |= AOPOBJ_DATA_VALID;
ObjDesc->Reference.Class = ACPI_REFCLASS_TABLE;
*DdbHandle = ObjDesc;
/* Install the new table into the local data structures */
ObjDesc->Reference.Value = TableIndex;
/* Add the table to the namespace */
Status = AcpiNsLoadTable (TableIndex, ParentNode);
if (ACPI_FAILURE (Status))
{
AcpiUtRemoveReference (ObjDesc);
*DdbHandle = NULL;
return_ACPI_STATUS (Status);
}
/* Execute any module-level code that was found in the table */
AcpiExExitInterpreter ();
if (AcpiGbl_GroupModuleLevelCode)
{
AcpiNsExecModuleCodeList ();
}
AcpiExEnterInterpreter ();
/*
* Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
* responsible for discovering any new wake GPEs by running _PRW methods
* that may have been loaded by this table.
*/
Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);
if (ACPI_SUCCESS (Status))
{
AcpiEvUpdateGpes (OwnerId);
}
*DdbHandle = ObjDesc;
return_ACPI_STATUS (AE_OK);
}
@ -174,7 +136,6 @@ AcpiExLoadTableOp (
ACPI_NAMESPACE_NODE *StartNode;
ACPI_NAMESPACE_NODE *ParameterNode = NULL;
ACPI_OPERAND_OBJECT *DdbHandle;
ACPI_TABLE_HEADER *Table;
UINT32 TableIndex;
@ -183,10 +144,12 @@ AcpiExLoadTableOp (
/* Find the ACPI table in the RSDT/XSDT */
AcpiExExitInterpreter ();
Status = AcpiTbFindTable (
Operand[0]->String.Pointer,
Operand[1]->String.Pointer,
Operand[2]->String.Pointer, &TableIndex);
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
{
if (Status != AE_NOT_FOUND)
@ -219,8 +182,9 @@ AcpiExLoadTableOp (
* Find the node referenced by the RootPathString. This is the
* location within the namespace where the table will be loaded.
*/
Status = AcpiNsGetNode (StartNode, Operand[3]->String.Pointer,
ACPI_NS_SEARCH_PARENT, &ParentNode);
Status = AcpiNsGetNodeUnlocked (StartNode,
Operand[3]->String.Pointer, ACPI_NS_SEARCH_PARENT,
&ParentNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -243,8 +207,9 @@ AcpiExLoadTableOp (
/* Find the node referenced by the ParameterPathString */
Status = AcpiNsGetNode (StartNode, Operand[4]->String.Pointer,
ACPI_NS_SEARCH_PARENT, &ParameterNode);
Status = AcpiNsGetNodeUnlocked (StartNode,
Operand[4]->String.Pointer, ACPI_NS_SEARCH_PARENT,
&ParameterNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -253,7 +218,16 @@ AcpiExLoadTableOp (
/* Load the table into the namespace */
Status = AcpiExAddTable (TableIndex, ParentNode, &DdbHandle);
ACPI_INFO (("Dynamic OEM Table Load:"));
AcpiExExitInterpreter ();
Status = AcpiTbLoadTable (TableIndex, ParentNode);
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
Status = AcpiExAddTable (TableIndex, &DdbHandle);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -276,21 +250,6 @@ AcpiExLoadTableOp (
}
}
Status = AcpiGetTableByIndex (TableIndex, &Table);
if (ACPI_SUCCESS (Status))
{
ACPI_INFO (("Dynamic OEM Table Load:"));
AcpiTbPrintTableHeader (0, Table);
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
AcpiGbl_TableHandlerContext);
}
*ReturnDesc = DdbHandle;
return_ACPI_STATUS (Status);
}
@ -520,13 +479,10 @@ AcpiExLoadOp (
/* Install the new table into the local data structures */
ACPI_INFO (("Dynamic OEM Table Load:"));
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
Status = AcpiTbInstallStandardTable (ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, TRUE, TRUE,
&TableIndex);
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
AcpiExExitInterpreter ();
Status = AcpiTbInstallAndLoadTable (Table, ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, TRUE, &TableIndex);
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
{
/* Delete allocated table buffer */
@ -535,17 +491,6 @@ AcpiExLoadOp (
return_ACPI_STATUS (Status);
}
/*
* Note: Now table is "INSTALLED", it must be validated before
* loading.
*/
Status = AcpiTbValidateTable (
&AcpiGbl_RootTableList.Tables[TableIndex]);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/*
* Add the table to the namespace.
*
@ -553,7 +498,7 @@ AcpiExLoadOp (
* This appears to go against the ACPI specification, but we do it for
* compatibility with other ACPI implementations.
*/
Status = AcpiExAddTable (TableIndex, AcpiGbl_RootNode, &DdbHandle);
Status = AcpiExAddTable (TableIndex, &DdbHandle);
if (ACPI_FAILURE (Status))
{
/* On error, TablePtr was deallocated above */
@ -577,15 +522,6 @@ AcpiExLoadOp (
/* Remove the reference by added by AcpiExStore above */
AcpiUtRemoveReference (DdbHandle);
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
AcpiGbl_TableHandlerContext);
}
return_ACPI_STATUS (Status);
}
@ -645,11 +581,18 @@ AcpiExUnloadTable (
TableIndex = TableDesc->Reference.Value;
/*
* Release the interpreter lock so that the table lock won't have
* strict order requirement against it.
*/
AcpiExExitInterpreter ();
/* Ensure the table is still loaded */
if (!AcpiTbIsTableLoaded (TableIndex))
{
return_ACPI_STATUS (AE_NOT_EXIST);
Status = AE_NOT_EXIST;
goto LockAndExit;
}
/* Invoke table handler if present */
@ -669,16 +612,25 @@ AcpiExUnloadTable (
Status = AcpiTbDeleteNamespaceByOwner (TableIndex);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
goto LockAndExit;
}
(void) AcpiTbReleaseOwnerId (TableIndex);
AcpiTbSetTableLoadedFlag (TableIndex, FALSE);
LockAndExit:
/* Re-acquire the interpreter lock */
AcpiExEnterInterpreter ();
/*
* Invalidate the handle. We do this because the handle may be stored
* in a named object and may not be actually deleted until much later.
*/
DdbHandle->Common.Flags &= ~AOPOBJ_DATA_VALID;
return_ACPI_STATUS (AE_OK);
if (ACPI_SUCCESS (Status))
{
DdbHandle->Common.Flags &= ~AOPOBJ_DATA_VALID;
}
return_ACPI_STATUS (Status);
}

7
sys/contrib/dev/acpica/components/executer/exconvrt.c
View file

@ -137,8 +137,8 @@ AcpiExConvertToInteger (
* of ACPI 3.0) is that the ToInteger() operator allows both decimal
* and hexadecimal strings (hex prefixed with "0x").
*/
Status = AcpiUtStrtoul64 ((char *) Pointer, Flags,
AcpiGbl_IntegerByteWidth, &Result);
Status = AcpiUtStrtoul64 (ACPI_CAST_PTR (char, Pointer),
(AcpiGbl_IntegerByteWidth | Flags), &Result);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -684,7 +684,8 @@ AcpiExConvertToTargetType (
* These types require an Integer operand. We can convert
* a Buffer or a String to an Integer if necessary.
*/
Status = AcpiExConvertToInteger (SourceDesc, ResultDesc, 16);
Status = AcpiExConvertToInteger (SourceDesc, ResultDesc,
ACPI_STRTOUL_BASE16);
break;
case ACPI_TYPE_STRING:

3
sys/contrib/dev/acpica/components/executer/exmisc.c
View file

@ -360,7 +360,8 @@ AcpiExDoLogicalOp (
{
case ACPI_TYPE_INTEGER:
Status = AcpiExConvertToInteger (Operand1, &LocalOperand1, 16);
Status = AcpiExConvertToInteger (Operand1, &LocalOperand1,
ACPI_STRTOUL_BASE16);
break;
case ACPI_TYPE_STRING:

7
sys/contrib/dev/acpica/components/executer/exoparg1.c
View file

@ -550,8 +550,9 @@ AcpiExOpcode_1A_1T_1R (
case AML_TO_INTEGER_OP: /* ToInteger (Data, Result) */
Status = AcpiExConvertToInteger (
Operand[0], &ReturnDesc, ACPI_ANY_BASE);
/* Perform "explicit" conversion */
Status = AcpiExConvertToInteger (Operand[0], &ReturnDesc, 0);
if (ReturnDesc == Operand[0])
{
/* No conversion performed, add ref to handle return value */
@ -936,7 +937,7 @@ AcpiExOpcode_1A_0T_1R (
* 2) Dereference the node to an actual object. Could be a
* Field, so we need to resolve the node to a value.
*/
Status = AcpiNsGetNode (WalkState->ScopeInfo->Scope.Node,
Status = AcpiNsGetNodeUnlocked (WalkState->ScopeInfo->Scope.Node,
Operand[0]->String.Pointer,
ACPI_NS_SEARCH_PARENT,
ACPI_CAST_INDIRECT_PTR (

10
sys/contrib/dev/acpica/components/executer/exresop.c
View file

@ -428,11 +428,13 @@ AcpiExResolveOperands (
case ARGI_INTEGER:
/*
* Need an operand of type ACPI_TYPE_INTEGER,
* But we can implicitly convert from a STRING or BUFFER
* Aka - "Implicit Source Operand Conversion"
* Need an operand of type ACPI_TYPE_INTEGER, but we can
* implicitly convert from a STRING or BUFFER.
*
* Known as "Implicit Source Operand Conversion"
*/
Status = AcpiExConvertToInteger (ObjDesc, StackPtr, 16);
Status = AcpiExConvertToInteger (ObjDesc, StackPtr,
ACPI_STRTOUL_BASE16);
if (ACPI_FAILURE (Status))
{
if (Status == AE_TYPE)

28
sys/contrib/dev/acpica/components/executer/extrace.c
View file

@ -226,7 +226,6 @@ AcpiExStartTraceMethod (
ACPI_OPERAND_OBJECT *ObjDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
char *Pathname = NULL;
BOOLEAN Enabled = FALSE;
@ -239,12 +238,6 @@ AcpiExStartTraceMethod (
Pathname = AcpiNsGetNormalizedPathname (MethodNode, TRUE);
}
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
goto Exit;
}
Enabled = AcpiExInterpreterTraceEnabled (Pathname);
if (Enabled && !AcpiGbl_TraceMethodObject)
{
@ -265,9 +258,6 @@ AcpiExStartTraceMethod (
}
}
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
Exit:
if (Enabled)
{
ACPI_TRACE_POINT (ACPI_TRACE_AML_METHOD, TRUE,
@ -302,7 +292,6 @@ AcpiExStopTraceMethod (
ACPI_OPERAND_OBJECT *ObjDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
char *Pathname = NULL;
BOOLEAN Enabled;
@ -315,28 +304,14 @@ AcpiExStopTraceMethod (
Pathname = AcpiNsGetNormalizedPathname (MethodNode, TRUE);
}
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
goto ExitPath;
}
Enabled = AcpiExInterpreterTraceEnabled (NULL);
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (Enabled)
{
ACPI_TRACE_POINT (ACPI_TRACE_AML_METHOD, FALSE,
ObjDesc ? ObjDesc->Method.AmlStart : NULL, Pathname);
}
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
goto ExitPath;
}
/* Check whether the tracer should be stopped */
if (AcpiGbl_TraceMethodObject == ObjDesc)
@ -353,9 +328,6 @@ AcpiExStopTraceMethod (
AcpiGbl_TraceMethodObject = NULL;
}
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
ExitPath:
if (Pathname)
{
ACPI_FREE (Pathname);

10
sys/contrib/dev/acpica/components/executer/exutils.c
View file

@ -103,6 +103,11 @@ AcpiExEnterInterpreter (
{
ACPI_ERROR ((AE_INFO, "Could not acquire AML Interpreter mutex"));
}
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
ACPI_ERROR ((AE_INFO, "Could not acquire AML Namespace mutex"));
}
return_VOID;
}
@ -141,6 +146,11 @@ AcpiExExitInterpreter (
ACPI_FUNCTION_TRACE (ExExitInterpreter);
Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
ACPI_ERROR ((AE_INFO, "Could not release AML Namespace mutex"));
}
Status = AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
if (ACPI_FAILURE (Status))
{

22
sys/contrib/dev/acpica/components/hardware/hwgpe.c
View file

@ -108,7 +108,7 @@ AcpiHwLowSetGpe (
UINT32 Action)
{
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
ACPI_STATUS Status;
ACPI_STATUS Status = AE_OK;
UINT32 EnableMask;
UINT32 RegisterBit;
@ -164,9 +164,12 @@ AcpiHwLowSetGpe (
return (AE_BAD_PARAMETER);
}
/* Write the updated enable mask */
if (!(RegisterBit & GpeRegisterInfo->MaskForRun))
{
/* Write the updated enable mask */
Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
}
return (Status);
}
@ -269,6 +272,13 @@ AcpiHwGetGpeStatus (
LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
}
/* GPE currently masked? (masked for runtime?) */
if (RegisterBit & GpeRegisterInfo->MaskForRun)
{
LocalEventStatus |= ACPI_EVENT_FLAG_MASKED;
}
/* GPE enabled for wake? */
if (RegisterBit & GpeRegisterInfo->EnableForWake)
@ -440,6 +450,7 @@ AcpiHwEnableRuntimeGpeBlock (
UINT32 i;
ACPI_STATUS Status;
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
UINT8 EnableMask;
/* NOTE: assumes that all GPEs are currently disabled */
@ -456,8 +467,9 @@ AcpiHwEnableRuntimeGpeBlock (
/* Enable all "runtime" GPEs in this register */
Status = AcpiHwGpeEnableWrite (GpeRegisterInfo->EnableForRun,
GpeRegisterInfo);
EnableMask = GpeRegisterInfo->EnableForRun &
~GpeRegisterInfo->MaskForRun;
Status = AcpiHwGpeEnableWrite (EnableMask, GpeRegisterInfo);
if (ACPI_FAILURE (Status))
{
return (Status);

2
sys/contrib/dev/acpica/components/namespace/nsconvert.c
View file

@ -84,7 +84,7 @@ AcpiNsConvertToInteger (
/* String-to-Integer conversion */
Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer,
ACPI_ANY_BASE, AcpiGbl_IntegerByteWidth, &Value);
AcpiGbl_IntegerByteWidth, &Value);
if (ACPI_FAILURE (Status))
{
return (Status);

30
sys/contrib/dev/acpica/components/namespace/nsload.c
View file

@ -46,6 +46,7 @@
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/acdispat.h>
#include <contrib/dev/acpica/include/actables.h>
#include <contrib/dev/acpica/include/acinterp.h>
#define _COMPONENT ACPI_NAMESPACE
@ -89,21 +90,6 @@ AcpiNsLoadTable (
ACPI_FUNCTION_TRACE (NsLoadTable);
/*
* Parse the table and load the namespace with all named
* objects found within. Control methods are NOT parsed
* at this time. In fact, the control methods cannot be
* parsed until the entire namespace is loaded, because
* if a control method makes a forward reference (call)
* to another control method, we can't continue parsing
* because we don't know how many arguments to parse next!
*/
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* If table already loaded into namespace, just return */
if (AcpiTbIsTableLoaded (TableIndex))
@ -121,6 +107,15 @@ AcpiNsLoadTable (
goto Unlock;
}
/*
* Parse the table and load the namespace with all named
* objects found within. Control methods are NOT parsed
* at this time. In fact, the control methods cannot be
* parsed until the entire namespace is loaded, because
* if a control method makes a forward reference (call)
* to another control method, we can't continue parsing
* because we don't know how many arguments to parse next!
*/
Status = AcpiNsParseTable (TableIndex, Node);
if (ACPI_SUCCESS (Status))
{
@ -137,7 +132,6 @@ AcpiNsLoadTable (
* exist. This target of Scope must already exist in the
* namespace, as per the ACPI specification.
*/
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
AcpiNsDeleteNamespaceByOwner (
AcpiGbl_RootTableList.Tables[TableIndex].OwnerId);
@ -146,8 +140,6 @@ AcpiNsLoadTable (
}
Unlock:
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -180,7 +172,7 @@ Unlock:
* other ACPI implementations. Optionally, the execution can be deferred
* until later, see AcpiInitializeObjects.
*/
if (!AcpiGbl_GroupModuleLevelCode)
if (!AcpiGbl_ParseTableAsTermList && !AcpiGbl_GroupModuleLevelCode)
{
AcpiNsExecModuleCodeList ();
}

181
sys/contrib/dev/acpica/components/namespace/nsparse.c
View file

@ -47,12 +47,116 @@
#include <contrib/dev/acpica/include/acparser.h>
#include <contrib/dev/acpica/include/acdispat.h>
#include <contrib/dev/acpica/include/actables.h>
#include <contrib/dev/acpica/include/acinterp.h>
#define _COMPONENT ACPI_NAMESPACE
ACPI_MODULE_NAME ("nsparse")
/*******************************************************************************
*
* FUNCTION: NsExecuteTable
*
* PARAMETERS: TableDesc - An ACPI table descriptor for table to parse
* StartNode - Where to enter the table into the namespace
*
* RETURN: Status
*
* DESCRIPTION: Load ACPI/AML table by executing the entire table as a
* TermList.
*
******************************************************************************/
ACPI_STATUS
AcpiNsExecuteTable (
UINT32 TableIndex,
ACPI_NAMESPACE_NODE *StartNode)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER *Table;
ACPI_OWNER_ID OwnerId;
ACPI_EVALUATE_INFO *Info = NULL;
UINT32 AmlLength;
UINT8 *AmlStart;
ACPI_OPERAND_OBJECT *MethodObj = NULL;
ACPI_FUNCTION_TRACE (NsExecuteTable);
Status = AcpiGetTableByIndex (TableIndex, &Table);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Table must consist of at least a complete header */
if (Table->Length < sizeof (ACPI_TABLE_HEADER))
{
return_ACPI_STATUS (AE_BAD_HEADER);
}
AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);
AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Create, initialize, and link a new temporary method object */
MethodObj = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
if (!MethodObj)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Allocate the evaluation information block */
Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
if (!Info)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Create table code block: %p\n", MethodObj));
MethodObj->Method.AmlStart = AmlStart;
MethodObj->Method.AmlLength = AmlLength;
MethodObj->Method.OwnerId = OwnerId;
MethodObj->Method.InfoFlags |= ACPI_METHOD_MODULE_LEVEL;
Info->PassNumber = ACPI_IMODE_EXECUTE;
Info->Node = StartNode;
Info->ObjDesc = MethodObj;
Info->NodeFlags = Info->Node->Flags;
Info->FullPathname = AcpiNsGetNormalizedPathname (Info->Node, TRUE);
if (!Info->FullPathname)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
Status = AcpiPsExecuteTable (Info);
Cleanup:
if (Info)
{
ACPI_FREE (Info->FullPathname);
Info->FullPathname = NULL;
}
ACPI_FREE (Info);
AcpiUtRemoveReference (MethodObj);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: NsOneCompleteParse
@ -156,7 +260,9 @@ AcpiNsOneCompleteParse (
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"*PARSE* pass %u parse\n", PassNumber));
AcpiExEnterInterpreter ();
Status = AcpiPsParseAml (WalkState);
AcpiExExitInterpreter ();
Cleanup:
AcpiPsDeleteParseTree (ParseRoot);
@ -188,40 +294,53 @@ AcpiNsParseTable (
ACPI_FUNCTION_TRACE (NsParseTable);
/*
* AML Parse, pass 1
*
* In this pass, we load most of the namespace. Control methods
* are not parsed until later. A parse tree is not created. Instead,
* each Parser Op subtree is deleted when it is finished. This saves
* a great deal of memory, and allows a small cache of parse objects
* to service the entire parse. The second pass of the parse then
* performs another complete parse of the AML.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Start pass 1\n"));
Status = AcpiNsOneCompleteParse (ACPI_IMODE_LOAD_PASS1,
TableIndex, StartNode);
if (ACPI_FAILURE (Status))
if (AcpiGbl_ParseTableAsTermList)
{
return_ACPI_STATUS (Status);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Start load pass\n"));
Status = AcpiNsExecuteTable (TableIndex, StartNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* AML Parse, pass 2
*
* In this pass, we resolve forward references and other things
* that could not be completed during the first pass.
* Another complete parse of the AML is performed, but the
* overhead of this is compensated for by the fact that the
* parse objects are all cached.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Start pass 2\n"));
Status = AcpiNsOneCompleteParse (ACPI_IMODE_LOAD_PASS2,
TableIndex, StartNode);
if (ACPI_FAILURE (Status))
else
{
return_ACPI_STATUS (Status);
/*
* AML Parse, pass 1
*
* In this pass, we load most of the namespace. Control methods
* are not parsed until later. A parse tree is not created.
* Instead, each Parser Op subtree is deleted when it is finished.
* This saves a great deal of memory, and allows a small cache of
* parse objects to service the entire parse. The second pass of
* the parse then performs another complete parse of the AML.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Start pass 1\n"));
Status = AcpiNsOneCompleteParse (ACPI_IMODE_LOAD_PASS1,
TableIndex, StartNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/*
* AML Parse, pass 2
*
* In this pass, we resolve forward references and other things
* that could not be completed during the first pass.
* Another complete parse of the AML is performed, but the
* overhead of this is compensated for by the fact that the
* parse objects are all cached.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Start pass 2\n"));
Status = AcpiNsOneCompleteParse (ACPI_IMODE_LOAD_PASS2,
TableIndex, StartNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
return_ACPI_STATUS (Status);

68
sys/contrib/dev/acpica/components/namespace/nsutils.c
View file

@ -771,7 +771,7 @@ AcpiNsOpensScope (
/*******************************************************************************
*
* FUNCTION: AcpiNsGetNode
* FUNCTION: AcpiNsGetNodeUnlocked
*
* PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
* \ (backslash) and ^ (carat) prefixes, and the
@ -787,12 +787,12 @@ AcpiNsOpensScope (
* DESCRIPTION: Look up a name relative to a given scope and return the
* corresponding Node. NOTE: Scope can be null.
*
* MUTEX: Locks namespace
* MUTEX: Doesn't locks namespace
*
******************************************************************************/
ACPI_STATUS
AcpiNsGetNode (
AcpiNsGetNodeUnlocked (
ACPI_NAMESPACE_NODE *PrefixNode,
const char *Pathname,
UINT32 Flags,
@ -803,7 +803,7 @@ AcpiNsGetNode (
char *InternalPath;
ACPI_FUNCTION_TRACE_PTR (NsGetNode, ACPI_CAST_PTR (char, Pathname));
ACPI_FUNCTION_TRACE_PTR (NsGetNodeUnlocked, ACPI_CAST_PTR (char, Pathname));
/* Simplest case is a null pathname */
@ -835,14 +835,6 @@ AcpiNsGetNode (
return_ACPI_STATUS (Status);
}
/* Must lock namespace during lookup */
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
/* Setup lookup scope (search starting point) */
ScopeInfo.Scope.Node = PrefixNode;
@ -858,9 +850,55 @@ AcpiNsGetNode (
Pathname, AcpiFormatException (Status)));
}
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
Cleanup:
ACPI_FREE (InternalPath);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiNsGetNode
*
* PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
* \ (backslash) and ^ (carat) prefixes, and the
* . (period) to separate segments are supported.
* PrefixNode - Root of subtree to be searched, or NS_ALL for the
* root of the name space. If Name is fully
* qualified (first INT8 is '\'), the passed value
* of Scope will not be accessed.
* Flags - Used to indicate whether to perform upsearch or
* not.
* ReturnNode - Where the Node is returned
*
* DESCRIPTION: Look up a name relative to a given scope and return the
* corresponding Node. NOTE: Scope can be null.
*
* MUTEX: Locks namespace
*
******************************************************************************/
ACPI_STATUS
AcpiNsGetNode (
ACPI_NAMESPACE_NODE *PrefixNode,
const char *Pathname,
UINT32 Flags,
ACPI_NAMESPACE_NODE **ReturnNode)
{
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE_PTR (NsGetNode, ACPI_CAST_PTR (char, Pathname));
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
Status = AcpiNsGetNodeUnlocked (PrefixNode, Pathname,
Flags, ReturnNode);
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
return_ACPI_STATUS (Status);
}

5
sys/contrib/dev/acpica/components/parser/psparse.c
View file

@ -555,8 +555,10 @@ AcpiPsParseAml (
{
/* Either the method parse or actual execution failed */
AcpiExExitInterpreter ();
ACPI_ERROR_METHOD ("Method parse/execution failed",
WalkState->MethodNode, NULL, Status);
AcpiExEnterInterpreter ();
/* Check for possible multi-thread reentrancy problem */
@ -589,7 +591,8 @@ AcpiPsParseAml (
* cleanup to do
*/
if (((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
ACPI_PARSE_EXECUTE) ||
ACPI_PARSE_EXECUTE &&
!(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) ||
(ACPI_FAILURE (Status)))
{
AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);

94
sys/contrib/dev/acpica/components/parser/psxface.c
View file

@ -273,6 +273,100 @@ Cleanup:
}
/*******************************************************************************
*
* FUNCTION: AcpiPsExecuteTable
*
* PARAMETERS: Info - Method info block, contains:
* Node - Node to where the is entered into the
* namespace
* ObjDesc - Pseudo method object describing the AML
* code of the entire table
* PassNumber - Parse or execute pass
*
* RETURN: Status
*
* DESCRIPTION: Execute a table
*
******************************************************************************/
ACPI_STATUS
AcpiPsExecuteTable (
ACPI_EVALUATE_INFO *Info)
{
ACPI_STATUS Status;
ACPI_PARSE_OBJECT *Op = NULL;
ACPI_WALK_STATE *WalkState = NULL;
ACPI_FUNCTION_TRACE (PsExecuteTable);
/* Create and init a Root Node */
Op = AcpiPsCreateScopeOp (Info->ObjDesc->Method.AmlStart);
if (!Op)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
/* Create and initialize a new walk state */
WalkState = AcpiDsCreateWalkState (
Info->ObjDesc->Method.OwnerId, NULL, NULL, NULL);
if (!WalkState)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
Status = AcpiDsInitAmlWalk (WalkState, Op, Info->Node,
Info->ObjDesc->Method.AmlStart,
Info->ObjDesc->Method.AmlLength, Info, Info->PassNumber);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)
{
WalkState->ParseFlags |= ACPI_PARSE_MODULE_LEVEL;
}
/* Info->Node is the default location to load the table */
if (Info->Node && Info->Node != AcpiGbl_RootNode)
{
Status = AcpiDsScopeStackPush (
Info->Node, ACPI_TYPE_METHOD, WalkState);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
}
/*
* Parse the AML, WalkState will be deleted by ParseAml
*/
AcpiExEnterInterpreter ();
Status = AcpiPsParseAml (WalkState);
AcpiExExitInterpreter ();
WalkState = NULL;
Cleanup:
if (WalkState)
{
AcpiDsDeleteWalkState (WalkState);
}
if (Op)
{
AcpiPsDeleteParseTree (Op);
}
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiPsUpdateParameterList

165
sys/contrib/dev/acpica/components/tables/tbdata.c
View file

@ -45,6 +45,7 @@
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/actables.h>
#include <contrib/dev/acpica/include/acevents.h>
#define _COMPONENT ACPI_TABLES
ACPI_MODULE_NAME ("tbdata")
@ -680,18 +681,13 @@ AcpiTbDeleteNamespaceByOwner (
* lock may block, and also since the execution of a namespace walk
* must be allowed to use the interpreter.
*/
(void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
Status = AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock);
AcpiNsDeleteNamespaceByOwner (OwnerId);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
AcpiNsDeleteNamespaceByOwner (OwnerId);
AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock);
Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
return_ACPI_STATUS (Status);
}
@ -867,3 +863,160 @@ AcpiTbSetTableLoadedFlag (
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
}
/*******************************************************************************
*
* FUNCTION: AcpiTbLoadTable
*
* PARAMETERS: TableIndex - Table index
* ParentNode - Where table index is returned
*
* RETURN: Status
*
* DESCRIPTION: Load an ACPI table
*
******************************************************************************/
ACPI_STATUS
AcpiTbLoadTable (
UINT32 TableIndex,
ACPI_NAMESPACE_NODE *ParentNode)
{
ACPI_TABLE_HEADER *Table;
ACPI_STATUS Status;
ACPI_OWNER_ID OwnerId;
ACPI_FUNCTION_TRACE (TbLoadTable);
/*
* Note: Now table is "INSTALLED", it must be validated before
* using.
*/
Status = AcpiGetTableByIndex (TableIndex, &Table);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
Status = AcpiNsLoadTable (TableIndex, ParentNode);
/* Execute any module-level code that was found in the table */
if (!AcpiGbl_ParseTableAsTermList && AcpiGbl_GroupModuleLevelCode)
{
AcpiNsExecModuleCodeList ();
}
/*
* Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
* responsible for discovering any new wake GPEs by running _PRW methods
* that may have been loaded by this table.
*/
Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);
if (ACPI_SUCCESS (Status))
{
AcpiEvUpdateGpes (OwnerId);
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
AcpiGbl_TableHandlerContext);
}
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiTbInstallAndLoadTable
*
* PARAMETERS: Table - Pointer to the table
* Address - Physical address of the table
* Flags - Allocation flags of the table
* TableIndex - Where table index is returned
*
* RETURN: Status
*
* DESCRIPTION: Install and load an ACPI table
*
******************************************************************************/
ACPI_STATUS
AcpiTbInstallAndLoadTable (
ACPI_TABLE_HEADER *Table,
ACPI_PHYSICAL_ADDRESS Address,
UINT8 Flags,
BOOLEAN Override,
UINT32 *TableIndex)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_OWNER_ID OwnerId;
ACPI_FUNCTION_TRACE (AcpiLoadTable);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
/* Install the table and load it into the namespace */
Status = AcpiTbInstallStandardTable (Address, Flags, TRUE,
Override, &i);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
/*
* Note: Now table is "INSTALLED", it must be validated before
* using.
*/
Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[i]);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
Status = AcpiNsLoadTable (i, AcpiGbl_RootNode);
/* Execute any module-level code that was found in the table */
if (!AcpiGbl_ParseTableAsTermList && AcpiGbl_GroupModuleLevelCode)
{
AcpiNsExecModuleCodeList ();
}
/*
* Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
* responsible for discovering any new wake GPEs by running _PRW methods
* that may have been loaded by this table.
*/
Status = AcpiTbGetOwnerId (i, &OwnerId);
if (ACPI_SUCCESS (Status))
{
AcpiEvUpdateGpes (OwnerId);
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
AcpiGbl_TableHandlerContext);
}
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
UnlockAndExit:
*TableIndex = i;
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
}

114
sys/contrib/dev/acpica/components/tables/tbfadt.c
View file

@ -375,8 +375,10 @@ AcpiTbParseFadt (
/* Obtain the DSDT and FACS tables via their addresses within the FADT */
AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt,
ACPI_SIG_DSDT, &AcpiGbl_DsdtIndex);
AcpiTbInstallStandardTable (
(ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt,
ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, FALSE, TRUE,
&AcpiGbl_DsdtIndex);
/* If Hardware Reduced flag is set, there is no FACS */
@ -384,13 +386,17 @@ AcpiTbParseFadt (
{
if (AcpiGbl_FADT.Facs)
{
AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.Facs,
ACPI_SIG_FACS, &AcpiGbl_FacsIndex);
AcpiTbInstallStandardTable (
(ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.Facs,
ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, FALSE, TRUE,
&AcpiGbl_FacsIndex);
}
if (AcpiGbl_FADT.XFacs)
{
AcpiTbInstallFixedTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs,
ACPI_SIG_FACS, &AcpiGbl_XFacsIndex);
AcpiTbInstallStandardTable (
(ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs,
ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, FALSE, TRUE,
&AcpiGbl_XFacsIndex);
}
}
}
@ -516,17 +522,19 @@ AcpiTbConvertFadt (
/*
* For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
* For ACPI 1.0 FADTs (revision 1), ensure that reserved fields which
* should be zero are indeed zero. This will workaround BIOSs that
* inadvertently place values in these fields.
*
* The ACPI 1.0 reserved fields that will be zeroed are the bytes located
* at offset 45, 55, 95, and the word located at offset 109, 110.
*
* Note: The FADT revision value is unreliable. Only the length can be
* trusted.
* Note: The FADT revision value is unreliable because of BIOS errors.
* The table length is instead used as the final word on the version.
*
* Note: FADT revision 3 is the ACPI 2.0 version of the FADT.
*/
if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V2_SIZE)
if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V3_SIZE)
{
AcpiGbl_FADT.PreferredProfile = 0;
AcpiGbl_FADT.PstateControl = 0;
@ -591,65 +599,67 @@ AcpiTbConvertFadt (
*
* Address32 zero, Address64 [don't care] - Use Address64
*
* No override: if AcpiGbl_Use32BitFadtAddresses is FALSE, and:
* Address32 non-zero, Address64 zero - Copy/use Address32
* Address32 non-zero == Address64 non-zero - Use Address64
* Address32 non-zero != Address64 non-zero - Warning, use Address64
*
* Override: if AcpiGbl_Use32BitFadtAddresses is TRUE, and:
* Address32 non-zero, Address64 zero - Copy/use Address32
* Address32 non-zero == Address64 non-zero - Copy/use Address32
* Address32 non-zero != Address64 non-zero - Warning, copy/use Address32
*
* Note: SpaceId is always I/O for 32-bit legacy address fields
*/
if (Address32)
{
if (!Address64->Address)
if (Address64->Address)
{
/* 64-bit address is zero, use 32-bit address */
AcpiTbInitGenericAddress (Address64,
ACPI_ADR_SPACE_SYSTEM_IO,
*ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT,
FadtInfoTable[i].Length),
(UINT64) Address32, Name, Flags);
}
else if (Address64->Address != (UINT64) Address32)
{
/* Address mismatch */
ACPI_BIOS_WARNING ((AE_INFO,
"32/64X address mismatch in FADT/%s: "
"0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
Name, Address32,
ACPI_FORMAT_UINT64 (Address64->Address),
AcpiGbl_Use32BitFadtAddresses ? 32 : 64));
if (AcpiGbl_Use32BitFadtAddresses)
if (Address64->Address != (UINT64) Address32)
{
/* 32-bit address override */
/* Address mismatch */
AcpiTbInitGenericAddress (Address64,
ACPI_ADR_SPACE_SYSTEM_IO,
*ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT,
FadtInfoTable[i].Length),
(UINT64) Address32, Name, Flags);
ACPI_BIOS_WARNING ((AE_INFO,
"32/64X address mismatch in FADT/%s: "
"0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
Name, Address32,
ACPI_FORMAT_UINT64 (Address64->Address),
AcpiGbl_Use32BitFadtAddresses ? 32 : 64));
}
/*
* For each extended field, check for length mismatch
* between the legacy length field and the corresponding
* 64-bit X length field.
* Note: If the legacy length field is > 0xFF bits, ignore
* this check. (GPE registers can be larger than the
* 64-bit GAS structure can accomodate, 0xFF bits).
*/
if ((ACPI_MUL_8 (Length) <= ACPI_UINT8_MAX) &&
(Address64->BitWidth != ACPI_MUL_8 (Length)))
{
ACPI_BIOS_WARNING ((AE_INFO,
"32/64X length mismatch in FADT/%s: %u/%u",
Name, ACPI_MUL_8 (Length), Address64->BitWidth));
}
}
}
/*
* For each extended field, check for length mismatch between the
* legacy length field and the corresponding 64-bit X length field.
* Note: If the legacy length field is > 0xFF bits, ignore this
* check. (GPE registers can be larger than the 64-bit GAS structure
* can accomodate, 0xFF bits).
*/
if (Address64->Address &&
(ACPI_MUL_8 (Length) <= ACPI_UINT8_MAX) &&
(Address64->BitWidth != ACPI_MUL_8 (Length)))
{
ACPI_BIOS_WARNING ((AE_INFO,
"32/64X length mismatch in FADT/%s: %u/%u",
Name, ACPI_MUL_8 (Length), Address64->BitWidth));
/*
* Hardware register access code always uses the 64-bit fields.
* So if the 64-bit field is zero or is to be overridden,
* initialize it with the 32-bit fields.
* Note that when the 32-bit address favor is specified, the
* 64-bit fields are always re-initialized so that
* AccessSize/BitWidth/BitOffset fields can be correctly
* configured to the values to trigger a 32-bit compatible
* access mode in the hardware register access code.
*/
if (!Address64->Address || AcpiGbl_Use32BitFadtAddresses)
{
AcpiTbInitGenericAddress (Address64,
ACPI_ADR_SPACE_SYSTEM_IO, Length,
(UINT64) Address32, Name, Flags);
}
}
if (FadtInfoTable[i].Flags & ACPI_FADT_REQUIRED)

12
sys/contrib/dev/acpica/components/tables/tbfind.c
View file

@ -73,7 +73,7 @@ AcpiTbFindTable (
char *OemTableId,
UINT32 *TableIndex)
{
ACPI_STATUS Status;
ACPI_STATUS Status = AE_OK;
ACPI_TABLE_HEADER Header;
UINT32 i;
@ -105,6 +105,7 @@ AcpiTbFindTable (
/* Search for the table */
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
{
if (memcmp (&(AcpiGbl_RootTableList.Tables[i].Signature),
@ -124,7 +125,7 @@ AcpiTbFindTable (
Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[i]);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
goto UnlockAndExit;
}
if (!AcpiGbl_RootTableList.Tables[i].Pointer)
@ -148,9 +149,12 @@ AcpiTbFindTable (
ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "Found table [%4.4s]\n",
Header.Signature));
return_ACPI_STATUS (AE_OK);
goto UnlockAndExit;
}
}
Status = AE_NOT_FOUND;
return_ACPI_STATUS (AE_NOT_FOUND);
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
}

79
sys/contrib/dev/acpica/components/tables/tbinstal.c
View file

@ -167,74 +167,6 @@ AcpiTbInstallTableWithOverride (
}
/*******************************************************************************
*
* FUNCTION: AcpiTbInstallFixedTable
*
* PARAMETERS: Address - Physical address of DSDT or FACS
* Signature - Table signature, NULL if no need to
* match
* TableIndex - Where the table index is returned
*
* RETURN: Status
*
* DESCRIPTION: Install a fixed ACPI table (DSDT/FACS) into the global data
* structure.
*
******************************************************************************/
ACPI_STATUS
AcpiTbInstallFixedTable (
ACPI_PHYSICAL_ADDRESS Address,
char *Signature,
UINT32 *TableIndex)
{
ACPI_TABLE_DESC NewTableDesc;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (TbInstallFixedTable);
if (!Address)
{
ACPI_ERROR ((AE_INFO, "Null physical address for ACPI table [%s]",
Signature));
return (AE_NO_MEMORY);
}
/* Fill a table descriptor for validation */
Status = AcpiTbAcquireTempTable (&NewTableDesc, Address,
ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL);
if (ACPI_FAILURE (Status))
{
ACPI_ERROR ((AE_INFO, "Could not acquire table length at %8.8X%8.8X",
ACPI_FORMAT_UINT64 (Address)));
return_ACPI_STATUS (Status);
}
/* Validate and verify a table before installation */
Status = AcpiTbVerifyTempTable (&NewTableDesc, Signature);
if (ACPI_FAILURE (Status))
{
goto ReleaseAndExit;
}
/* Add the table to the global root table list */
AcpiTbInstallTableWithOverride (&NewTableDesc, TRUE, TableIndex);
ReleaseAndExit:
/* Release the temporary table descriptor */
AcpiTbReleaseTempTable (&NewTableDesc);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiTbInstallStandardTable
@ -248,8 +180,7 @@ ReleaseAndExit:
*
* RETURN: Status
*
* DESCRIPTION: This function is called to install an ACPI table that is
* neither DSDT nor FACS (a "standard" table.)
* DESCRIPTION: This function is called to verify and install an ACPI table.
* When this function is called by "Load" or "LoadTable" opcodes,
* or by AcpiLoadTable() API, the "Reload" parameter is set.
* After sucessfully returning from this function, table is
@ -390,6 +321,14 @@ AcpiTbInstallStandardTable (
AcpiTbInstallTableWithOverride (&NewTableDesc, Override, TableIndex);
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_INSTALL,
NewTableDesc.Pointer, AcpiGbl_TableHandlerContext);
}
ReleaseAndExit:
/* Release the temporary table descriptor */

2
sys/contrib/dev/acpica/components/tables/tbutils.c
View file

@ -273,7 +273,7 @@ AcpiTbGetRootTableEntry (
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiTbParseRootTable (
ACPI_PHYSICAL_ADDRESS RsdpAddress)
{

4
sys/contrib/dev/acpica/components/tables/tbxface.c
View file

@ -103,7 +103,7 @@ AcpiAllocateRootTable (
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiInitializeTables (
ACPI_TABLE_DESC *InitialTableArray,
UINT32 InitialTableCount,
@ -179,7 +179,7 @@ ACPI_EXPORT_SYMBOL_INIT (AcpiInitializeTables)
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiReallocateRootTable (
void)
{

75
sys/contrib/dev/acpica/components/tables/tbxfload.c
View file

@ -65,7 +65,7 @@
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiLoadTables (
void)
{
@ -111,7 +111,7 @@ AcpiLoadTables (
"While loading namespace from ACPI tables"));
}
if (!AcpiGbl_GroupModuleLevelCode)
if (AcpiGbl_ParseTableAsTermList || !AcpiGbl_GroupModuleLevelCode)
{
/*
* Initialize the objects that remain uninitialized. This
@ -207,11 +207,11 @@ AcpiTbLoadNamespace (
memcpy (&AcpiGbl_OriginalDsdtHeader, AcpiGbl_DSDT,
sizeof (ACPI_TABLE_HEADER));
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
/* Load and parse tables */
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
Status = AcpiNsLoadTable (AcpiGbl_DsdtIndex, AcpiGbl_RootNode);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "[DSDT] table load failed"));
@ -224,7 +224,6 @@ AcpiTbLoadNamespace (
/* Load any SSDT or PSDT tables. Note: Loop leaves tables locked */
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
{
Table = &AcpiGbl_RootTableList.Tables[i];
@ -242,6 +241,7 @@ AcpiTbLoadNamespace (
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
Status = AcpiNsLoadTable (i, AcpiGbl_RootNode);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "(%4.4s:%8.8s) while loading table",
@ -257,14 +257,12 @@ AcpiTbLoadNamespace (
{
TablesLoaded++;
}
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
}
if (!TablesFailed)
{
ACPI_INFO ((
"%u ACPI AML tables successfully acquired and loaded\n",
"%u ACPI AML tables successfully acquired and loaded",
TablesLoaded));
}
else
@ -278,6 +276,11 @@ AcpiTbLoadNamespace (
Status = AE_CTRL_TERMINATE;
}
#ifdef ACPI_APPLICATION
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "\n"));
#endif
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
@ -300,7 +303,7 @@ UnlockAndExit:
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiInstallTable (
ACPI_PHYSICAL_ADDRESS Address,
BOOLEAN Physical)
@ -366,52 +369,11 @@ AcpiLoadTable (
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* Must acquire the interpreter lock during this operation */
Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Install the table and load it into the namespace */
ACPI_INFO (("Host-directed Dynamic ACPI Table Load:"));
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
Status = AcpiTbInstallStandardTable (ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL, TRUE, FALSE,
&TableIndex);
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
/*
* Note: Now table is "INSTALLED", it must be validated before
* using.
*/
Status = AcpiTbValidateTable (
&AcpiGbl_RootTableList.Tables[TableIndex]);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
Status = AcpiNsLoadTable (TableIndex, AcpiGbl_RootNode);
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
AcpiGbl_TableHandlerContext);
}
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
Status = AcpiTbInstallAndLoadTable (Table, ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL, FALSE, &TableIndex);
return_ACPI_STATUS (Status);
}
@ -466,9 +428,9 @@ AcpiUnloadParentTable (
return_ACPI_STATUS (AE_TYPE);
}
/* Must acquire the interpreter lock during this operation */
/* Must acquire the table lock during this operation */
Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
@ -499,9 +461,11 @@ AcpiUnloadParentTable (
/* Ensure the table is actually loaded */
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
if (!AcpiTbIsTableLoaded (i))
{
Status = AE_NOT_EXIST;
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
break;
}
@ -528,10 +492,11 @@ AcpiUnloadParentTable (
Status = AcpiTbReleaseOwnerId (i);
AcpiTbSetTableLoadedFlag (i, FALSE);
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
break;
}
(void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
}

4
sys/contrib/dev/acpica/components/tables/tbxfroot.c
View file

@ -156,7 +156,7 @@ AcpiTbValidateRsdp (
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiFindRootPointer (
ACPI_PHYSICAL_ADDRESS *TableAddress)
{
@ -262,7 +262,7 @@ AcpiFindRootPointer (
return_ACPI_STATUS (AE_NOT_FOUND);
}
ACPI_EXPORT_SYMBOL (AcpiFindRootPointer)
ACPI_EXPORT_SYMBOL_INIT (AcpiFindRootPointer)
/*******************************************************************************

9
sys/contrib/dev/acpica/components/utilities/utaddress.c
View file

@ -82,7 +82,6 @@ AcpiUtAddAddressRange (
ACPI_NAMESPACE_NODE *RegionNode)
{
ACPI_ADDRESS_RANGE *RangeInfo;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (UtAddAddressRange);
@ -106,13 +105,6 @@ AcpiUtAddAddressRange (
RangeInfo->EndAddress = (Address + Length - 1);
RangeInfo->RegionNode = RegionNode;
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
ACPI_FREE (RangeInfo);
return_ACPI_STATUS (Status);
}
RangeInfo->Next = AcpiGbl_AddressRangeList[SpaceId];
AcpiGbl_AddressRangeList[SpaceId] = RangeInfo;
@ -122,7 +114,6 @@ AcpiUtAddAddressRange (
ACPI_FORMAT_UINT64 (Address),
ACPI_FORMAT_UINT64 (RangeInfo->EndAddress)));
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
return_ACPI_STATUS (AE_OK);
}

26
sys/contrib/dev/acpica/components/utilities/utbuffer.c
View file

@ -264,7 +264,7 @@ AcpiUtDumpBufferToFile (
if (!Buffer)
{
AcpiUtFilePrintf (File, "Null Buffer Pointer in DumpBuffer!\n");
fprintf (File, "Null Buffer Pointer in DumpBuffer!\n");
return;
}
@ -279,7 +279,7 @@ AcpiUtDumpBufferToFile (
{
/* Print current offset */
AcpiUtFilePrintf (File, "%6.4X: ", (BaseOffset + i));
fprintf (File, "%6.4X: ", (BaseOffset + i));
/* Print 16 hex chars */
@ -289,7 +289,7 @@ AcpiUtDumpBufferToFile (
{
/* Dump fill spaces */
AcpiUtFilePrintf (File, "%*s", ((Display * 2) + 1), " ");
fprintf (File, "%*s", ((Display * 2) + 1), " ");
j += Display;
continue;
}
@ -299,28 +299,28 @@ AcpiUtDumpBufferToFile (
case DB_BYTE_DISPLAY:
default: /* Default is BYTE display */
AcpiUtFilePrintf (File, "%02X ", Buffer[(ACPI_SIZE) i + j]);
fprintf (File, "%02X ", Buffer[(ACPI_SIZE) i + j]);
break;
case DB_WORD_DISPLAY:
ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
AcpiUtFilePrintf (File, "%04X ", Temp32);
fprintf (File, "%04X ", Temp32);
break;
case DB_DWORD_DISPLAY:
ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
AcpiUtFilePrintf (File, "%08X ", Temp32);
fprintf (File, "%08X ", Temp32);
break;
case DB_QWORD_DISPLAY:
ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
AcpiUtFilePrintf (File, "%08X", Temp32);
fprintf (File, "%08X", Temp32);
ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
AcpiUtFilePrintf (File, "%08X ", Temp32);
fprintf (File, "%08X ", Temp32);
break;
}
@ -331,29 +331,29 @@ AcpiUtDumpBufferToFile (
* Print the ASCII equivalent characters but watch out for the bad
* unprintable ones (printable chars are 0x20 through 0x7E)
*/
AcpiUtFilePrintf (File, " ");
fprintf (File, " ");
for (j = 0; j < 16; j++)
{
if (i + j >= Count)
{
AcpiUtFilePrintf (File, "\n");
fprintf (File, "\n");
return;
}
BufChar = Buffer[(ACPI_SIZE) i + j];
if (isprint (BufChar))
{
AcpiUtFilePrintf (File, "%c", BufChar);
fprintf (File, "%c", BufChar);
}
else
{
AcpiUtFilePrintf (File, ".");
fprintf (File, ".");
}
}
/* Done with that line. */
AcpiUtFilePrintf (File, "\n");
fprintf (File, "\n");
i += 16;
}

30
sys/contrib/dev/acpica/components/utilities/utdebug.c
View file

@ -708,33 +708,3 @@ AcpiTracePoint (
ACPI_EXPORT_SYMBOL (AcpiTracePoint)
#endif
#ifdef ACPI_APPLICATION
/*******************************************************************************
*
* FUNCTION: AcpiLogError
*
* PARAMETERS: Format - Printf format field
* ... - Optional printf arguments
*
* RETURN: None
*
* DESCRIPTION: Print error message to the console, used by applications.
*
******************************************************************************/
void ACPI_INTERNAL_VAR_XFACE
AcpiLogError (
const char *Format,
...)
{
va_list Args;
va_start (Args, Format);
(void) AcpiUtFileVprintf (ACPI_FILE_ERR, Format, Args);
va_end (Args);
}
ACPI_EXPORT_SYMBOL (AcpiLogError)
#endif

51
sys/contrib/dev/acpica/components/utilities/uthex.c
View file

@ -80,11 +80,48 @@ AcpiUtHexToAsciiChar (
}
/*******************************************************************************
*
* FUNCTION: AcpiUtAsciiToHexByte
*
* PARAMETERS: TwoAsciiChars - Pointer to two ASCII characters
* ReturnByte - Where converted byte is returned
*
* RETURN: Status and converted hex byte
*
* DESCRIPTION: Perform ascii-to-hex translation, exactly two ASCII characters
* to a single converted byte value.
*
******************************************************************************/
ACPI_STATUS
AcpiUtAsciiToHexByte (
char *TwoAsciiChars,
UINT8 *ReturnByte)
{
/* Both ASCII characters must be valid hex digits */
if (!isxdigit ((int) TwoAsciiChars[0]) ||
!isxdigit ((int) TwoAsciiChars[1]))
{
return (AE_BAD_HEX_CONSTANT);
}
*ReturnByte =
AcpiUtAsciiCharToHex (TwoAsciiChars[1]) |
(AcpiUtAsciiCharToHex (TwoAsciiChars[0]) << 4);
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtAsciiCharToHex
*
* PARAMETERS: HexChar - Hex character in Ascii
* PARAMETERS: HexChar - Hex character in Ascii. Must be:
* 0-9 or A-F or a-f
*
* RETURN: The binary value of the ascii/hex character
*
@ -97,15 +134,21 @@ AcpiUtAsciiCharToHex (
int HexChar)
{
if (HexChar <= 0x39)
/* Values 0-9 */
if (HexChar <= '9')
{
return ((UINT8) (HexChar - 0x30));
return ((UINT8) (HexChar - '0'));
}
if (HexChar <= 0x46)
/* Upper case A-F */
if (HexChar <= 'F')
{
return ((UINT8) (HexChar - 0x37));
}
/* Lower case a-f */
return ((UINT8) (HexChar - 0x57));
}

2
sys/contrib/dev/acpica/components/utilities/utinit.c
View file

@ -226,7 +226,7 @@ AcpiUtInitGlobals (
AcpiGbl_NextOwnerIdOffset = 0;
AcpiGbl_DebuggerConfiguration = DEBUGGER_THREADING;
AcpiGbl_OsiMutex = NULL;
AcpiGbl_MaxLoopIterations = 0xFFFF;
AcpiGbl_MaxLoopIterations = ACPI_MAX_LOOP_COUNT;
/* Hardware oriented */

432
sys/contrib/dev/acpica/components/utilities/utnonansi.c
View file

@ -48,10 +48,9 @@
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utnonansi")
/*
* Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit
* version of strtoul.
* Non-ANSI C library functions - strlwr, strupr, stricmp, and "safe"
* string functions.
*/
/*******************************************************************************
@ -238,430 +237,3 @@ AcpiUtSafeStrncat (
return (FALSE);
}
#endif
/*******************************************************************************
*
* FUNCTION: AcpiUtStrtoul64
*
* PARAMETERS: String - Null terminated string
* Base - Radix of the string: 16 or 10 or
* ACPI_ANY_BASE
* MaxIntegerByteWidth - Maximum allowable integer,in bytes:
* 4 or 8 (32 or 64 bits)
* RetInteger - Where the converted integer is
* returned
*
* RETURN: Status and Converted value
*
* DESCRIPTION: Convert a string into an unsigned value. Performs either a
* 32-bit or 64-bit conversion, depending on the input integer
* size (often the current mode of the interpreter).
*
* NOTES: Negative numbers are not supported, as they are not supported
* by ACPI.
*
* AcpiGbl_IntegerByteWidth should be set to the proper width.
* For the core ACPICA code, this width depends on the DSDT
* version. For iASL, the default byte width is always 8 for the
* parser, but error checking is performed later to flag cases
* where a 64-bit constant is defined in a 32-bit DSDT/SSDT.
*
* Does not support Octal strings, not needed at this time.
*
******************************************************************************/
ACPI_STATUS
AcpiUtStrtoul64 (
char *String,
UINT32 Base,
UINT32 MaxIntegerByteWidth,
UINT64 *RetInteger)
{
UINT32 ThisDigit = 0;
UINT64 ReturnValue = 0;
UINT64 Quotient;
UINT64 Dividend;
UINT8 ValidDigits = 0;
UINT8 SignOf0x = 0;
UINT8 Term = 0;
ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String);
switch (Base)
{
case ACPI_ANY_BASE:
case 10:
case 16:
break;
default:
/* Invalid Base */
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
if (!String)
{
goto ErrorExit;
}
/* Skip over any white space in the buffer */
while ((*String) && (isspace ((int) *String) || *String == '\t'))
{
String++;
}
if (Base == ACPI_ANY_BASE)
{
/*
* Base equal to ACPI_ANY_BASE means 'Either decimal or hex'.
* We need to determine if it is decimal or hexadecimal.
*/
if ((*String == '0') && (tolower ((int) *(String + 1)) == 'x'))
{
SignOf0x = 1;
Base = 16;
/* Skip over the leading '0x' */
String += 2;
}
else
{
Base = 10;
}
}
/* Any string left? Check that '0x' is not followed by white space. */
if (!(*String) || isspace ((int) *String) || *String == '\t')
{
if (Base == ACPI_ANY_BASE)
{
goto ErrorExit;
}
else
{
goto AllDone;
}
}
/*
* Perform a 32-bit or 64-bit conversion, depending upon the input
* byte width
*/
Dividend = (MaxIntegerByteWidth <= ACPI_MAX32_BYTE_WIDTH) ?
ACPI_UINT32_MAX : ACPI_UINT64_MAX;
/* Main loop: convert the string to a 32- or 64-bit integer */
while (*String)
{
if (isdigit ((int) *String))
{
/* Convert ASCII 0-9 to Decimal value */
ThisDigit = ((UINT8) *String) - '0';
}
else if (Base == 10)
{
/* Digit is out of range; possible in ToInteger case only */
Term = 1;
}
else
{
ThisDigit = (UINT8) toupper ((int) *String);
if (isxdigit ((int) ThisDigit))
{
/* Convert ASCII Hex char to value */
ThisDigit = ThisDigit - 'A' + 10;
}
else
{
Term = 1;
}
}
if (Term)
{
if (Base == ACPI_ANY_BASE)
{
goto ErrorExit;
}
else
{
break;
}
}
else if ((ValidDigits == 0) && (ThisDigit == 0) && !SignOf0x)
{
/* Skip zeros */
String++;
continue;
}
ValidDigits++;
if (SignOf0x && ((ValidDigits > 16) ||
((ValidDigits > 8) && (MaxIntegerByteWidth <= ACPI_MAX32_BYTE_WIDTH))))
{
/*
* This is ToInteger operation case.
* No restrictions for string-to-integer conversion,
* see ACPI spec.
*/
goto ErrorExit;
}
/* Divide the digit into the correct position */
(void) AcpiUtShortDivide (
(Dividend - (UINT64) ThisDigit), Base, &Quotient, NULL);
if (ReturnValue > Quotient)
{
if (Base == ACPI_ANY_BASE)
{
goto ErrorExit;
}
else
{
break;
}
}
ReturnValue *= Base;
ReturnValue += ThisDigit;
String++;
}
/* All done, normal exit */
AllDone:
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
ACPI_FORMAT_UINT64 (ReturnValue)));
*RetInteger = ReturnValue;
return_ACPI_STATUS (AE_OK);
ErrorExit:
/* Base was set/validated above (10 or 16) */
if (Base == 10)
{
return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT);
}
else
{
return_ACPI_STATUS (AE_BAD_HEX_CONSTANT);
}
}
#ifdef _OBSOLETE_FUNCTIONS
/* Removed: 01/2016 */
/*******************************************************************************
*
* FUNCTION: strtoul64
*
* PARAMETERS: String - Null terminated string
* Terminater - Where a pointer to the terminating byte
* is returned
* Base - Radix of the string
*
* RETURN: Converted value
*
* DESCRIPTION: Convert a string into an unsigned value.
*
******************************************************************************/
ACPI_STATUS
strtoul64 (
char *String,
UINT32 Base,
UINT64 *RetInteger)
{
UINT32 Index;
UINT32 Sign;
UINT64 ReturnValue = 0;
ACPI_STATUS Status = AE_OK;
*RetInteger = 0;
switch (Base)
{
case 0:
case 8:
case 10:
case 16:
break;
default:
/*
* The specified Base parameter is not in the domain of
* this function:
*/
return (AE_BAD_PARAMETER);
}
/* Skip over any white space in the buffer: */
while (isspace ((int) *String) || *String == '\t')
{
++String;
}
/*
* The buffer may contain an optional plus or minus sign.
* If it does, then skip over it but remember what is was:
*/
if (*String == '-')
{
Sign = ACPI_SIGN_NEGATIVE;
++String;
}
else if (*String == '+')
{
++String;
Sign = ACPI_SIGN_POSITIVE;
}
else
{
Sign = ACPI_SIGN_POSITIVE;
}
/*
* If the input parameter Base is zero, then we need to
* determine if it is octal, decimal, or hexadecimal:
*/
if (Base == 0)
{
if (*String == '0')
{
if (tolower ((int) *(++String)) == 'x')
{
Base = 16;
++String;
}
else
{
Base = 8;
}
}
else
{
Base = 10;
}
}
/*
* For octal and hexadecimal bases, skip over the leading
* 0 or 0x, if they are present.
*/
if (Base == 8 && *String == '0')
{
String++;
}
if (Base == 16 &&
*String == '0' &&
tolower ((int) *(++String)) == 'x')
{
String++;
}
/* Main loop: convert the string to an unsigned long */
while (*String)
{
if (isdigit ((int) *String))
{
Index = ((UINT8) *String) - '0';
}
else
{
Index = (UINT8) toupper ((int) *String);
if (isupper ((int) Index))
{
Index = Index - 'A' + 10;
}
else
{
goto ErrorExit;
}
}
if (Index >= Base)
{
goto ErrorExit;
}
/* Check to see if value is out of range: */
if (ReturnValue > ((ACPI_UINT64_MAX - (UINT64) Index) /
(UINT64) Base))
{
goto ErrorExit;
}
else
{
ReturnValue *= Base;
ReturnValue += Index;
}
++String;
}
/* If a minus sign was present, then "the conversion is negated": */
if (Sign == ACPI_SIGN_NEGATIVE)
{
ReturnValue = (ACPI_UINT32_MAX - ReturnValue) + 1;
}
*RetInteger = ReturnValue;
return (Status);
ErrorExit:
switch (Base)
{
case 8:
Status = AE_BAD_OCTAL_CONSTANT;
break;
case 10:
Status = AE_BAD_DECIMAL_CONSTANT;
break;
case 16:
Status = AE_BAD_HEX_CONSTANT;
break;
default:
/* Base validated above */
break;
}
return (Status);
}
#endif

22
sys/contrib/dev/acpica/components/utilities/utosi.c
View file

@ -442,11 +442,22 @@ AcpiUtGetInterface (
* PARAMETERS: WalkState - Current walk state
*
* RETURN: Status
* Integer: TRUE (0) if input string is matched
* FALSE (-1) if string is not matched
*
* DESCRIPTION: Implementation of the _OSI predefined control method. When
* an invocation of _OSI is encountered in the system AML,
* control is transferred to this function.
*
* (August 2016)
* Note: _OSI is now defined to return "Ones" to indicate a match, for
* compatibility with other ACPI implementations. On a 32-bit DSDT, Ones
* is 0xFFFFFFFF. On a 64-bit DSDT, Ones is 0xFFFFFFFFFFFFFFFF
* (ACPI_UINT64_MAX).
*
* This function always returns ACPI_UINT64_MAX for TRUE, and later code
* will truncate this to 32 bits if necessary.
*
******************************************************************************/
ACPI_STATUS
@ -458,7 +469,7 @@ AcpiUtOsiImplementation (
ACPI_INTERFACE_INFO *InterfaceInfo;
ACPI_INTERFACE_HANDLER InterfaceHandler;
ACPI_STATUS Status;
UINT32 ReturnValue;
UINT64 ReturnValue;
ACPI_FUNCTION_TRACE (UtOsiImplementation);
@ -507,7 +518,7 @@ AcpiUtOsiImplementation (
AcpiGbl_OsiData = InterfaceInfo->Value;
}
ReturnValue = ACPI_UINT32_MAX;
ReturnValue = ACPI_UINT64_MAX;
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
@ -520,8 +531,11 @@ AcpiUtOsiImplementation (
InterfaceHandler = AcpiGbl_InterfaceHandler;
if (InterfaceHandler)
{
ReturnValue = InterfaceHandler (
StringDesc->String.Pointer, ReturnValue);
if (InterfaceHandler (
StringDesc->String.Pointer, (UINT32) ReturnValue))
{
ReturnValue = ACPI_UINT64_MAX;
}
}
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,

2
sys/contrib/dev/acpica/components/utilities/utpredef.c
View file

@ -196,8 +196,6 @@ AcpiUtGetExpectedReturnTypes (
******************************************************************************/
#if (defined ACPI_ASL_COMPILER || defined ACPI_HELP_APP)
#include <stdio.h>
#include <string.h>
/* Local prototypes */

812
sys/contrib/dev/acpica/components/utilities/utprint.c
View file

@ -1,812 +0,0 @@
/******************************************************************************
*
* Module Name: utprint - Formatted printing routines
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2016, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utprint")
#define ACPI_FORMAT_SIGN 0x01
#define ACPI_FORMAT_SIGN_PLUS 0x02
#define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04
#define ACPI_FORMAT_ZERO 0x08
#define ACPI_FORMAT_LEFT 0x10
#define ACPI_FORMAT_UPPER 0x20
#define ACPI_FORMAT_PREFIX 0x40
/* Local prototypes */
static ACPI_SIZE
AcpiUtBoundStringLength (
const char *String,
ACPI_SIZE Count);
static char *
AcpiUtBoundStringOutput (
char *String,
const char *End,
char c);
static char *
AcpiUtFormatNumber (
char *String,
char *End,
UINT64 Number,
UINT8 Base,
INT32 Width,
INT32 Precision,
UINT8 Type);
static char *
AcpiUtPutNumber (
char *String,
UINT64 Number,
UINT8 Base,
BOOLEAN Upper);
/*******************************************************************************
*
* FUNCTION: AcpiUtBoundStringLength
*
* PARAMETERS: String - String with boundary
* Count - Boundary of the string
*
* RETURN: Length of the string. Less than or equal to Count.
*
* DESCRIPTION: Calculate the length of a string with boundary.
*
******************************************************************************/
static ACPI_SIZE
AcpiUtBoundStringLength (
const char *String,
ACPI_SIZE Count)
{
UINT32 Length = 0;
while (*String && Count)
{
Length++;
String++;
Count--;
}
return (Length);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtBoundStringOutput
*
* PARAMETERS: String - String with boundary
* End - Boundary of the string
* c - Character to be output to the string
*
* RETURN: Updated position for next valid character
*
* DESCRIPTION: Output a character into a string with boundary check.
*
******************************************************************************/
static char *
AcpiUtBoundStringOutput (
char *String,
const char *End,
char c)
{
if (String < End)
{
*String = c;
}
++String;
return (String);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtPutNumber
*
* PARAMETERS: String - Buffer to hold reverse-ordered string
* Number - Integer to be converted
* Base - Base of the integer
* Upper - Whether or not using upper cased digits
*
* RETURN: Updated position for next valid character
*
* DESCRIPTION: Convert an integer into a string, note that, the string holds a
* reversed ordered number without the trailing zero.
*
******************************************************************************/
static char *
AcpiUtPutNumber (
char *String,
UINT64 Number,
UINT8 Base,
BOOLEAN Upper)
{
const char *Digits;
UINT64 DigitIndex;
char *Pos;
Pos = String;
Digits = Upper ? AcpiGbl_UpperHexDigits : AcpiGbl_LowerHexDigits;
if (Number == 0)
{
*(Pos++) = '0';
}
else
{
while (Number)
{
(void) AcpiUtDivide (Number, Base, &Number, &DigitIndex);
*(Pos++) = Digits[DigitIndex];
}
}
/* *(Pos++) = '0'; */
return (Pos);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtScanNumber
*
* PARAMETERS: String - String buffer
* NumberPtr - Where the number is returned
*
* RETURN: Updated position for next valid character
*
* DESCRIPTION: Scan a string for a decimal integer.
*
******************************************************************************/
const char *
AcpiUtScanNumber (
const char *String,
UINT64 *NumberPtr)
{
UINT64 Number = 0;
while (isdigit ((int) *String))
{
Number *= 10;
Number += *(String++) - '0';
}
*NumberPtr = Number;
return (String);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtPrintNumber
*
* PARAMETERS: String - String buffer
* Number - The number to be converted
*
* RETURN: Updated position for next valid character
*
* DESCRIPTION: Print a decimal integer into a string.
*
******************************************************************************/
const char *
AcpiUtPrintNumber (
char *String,
UINT64 Number)
{
char AsciiString[20];
const char *Pos1;
char *Pos2;
Pos1 = AcpiUtPutNumber (AsciiString, Number, 10, FALSE);
Pos2 = String;
while (Pos1 != AsciiString)
{
*(Pos2++) = *(--Pos1);
}
*Pos2 = 0;
return (String);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtFormatNumber
*
* PARAMETERS: String - String buffer with boundary
* End - Boundary of the string
* Number - The number to be converted
* Base - Base of the integer
* Width - Field width
* Precision - Precision of the integer
* Type - Special printing flags
*
* RETURN: Updated position for next valid character
*
* DESCRIPTION: Print an integer into a string with any base and any precision.
*
******************************************************************************/
static char *
AcpiUtFormatNumber (
char *String,
char *End,
UINT64 Number,
UINT8 Base,
INT32 Width,
INT32 Precision,
UINT8 Type)
{
char *Pos;
char Sign;
char Zero;
BOOLEAN NeedPrefix;
BOOLEAN Upper;
INT32 i;
char ReversedString[66];
/* Parameter validation */
if (Base < 2 || Base > 16)
{
return (NULL);
}
if (Type & ACPI_FORMAT_LEFT)
{
Type &= ~ACPI_FORMAT_ZERO;
}
NeedPrefix = ((Type & ACPI_FORMAT_PREFIX) && Base != 10) ? TRUE : FALSE;
Upper = (Type & ACPI_FORMAT_UPPER) ? TRUE : FALSE;
Zero = (Type & ACPI_FORMAT_ZERO) ? '0' : ' ';
/* Calculate size according to sign and prefix */
Sign = '\0';
if (Type & ACPI_FORMAT_SIGN)
{
if ((INT64) Number < 0)
{
Sign = '-';
Number = - (INT64) Number;
Width--;
}
else if (Type & ACPI_FORMAT_SIGN_PLUS)
{
Sign = '+';
Width--;
}
else if (Type & ACPI_FORMAT_SIGN_PLUS_SPACE)
{
Sign = ' ';
Width--;
}
}
if (NeedPrefix)
{
Width--;
if (Base == 16)
{
Width--;
}
}
/* Generate full string in reverse order */
Pos = AcpiUtPutNumber (ReversedString, Number, Base, Upper);
i = ACPI_PTR_DIFF (Pos, ReversedString);
/* Printing 100 using %2d gives "100", not "00" */
if (i > Precision)
{
Precision = i;
}
Width -= Precision;
/* Output the string */
if (!(Type & (ACPI_FORMAT_ZERO | ACPI_FORMAT_LEFT)))
{
while (--Width >= 0)
{
String = AcpiUtBoundStringOutput (String, End, ' ');
}
}
if (Sign)
{
String = AcpiUtBoundStringOutput (String, End, Sign);
}
if (NeedPrefix)
{
String = AcpiUtBoundStringOutput (String, End, '0');
if (Base == 16)
{
String = AcpiUtBoundStringOutput (
String, End, Upper ? 'X' : 'x');
}
}
if (!(Type & ACPI_FORMAT_LEFT))
{
while (--Width >= 0)
{
String = AcpiUtBoundStringOutput (String, End, Zero);
}
}
while (i <= --Precision)
{
String = AcpiUtBoundStringOutput (String, End, '0');
}
while (--i >= 0)
{
String = AcpiUtBoundStringOutput (String, End,
ReversedString[i]);
}
while (--Width >= 0)
{
String = AcpiUtBoundStringOutput (String, End, ' ');
}
return (String);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtVsnprintf
*
* PARAMETERS: String - String with boundary
* Size - Boundary of the string
* Format - Standard printf format
* Args - Argument list
*
* RETURN: Number of bytes actually written.
*
* DESCRIPTION: Formatted output to a string using argument list pointer.
*
******************************************************************************/
int
AcpiUtVsnprintf (
char *String,
ACPI_SIZE Size,
const char *Format,
va_list Args)
{
UINT8 Base;
UINT8 Type;
INT32 Width;
INT32 Precision;
char Qualifier;
UINT64 Number;
char *Pos;
char *End;
char c;
const char *s;
const void *p;
INT32 Length;
int i;
Pos = String;
End = String + Size;
for (; *Format; ++Format)
{
if (*Format != '%')
{
Pos = AcpiUtBoundStringOutput (Pos, End, *Format);
continue;
}
Type = 0;
Base = 10;
/* Process sign */
do
{
++Format;
if (*Format == '#')
{
Type |= ACPI_FORMAT_PREFIX;
}
else if (*Format == '0')
{
Type |= ACPI_FORMAT_ZERO;
}
else if (*Format == '+')
{
Type |= ACPI_FORMAT_SIGN_PLUS;
}
else if (*Format == ' ')
{
Type |= ACPI_FORMAT_SIGN_PLUS_SPACE;
}
else if (*Format == '-')
{
Type |= ACPI_FORMAT_LEFT;
}
else
{
break;
}
} while (1);
/* Process width */
Width = -1;
if (isdigit ((int) *Format))
{
Format = AcpiUtScanNumber (Format, &Number);
Width = (INT32) Number;
}
else if (*Format == '*')
{
++Format;
Width = va_arg (Args, int);
if (Width < 0)
{
Width = -Width;
Type |= ACPI_FORMAT_LEFT;
}
}
/* Process precision */
Precision = -1;
if (*Format == '.')
{
++Format;
if (isdigit ((int) *Format))
{
Format = AcpiUtScanNumber (Format, &Number);
Precision = (INT32) Number;
}
else if (*Format == '*')
{
++Format;
Precision = va_arg (Args, int);
}
if (Precision < 0)
{
Precision = 0;
}
}
/* Process qualifier */
Qualifier = -1;
if (*Format == 'h' || *Format == 'l' || *Format == 'L')
{
Qualifier = *Format;
++Format;
if (Qualifier == 'l' && *Format == 'l')
{
Qualifier = 'L';
++Format;
}
}
switch (*Format)
{
case '%':
Pos = AcpiUtBoundStringOutput (Pos, End, '%');
continue;
case 'c':
if (!(Type & ACPI_FORMAT_LEFT))
{
while (--Width > 0)
{
Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
}
}
c = (char) va_arg (Args, int);
Pos = AcpiUtBoundStringOutput (Pos, End, c);
while (--Width > 0)
{
Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
}
continue;
case 's':
s = va_arg (Args, char *);
if (!s)
{
s = "<NULL>";
}
Length = AcpiUtBoundStringLength (s, Precision);
if (!(Type & ACPI_FORMAT_LEFT))
{
while (Length < Width--)
{
Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
}
}
for (i = 0; i < Length; ++i)
{
Pos = AcpiUtBoundStringOutput (Pos, End, *s);
++s;
}
while (Length < Width--)
{
Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
}
continue;
case 'o':
Base = 8;
break;
case 'X':
Type |= ACPI_FORMAT_UPPER;
case 'x':
Base = 16;
break;
case 'd':
case 'i':
Type |= ACPI_FORMAT_SIGN;
case 'u':
break;
case 'p':
if (Width == -1)
{
Width = 2 * sizeof (void *);
Type |= ACPI_FORMAT_ZERO;
}
p = va_arg (Args, void *);
Pos = AcpiUtFormatNumber (
Pos, End, ACPI_TO_INTEGER (p), 16, Width, Precision, Type);
continue;
default:
Pos = AcpiUtBoundStringOutput (Pos, End, '%');
if (*Format)
{
Pos = AcpiUtBoundStringOutput (Pos, End, *Format);
}
else
{
--Format;
}
continue;
}
if (Qualifier == 'L')
{
Number = va_arg (Args, UINT64);
if (Type & ACPI_FORMAT_SIGN)
{
Number = (INT64) Number;
}
}
else if (Qualifier == 'l')
{
Number = va_arg (Args, unsigned long);
if (Type & ACPI_FORMAT_SIGN)
{
Number = (INT32) Number;
}
}
else if (Qualifier == 'h')
{
Number = (UINT16) va_arg (Args, int);
if (Type & ACPI_FORMAT_SIGN)
{
Number = (INT16) Number;
}
}
else
{
Number = va_arg (Args, unsigned int);
if (Type & ACPI_FORMAT_SIGN)
{
Number = (signed int) Number;
}
}
Pos = AcpiUtFormatNumber (Pos, End, Number, Base,
Width, Precision, Type);
}
if (Size > 0)
{
if (Pos < End)
{
*Pos = '\0';
}
else
{
End[-1] = '\0';
}
}
return (ACPI_PTR_DIFF (Pos, String));
}
/*******************************************************************************
*
* FUNCTION: AcpiUtSnprintf
*
* PARAMETERS: String - String with boundary
* Size - Boundary of the string
* Format, ... - Standard printf format
*
* RETURN: Number of bytes actually written.
*
* DESCRIPTION: Formatted output to a string.
*
******************************************************************************/
int
AcpiUtSnprintf (
char *String,
ACPI_SIZE Size,
const char *Format,
...)
{
va_list Args;
int Length;
va_start (Args, Format);
Length = AcpiUtVsnprintf (String, Size, Format, Args);
va_end (Args);
return (Length);
}
#ifdef ACPI_APPLICATION
/*******************************************************************************
*
* FUNCTION: AcpiUtFileVprintf
*
* PARAMETERS: File - File descriptor
* Format - Standard printf format
* Args - Argument list
*
* RETURN: Number of bytes actually written.
*
* DESCRIPTION: Formatted output to a file using argument list pointer.
*
******************************************************************************/
int
AcpiUtFileVprintf (
ACPI_FILE File,
const char *Format,
va_list Args)
{
ACPI_CPU_FLAGS Flags;
int Length;
Flags = AcpiOsAcquireLock (AcpiGbl_PrintLock);
Length = AcpiUtVsnprintf (AcpiGbl_PrintBuffer,
sizeof (AcpiGbl_PrintBuffer), Format, Args);
(void) AcpiOsWriteFile (File, AcpiGbl_PrintBuffer, Length, 1);
AcpiOsReleaseLock (AcpiGbl_PrintLock, Flags);
return (Length);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtFilePrintf
*
* PARAMETERS: File - File descriptor
* Format, ... - Standard printf format
*
* RETURN: Number of bytes actually written.
*
* DESCRIPTION: Formatted output to a file.
*
******************************************************************************/
int
AcpiUtFilePrintf (
ACPI_FILE File,
const char *Format,
...)
{
va_list Args;
int Length;
va_start (Args, Format);
Length = AcpiUtFileVprintf (File, Format, Args);
va_end (Args);
return (Length);
}
#endif

390
sys/contrib/dev/acpica/components/utilities/utstrtoul64.c Normal file
View file

@ -0,0 +1,390 @@
/*******************************************************************************
*
* Module Name: utstrtoul64 - string to 64-bit integer support
*
******************************************************************************/
/*
* Copyright (C) 2000 - 2016, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
/*******************************************************************************
*
* The functions in this module satisfy the need for 64-bit string-to-integer
* conversions on both 32-bit and 64-bit platforms.
*
******************************************************************************/
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utstrtoul64")
/* Local prototypes */
static UINT64
AcpiUtStrtoulBase10 (
char *String,
UINT32 Flags);
static UINT64
AcpiUtStrtoulBase16 (
char *String,
UINT32 Flags);
/*******************************************************************************
*
* String conversion rules as written in the ACPI specification. The error
* conditions and behavior are different depending on the type of conversion.
*
*
* Implicit data type conversion: string-to-integer
* --------------------------------------------------
*
* Base is always 16. This is the ACPI_STRTOUL_BASE16 case.
*
* Example:
* Add ("BA98", Arg0, Local0)
*
* The integer is initialized to the value zero.
* The ASCII string is interpreted as a hexadecimal constant.
*
* 1) A "0x" prefix is not allowed. However, ACPICA allows this for
* compatibility with previous ACPICA. (NO ERROR)
*
* 2) Terminates when the size of an integer is reached (32 or 64 bits).
* (NO ERROR)
*
* 3) The first non-hex character terminates the conversion without error.
* (NO ERROR)
*
* 4) Conversion of a null (zero-length) string to an integer is not
* allowed. However, ACPICA allows this for compatibility with previous
* ACPICA. This conversion returns the value 0. (NO ERROR)
*
*
* Explicit data type conversion: ToInteger() with string operand
* ---------------------------------------------------------------
*
* Base is either 10 (default) or 16 (with 0x prefix)
*
* Examples:
* ToInteger ("1000")
* ToInteger ("0xABCD")
*
* 1) Can be (must be) either a decimal or hexadecimal numeric string.
* A hex value must be prefixed by "0x" or it is interpreted as a decimal.
*
* 2) The value must not exceed the maximum of an integer value. ACPI spec
* states the behavior is "unpredictable", so ACPICA matches the behavior
* of the implicit conversion case.(NO ERROR)
*
* 3) Behavior on the first non-hex character is not specified by the ACPI
* spec, so ACPICA matches the behavior of the implicit conversion case
* and terminates. (NO ERROR)
*
* 4) A null (zero-length) string is illegal.
* However, ACPICA allows this for compatibility with previous ACPICA.
* This conversion returns the value 0. (NO ERROR)
*
******************************************************************************/
/*******************************************************************************
*
* FUNCTION: AcpiUtStrtoul64
*
* PARAMETERS: String - Null terminated input string
* Flags - Conversion info, see below
* ReturnValue - Where the converted integer is
* returned
*
* RETURN: Status and Converted value
*
* DESCRIPTION: Convert a string into an unsigned value. Performs either a
* 32-bit or 64-bit conversion, depending on the input integer
* size in Flags (often the current mode of the interpreter).
*
* Values for Flags:
* ACPI_STRTOUL_32BIT - Max integer value is 32 bits
* ACPI_STRTOUL_64BIT - Max integer value is 64 bits
* ACPI_STRTOUL_BASE16 - Input string is hexadecimal. Default
* is 10/16 based on string prefix (0x).
*
* NOTES:
* Negative numbers are not supported, as they are not supported by ACPI.
*
* Supports only base 16 or base 10 strings/values. Does not
* support Octal strings, as these are not supported by ACPI.
*
* Current users of this support:
*
* Interpreter - Implicit and explicit conversions, GPE method names
* Debugger - Command line input string conversion
* iASL - Main parser, conversion of constants to integers
* iASL - Data Table Compiler parser (constant math expressions)
* iASL - Preprocessor (constant math expressions)
* AcpiDump - Input table addresses
* AcpiExec - Testing of the AcpiUtStrtoul64 function
*
* Note concerning callers:
* AcpiGbl_IntegerByteWidth can be used to set the 32/64 limit. If used,
* this global should be set to the proper width. For the core ACPICA code,
* this width depends on the DSDT version. For iASL, the default byte
* width is always 8 for the parser, but error checking is performed later
* to flag cases where a 64-bit constant is defined in a 32-bit DSDT/SSDT.
*
******************************************************************************/
ACPI_STATUS
AcpiUtStrtoul64 (
char *String,
UINT32 Flags,
UINT64 *ReturnValue)
{
ACPI_STATUS Status = AE_OK;
UINT32 Base;
ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String);
/* Parameter validation */
if (!String || !ReturnValue)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
*ReturnValue = 0;
/* Check for zero-length string, returns 0 */
if (*String == 0)
{
return_ACPI_STATUS (AE_OK);
}
/* Skip over any white space at start of string */
while (isspace ((int) *String))
{
String++;
}
/* End of string? return 0 */
if (*String == 0)
{
return_ACPI_STATUS (AE_OK);
}
/*
* 1) The "0x" prefix indicates base 16. Per the ACPI specification,
* the "0x" prefix is only allowed for implicit (non-strict) conversions.
* However, we always allow it for compatibility with older ACPICA.
*/
if ((*String == ACPI_ASCII_ZERO) &&
(tolower ((int) *(String + 1)) == 'x'))
{
String += 2; /* Go past the 0x */
if (*String == 0)
{
return_ACPI_STATUS (AE_OK); /* Return value 0 */
}
Base = 16;
}
/* 2) Force to base 16 (implicit conversion case) */
else if (Flags & ACPI_STRTOUL_BASE16)
{
Base = 16;
}
/* 3) Default fallback is to Base 10 */
else
{
Base = 10;
}
/* Skip all leading zeros */
while (*String == ACPI_ASCII_ZERO)
{
String++;
if (*String == 0)
{
return_ACPI_STATUS (AE_OK); /* Return value 0 */
}
}
/* Perform the base 16 or 10 conversion */
if (Base == 16)
{
*ReturnValue = AcpiUtStrtoulBase16 (String, Flags);
}
else
{
*ReturnValue = AcpiUtStrtoulBase10 (String, Flags);
}
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtStrtoulBase10
*
* PARAMETERS: String - Null terminated input string
* Flags - Conversion info
*
* RETURN: 64-bit converted integer
*
* DESCRIPTION: Performs a base 10 conversion of the input string to an
* integer value, either 32 or 64 bits.
* Note: String must be valid and non-null.
*
******************************************************************************/
static UINT64
AcpiUtStrtoulBase10 (
char *String,
UINT32 Flags)
{
int AsciiDigit;
UINT64 NextValue;
UINT64 ReturnValue = 0;
/* Main loop: convert each ASCII byte in the input string */
while (*String)
{
AsciiDigit = *String;
if (!isdigit (AsciiDigit))
{
/* Not ASCII 0-9, terminate */
goto Exit;
}
/* Convert and insert (add) the decimal digit */
NextValue =
(ReturnValue * 10) + (AsciiDigit - ACPI_ASCII_ZERO);
/* Check for overflow (32 or 64 bit) - return current converted value */
if (((Flags & ACPI_STRTOUL_32BIT) && (NextValue > ACPI_UINT32_MAX)) ||
(NextValue < ReturnValue)) /* 64-bit overflow case */
{
goto Exit;
}
ReturnValue = NextValue;
String++;
}
Exit:
return (ReturnValue);
}
/*******************************************************************************
*
* FUNCTION: AcpiUtStrtoulBase16
*
* PARAMETERS: String - Null terminated input string
* Flags - conversion info
*
* RETURN: 64-bit converted integer
*
* DESCRIPTION: Performs a base 16 conversion of the input string to an
* integer value, either 32 or 64 bits.
* Note: String must be valid and non-null.
*
******************************************************************************/
static UINT64
AcpiUtStrtoulBase16 (
char *String,
UINT32 Flags)
{
int AsciiDigit;
UINT32 ValidDigits = 1;
UINT64 ReturnValue = 0;
/* Main loop: convert each ASCII byte in the input string */
while (*String)
{
/* Check for overflow (32 or 64 bit) - return current converted value */
if ((ValidDigits > 16) ||
((ValidDigits > 8) && (Flags & ACPI_STRTOUL_32BIT)))
{
goto Exit;
}
AsciiDigit = *String;
if (!isxdigit (AsciiDigit))
{
/* Not Hex ASCII A-F, a-f, or 0-9, terminate */
goto Exit;
}
/* Convert and insert the hex digit */
ReturnValue =
(ReturnValue << 4) | AcpiUtAsciiCharToHex (AsciiDigit);
String++;
ValidDigits++;
}
Exit:
return (ReturnValue);
}

4
sys/contrib/dev/acpica/components/utilities/uttrack.c
View file

@ -107,14 +107,12 @@ AcpiUtCreateList (
ACPI_MEMORY_LIST *Cache;
Cache = AcpiOsAllocate (sizeof (ACPI_MEMORY_LIST));
Cache = AcpiOsAllocateZeroed (sizeof (ACPI_MEMORY_LIST));
if (!Cache)
{
return (AE_NO_MEMORY);
}
memset (Cache, 0, sizeof (ACPI_MEMORY_LIST));
Cache->ListName = ListName;
Cache->ObjectSize = ObjectSize;

2
sys/contrib/dev/acpica/components/utilities/utxface.c
View file

@ -63,7 +63,7 @@
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiTerminate (
void)
{

8
sys/contrib/dev/acpica/components/utilities/utxfinit.c
View file

@ -72,7 +72,7 @@ AeDoObjectOverrides (
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiInitializeSubsystem (
void)
{
@ -151,7 +151,7 @@ ACPI_EXPORT_SYMBOL_INIT (AcpiInitializeSubsystem)
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiEnableSubsystem (
UINT32 Flags)
{
@ -263,7 +263,7 @@ ACPI_EXPORT_SYMBOL_INIT (AcpiEnableSubsystem)
*
******************************************************************************/
ACPI_STATUS
ACPI_STATUS ACPI_INIT_FUNCTION
AcpiInitializeObjects (
UINT32 Flags)
{
@ -293,7 +293,7 @@ AcpiInitializeObjects (
* all of the tables have been loaded. It is a legacy option and is
* not compatible with other ACPI implementations. See AcpiNsLoadTable.
*/
if (AcpiGbl_GroupModuleLevelCode)
if (!AcpiGbl_ParseTableAsTermList && AcpiGbl_GroupModuleLevelCode)
{
AcpiNsExecModuleCodeList ();

14
sys/contrib/dev/acpica/include/acapps.h
View file

@ -44,11 +44,9 @@
#ifndef _ACAPPS
#define _ACAPPS
#include <stdio.h>
#ifdef _MSC_VER /* disable some level-4 warnings */
#pragma warning(disable:4100) /* warning C4100: unreferenced formal parameter */
#endif
#ifdef ACPI_USE_STANDARD_HEADERS
#include <sys/stat.h>
#endif /* ACPI_USE_STANDARD_HEADERS */
/* Common info for tool signons */
@ -85,13 +83,13 @@
/* Macros for usage messages */
#define ACPI_USAGE_HEADER(Usage) \
AcpiOsPrintf ("Usage: %s\nOptions:\n", Usage);
printf ("Usage: %s\nOptions:\n", Usage);
#define ACPI_USAGE_TEXT(Description) \
AcpiOsPrintf (Description);
printf (Description);
#define ACPI_OPTION(Name, Description) \
AcpiOsPrintf (" %-20s%s\n", Name, Description);
printf (" %-20s%s\n", Name, Description);
/* Check for unexpected exceptions */

118
sys/contrib/dev/acpica/include/acclib.h
View file

@ -73,6 +73,23 @@ extern const UINT8 AcpiGbl_Ctypes[];
#define isprint(c) (AcpiGbl_Ctypes[(unsigned char)(c)] & (_ACPI_LO | _ACPI_UP | _ACPI_DI | _ACPI_XS | _ACPI_PU))
#define isalpha(c) (AcpiGbl_Ctypes[(unsigned char)(c)] & (_ACPI_LO | _ACPI_UP))
/* Error code */
#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* I/O error */
#define EBADF 9 /* Bad file number */
#define EAGAIN 11 /* Try again */
#define ENOMEM 12 /* Out of memory */
#define EACCES 13 /* Permission denied */
#define EFAULT 14 /* Bad address */
#define EBUSY 16 /* Device or resource busy */
#define EEXIST 17 /* File exists */
#define ENODEV 19 /* No such device */
#define EINVAL 22 /* Invalid argument */
#define EPIPE 32 /* Broken pipe */
#define ERANGE 34 /* Math result not representable */
/* Strings */
@ -164,4 +181,105 @@ int
toupper (
int c);
/*
* utprint - printf/vprintf output functions
*/
const char *
AcpiUtScanNumber (
const char *String,
UINT64 *NumberPtr);
const char *
AcpiUtPrintNumber (
char *String,
UINT64 Number);
int
vsnprintf (
char *String,
ACPI_SIZE Size,
const char *Format,
va_list Args);
int
snprintf (
char *String,
ACPI_SIZE Size,
const char *Format,
...);
int
sprintf (
char *String,
const char *Format,
...);
#ifdef ACPI_APPLICATION
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
/*
* NOTE: Currently we only need to update errno for file IOs. Other
* Clibrary invocations in ACPICA do not make descisions according to
* the errno.
*/
extern int errno;
int
vprintf (
const char *Format,
va_list Args);
int
printf (
const char *Format,
...);
int
vfprintf (
FILE *File,
const char *Format,
va_list Args);
int
fprintf (
FILE *File,
const char *Format,
...);
FILE *
fopen (
const char *Path,
const char *Modes);
void
fclose (
FILE *File);
int
fread (
void *Buffer,
ACPI_SIZE Size,
ACPI_SIZE Count,
FILE *File);
int
fwrite (
void *Buffer,
ACPI_SIZE Size,
ACPI_SIZE Count,
FILE *File);
int
fseek (
FILE *File,
long Offset,
int From);
long
ftell (
FILE *File);
#endif
#endif /* _ACCLIB_H */

4
sys/contrib/dev/acpica/include/acconfig.h
View file

@ -146,6 +146,10 @@
#define ACPI_ADDRESS_RANGE_MAX 2
/* Maximum number of While() loops before abort */
#define ACPI_MAX_LOOP_COUNT 0x000FFFFF
/******************************************************************************
*

4
sys/contrib/dev/acpica/include/acdebug.h
View file

@ -233,8 +233,8 @@ AcpiDbDisassembleAml (
ACPI_PARSE_OBJECT *Op);
void
AcpiDbBatchExecute (
char *CountArg);
AcpiDbEvaluatePredefinedNames (
void);
/*

7
sys/contrib/dev/acpica/include/acdisasm.h
View file

@ -109,6 +109,7 @@ typedef enum
ACPI_DMT_UINT64,
ACPI_DMT_BUF7,
ACPI_DMT_BUF10,
ACPI_DMT_BUF12,
ACPI_DMT_BUF16,
ACPI_DMT_BUF128,
ACPI_DMT_SIG,
@ -279,8 +280,8 @@ extern ACPI_DMTABLE_INFO AcpiDmTableInfoErst[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoErst0[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFacs[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt1[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt2[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt3[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt4[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt5[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFadt6[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoFpdt[];
@ -386,6 +387,7 @@ extern ACPI_DMTABLE_INFO AcpiDmTableInfoPcctHdr[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoPcct0[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoPcct1[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoPcct2[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoRasf[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoRsdp1[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoRsdp2[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoS3pt[];
@ -423,6 +425,9 @@ extern ACPI_DMTABLE_INFO AcpiDmTableInfoXenv[];
extern ACPI_DMTABLE_INFO AcpiDmTableInfoGeneric[][2];
extern ACPI_DMTABLE_INFO *FadtRevisionInfo [ACPI_FADT_MAX_VERSION + 1];
/*
* dmtable and ahtable
*/

5
sys/contrib/dev/acpica/include/acevents.h
View file

@ -115,6 +115,11 @@ ACPI_STATUS
AcpiEvEnableGpe (
ACPI_GPE_EVENT_INFO *GpeEventInfo);
ACPI_STATUS
AcpiEvMaskGpe (
ACPI_GPE_EVENT_INFO *GpeEventInfo,
BOOLEAN IsMasked);
ACPI_STATUS
AcpiEvAddGpeReference (
ACPI_GPE_EVENT_INFO *GpeEventInfo);

6
sys/contrib/dev/acpica/include/acglobal.h
View file

@ -245,10 +245,6 @@ ACPI_INIT_GLOBAL (UINT32, AcpiGbl_NestingLevel, 0);
ACPI_GLOBAL (ACPI_THREAD_STATE *, AcpiGbl_CurrentWalkList);
/* Maximum number of While() loop iterations before forced abort */
ACPI_GLOBAL (UINT16, AcpiGbl_MaxLoopIterations);
/* Control method single step flag */
ACPI_GLOBAL (UINT8, AcpiGbl_CmSingleStep);
@ -322,6 +318,7 @@ ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_CstyleDisassembly, TRUE);
ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_ForceAmlDisassembly, FALSE);
ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_DmOpt_Verbose, TRUE);
ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_DmEmitExternalOpcodes, FALSE);
ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_DoDisassemblerOptimizations, TRUE);
ACPI_GLOBAL (BOOLEAN, AcpiGbl_DmOpt_Disasm);
ACPI_GLOBAL (BOOLEAN, AcpiGbl_DmOpt_Listing);
@ -392,6 +389,7 @@ ACPI_GLOBAL (const char, *AcpiGbl_PldShapeList[]);
ACPI_INIT_GLOBAL (ACPI_FILE, AcpiGbl_DebugFile, NULL);
ACPI_INIT_GLOBAL (ACPI_FILE, AcpiGbl_OutputFile, NULL);
ACPI_INIT_GLOBAL (BOOLEAN, AcpiGbl_DebugTimeout, FALSE);
/* Print buffer */

Some files were not shown because too many files have changed in this diff Show more