MFV: r329072

Merge ACPICA 20180209.
This commit is contained in:
Jung-uk Kim 2018-02-09 21:49:38 +00:00
commit ff879b0799
Notes: svn2git 2020-12-20 02:59:44 +00:00
svn path=/head/; revision=329085
48 changed files with 11186 additions and 9991 deletions

View File

@ -1,3 +1,71 @@
----------------------------------------
09 February 2018. Summary of changes for version 20180209:
1) ACPICA kernel-resident subsystem:
Completed the final integration of the recent changes to Package Object
handling and the module-level AML code support. This allows forward
references from individual package elements when the package object is
declared from within module-level code blocks. Provides compatibility
with other ACPI implementations.
The new architecture for the AML module-level code has been completed and
is now the default for the ACPICA code. This new architecture executes
the module-level code in-line as the ACPI table is loaded/parsed instead
of the previous architecture which deferred this code until after the
table was fully loaded. This solves some ASL code ordering issues and
provides compatibility with other ACPI implementations. At this time,
there is an option to fallback to the earlier architecture, but this
support is deprecated and is planned to be completely removed later this
year.
Added a compile-time option to ignore AE_NOT_FOUND exceptions during
resolution of named reference elements within Package objects. Although
this is potentially a serious problem, it can generate a lot of
noise/errors on platforms whose firmware carries around a bunch of unused
Package objects. To disable these errors, define
ACPI_IGNORE_PACKAGE_RESOLUTION_ERRORS in the OS-specific header. All
errors are always reported for ACPICA applications such as AcpiExec.
Fixed a regression related to the explicit type-conversion AML operators
(ToXXXX). The regression was introduced early in 2017 but was not seen
until recently because these operators are not fully supported by other
ACPI implementations and are thus rarely used by firmware developers. The
operators are defined by the ACPI specification to not implement the
"implicit result object conversion". The regression incorrectly
introduced this object conversion for the following explicit conversion
operators:
ToInteger
ToString
ToBuffer
ToDecimalString
ToHexString
ToBCD
FromBCD
2) iASL Compiler/Disassembler and Tools:
iASL: Fixed a problem with the compiler constant folding feature as
related to the ToXXXX explicit conversion operators. These operators do
not support the "implicit result object conversion" by definition. Thus,
ASL expressions that use these operators cannot be folded to a simple
Store operator because Store implements the implicit conversion. This
change uses the CopyObject operator for the ToXXXX operator folding
instead. CopyObject is defined to not implement implicit result
conversions and is thus appropriate for folding the ToXXXX operators.
iASL: Changed the severity of an error condition to a simple warning for
the case where a symbol is declared both locally and as an external
symbol. This accommodates existing ASL code.
AcpiExec: The -ep option to enable the new architecture for module-level
code has been removed. It is replaced by the -dp option which instead has
the opposite effect: it disables the new architecture (the default) and
enables the legacy architecture. When the legacy code is removed in the
future, the -dp option will be removed also.
----------------------------------------
05 January 2018. Summary of changes for version 20180105:

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,693 @@
/******************************************************************************
*
* Module Name: dmtbdump3 - Dump ACPI data tables that contain no AML code
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
* All rights reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
* rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
* to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
* and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
* Code and the date of any change. Licensee must include in that file the
* documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
* documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
* any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************
*
* Alternatively, you may choose to be licensed under the terms of the
* following license:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, you may choose to be licensed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
*****************************************************************************/
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acdisasm.h>
#include <contrib/dev/acpica/include/actables.h>
/* This module used for application-level code only */
#define _COMPONENT ACPI_CA_DISASSEMBLER
ACPI_MODULE_NAME ("dmtbdump3")
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpSlic
*
* PARAMETERS: Table - A SLIC table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a SLIC
*
******************************************************************************/
void
AcpiDmDumpSlic (
ACPI_TABLE_HEADER *Table)
{
(void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpSlit
*
* PARAMETERS: Table - An SLIT
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a SLIT
*
******************************************************************************/
void
AcpiDmDumpSlit (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status;
UINT32 Offset;
UINT8 *Row;
UINT32 Localities;
UINT32 i;
UINT32 j;
/* Main table */
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
if (ACPI_FAILURE (Status))
{
return;
}
/* Display the Locality NxN Matrix */
Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
for (i = 0; i < Localities; i++)
{
/* Display one row of the matrix */
AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
for (j = 0; j < Localities; j++)
{
/* Check for beyond EOT */
if (Offset >= Table->Length)
{
AcpiOsPrintf (
"\n**** Not enough room in table for all localities\n");
return;
}
AcpiOsPrintf ("%2.2X", Row[j]);
Offset++;
/* Display up to 16 bytes per output row */
if ((j+1) < Localities)
{
AcpiOsPrintf (" ");
if (j && (((j+1) % 16) == 0))
{
AcpiOsPrintf ("\\\n"); /* With line continuation char */
AcpiDmLineHeader (Offset, 0, NULL);
}
}
}
/* Point to next row */
AcpiOsPrintf ("\n");
Row += Localities;
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpSrat
*
* PARAMETERS: Table - A SRAT table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a SRAT
*
******************************************************************************/
void
AcpiDmDumpSrat (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status;
UINT32 Offset = sizeof (ACPI_TABLE_SRAT);
ACPI_SUBTABLE_HEADER *Subtable;
ACPI_DMTABLE_INFO *InfoTable;
/* Main table */
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
if (ACPI_FAILURE (Status))
{
return;
}
/* Subtables */
Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
while (Offset < Table->Length)
{
/* Common subtable header */
AcpiOsPrintf ("\n");
Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
Subtable->Length, AcpiDmTableInfoSratHdr);
if (ACPI_FAILURE (Status))
{
return;
}
switch (Subtable->Type)
{
case ACPI_SRAT_TYPE_CPU_AFFINITY:
InfoTable = AcpiDmTableInfoSrat0;
break;
case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
InfoTable = AcpiDmTableInfoSrat1;
break;
case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
InfoTable = AcpiDmTableInfoSrat2;
break;
case ACPI_SRAT_TYPE_GICC_AFFINITY:
InfoTable = AcpiDmTableInfoSrat3;
break;
case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY:
InfoTable = AcpiDmTableInfoSrat4;
break;
default:
AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n",
Subtable->Type);
/* Attempt to continue */
if (!Subtable->Length)
{
AcpiOsPrintf ("Invalid zero length subtable\n");
return;
}
goto NextSubtable;
}
AcpiOsPrintf ("\n");
Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
Subtable->Length, InfoTable);
if (ACPI_FAILURE (Status))
{
return;
}
NextSubtable:
/* Point to next subtable */
Offset += Subtable->Length;
Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable,
Subtable->Length);
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpStao
*
* PARAMETERS: Table - A STAO table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a STAO. This is a variable-length
* table that contains an open-ended number of ASCII strings
* at the end of the table.
*
******************************************************************************/
void
AcpiDmDumpStao (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status;
char *Namepath;
UINT32 Length = Table->Length;
UINT32 StringLength;
UINT32 Offset = sizeof (ACPI_TABLE_STAO);
/* Main table */
Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao);
if (ACPI_FAILURE (Status))
{
return;
}
/* The rest of the table consists of Namepath strings */
while (Offset < Table->Length)
{
Namepath = ACPI_ADD_PTR (char, Table, Offset);
StringLength = strlen (Namepath) + 1;
AcpiDmLineHeader (Offset, StringLength, "Namestring");
AcpiOsPrintf ("\"%s\"\n", Namepath);
/* Point to next namepath */
Offset += StringLength;
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpTcpa
*
* PARAMETERS: Table - A TCPA table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a TCPA.
*
* NOTE: There are two versions of the table with the same signature:
* the client version and the server version. The common
* PlatformClass field is used to differentiate the two types of
* tables.
*
******************************************************************************/
void
AcpiDmDumpTcpa (
ACPI_TABLE_HEADER *Table)
{
UINT32 Offset = sizeof (ACPI_TABLE_TCPA_HDR);
ACPI_TABLE_TCPA_HDR *CommonHeader = ACPI_CAST_PTR (
ACPI_TABLE_TCPA_HDR, Table);
ACPI_TABLE_TCPA_HDR *Subtable = ACPI_ADD_PTR (
ACPI_TABLE_TCPA_HDR, Table, Offset);
ACPI_STATUS Status;
/* Main table */
Status = AcpiDmDumpTable (Table->Length, 0, Table,
0, AcpiDmTableInfoTcpaHdr);
if (ACPI_FAILURE (Status))
{
return;
}
/*
* Examine the PlatformClass field to determine the table type.
* Either a client or server table. Only one.
*/
switch (CommonHeader->PlatformClass)
{
case ACPI_TCPA_CLIENT_TABLE:
Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
Table->Length - Offset, AcpiDmTableInfoTcpaClient);
break;
case ACPI_TCPA_SERVER_TABLE:
Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
Table->Length - Offset, AcpiDmTableInfoTcpaServer);
break;
default:
AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
CommonHeader->PlatformClass);
Status = AE_ERROR;
break;
}
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n");
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpTpm2
*
* PARAMETERS: Table - A TPM2 table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a TPM2.
*
******************************************************************************/
void
AcpiDmDumpTpm2 (
ACPI_TABLE_HEADER *Table)
{
UINT32 Offset = sizeof (ACPI_TABLE_TPM2);
ACPI_TABLE_TPM2 *CommonHeader = ACPI_CAST_PTR (ACPI_TABLE_TPM2, Table);
ACPI_TPM2_TRAILER *Subtable = ACPI_ADD_PTR (ACPI_TPM2_TRAILER, Table, Offset);
ACPI_TPM2_ARM_SMC *ArmSubtable;
ACPI_STATUS Status;
/* Main table */
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoTpm2);
if (ACPI_FAILURE (Status))
{
return;
}
AcpiOsPrintf ("\n");
Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
Table->Length - Offset, AcpiDmTableInfoTpm2a);
if (ACPI_FAILURE (Status))
{
return;
}
switch (CommonHeader->StartMethod)
{
case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC:
ArmSubtable = ACPI_ADD_PTR (ACPI_TPM2_ARM_SMC, Subtable,
sizeof (ACPI_TPM2_TRAILER));
Offset += sizeof (ACPI_TPM2_TRAILER);
AcpiOsPrintf ("\n");
Status = AcpiDmDumpTable (Table->Length, Offset, ArmSubtable,
Table->Length - Offset, AcpiDmTableInfoTpm211);
break;
default:
break;
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpVrtc
*
* PARAMETERS: Table - A VRTC table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a VRTC
*
******************************************************************************/
void
AcpiDmDumpVrtc (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status;
UINT32 Offset = sizeof (ACPI_TABLE_VRTC);
ACPI_VRTC_ENTRY *Subtable;
/* Main table */
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc);
if (ACPI_FAILURE (Status))
{
return;
}
/* Subtables */
Subtable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset);
while (Offset < Table->Length)
{
/* Common subtable header */
AcpiOsPrintf ("\n");
Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
if (ACPI_FAILURE (Status))
{
return;
}
/* Point to next subtable */
Offset += sizeof (ACPI_VRTC_ENTRY);
Subtable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Subtable,
sizeof (ACPI_VRTC_ENTRY));
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpWdat
*
* PARAMETERS: Table - A WDAT table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a WDAT
*
******************************************************************************/
void
AcpiDmDumpWdat (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status;
UINT32 Offset = sizeof (ACPI_TABLE_WDAT);
ACPI_WDAT_ENTRY *Subtable;
/* Main table */
Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
if (ACPI_FAILURE (Status))
{
return;
}
/* Subtables */
Subtable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
while (Offset < Table->Length)
{
/* Common subtable header */
AcpiOsPrintf ("\n");
Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
if (ACPI_FAILURE (Status))
{
return;
}
/* Point to next subtable */
Offset += sizeof (ACPI_WDAT_ENTRY);
Subtable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Subtable,
sizeof (ACPI_WDAT_ENTRY));
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmDumpWpbt
*
* PARAMETERS: Table - A WPBT table
*
* RETURN: None
*
* DESCRIPTION: Format the contents of a WPBT. This table type consists
* of an open-ended arguments buffer at the end of the table.
*
******************************************************************************/
void
AcpiDmDumpWpbt (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status;
ACPI_TABLE_WPBT *Subtable;
UINT32 Length = Table->Length;
UINT16 ArgumentsLength;
/* Dump the main table */
Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt);
if (ACPI_FAILURE (Status))
{
return;
}
/* Extract the arguments buffer length from the main table */
Subtable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table);
ArgumentsLength = Subtable->ArgumentsLength;
/* Dump the arguments buffer */
(void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
AcpiDmTableInfoWpbt0);
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,733 @@
/******************************************************************************
*
* Module Name: dmtbinfo3 - Table info for non-AML tables
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
* All rights reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
* rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
* to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
* and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
* Code and the date of any change. Licensee must include in that file the
* documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
* documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
* any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************
*
* Alternatively, you may choose to be licensed under the terms of the
* following license:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, you may choose to be licensed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
*****************************************************************************/
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acdisasm.h>
#include <contrib/dev/acpica/include/actbinfo.h>
/* This module used for application-level code only */
#define _COMPONENT ACPI_CA_DISASSEMBLER
ACPI_MODULE_NAME ("dmtbinfo3")
/*
* How to add a new table:
*
* - Add the C table definition to the actbl1.h or actbl2.h header.
* - Add ACPI_xxxx_OFFSET macro(s) for the table (and subtables) to list below.
* - Define the table in this file (for the disassembler). If any
* new data types are required (ACPI_DMT_*), see below.
* - Add an external declaration for the new table definition (AcpiDmTableInfo*)
* in acdisam.h
* - Add new table definition to the dispatch table in dmtable.c (AcpiDmTableData)
* If a simple table (with no subtables), no disassembly code is needed.
* Otherwise, create the AcpiDmDump* function for to disassemble the table
* and add it to the dmtbdump.c file.
* - Add an external declaration for the new AcpiDmDump* function in acdisasm.h
* - Add the new AcpiDmDump* function to the dispatch table in dmtable.c
* - Create a template for the new table
* - Add data table compiler support
*
* How to add a new data type (ACPI_DMT_*):
*
* - Add new type at the end of the ACPI_DMT list in acdisasm.h
* - Add length and implementation cases in dmtable.c (disassembler)
* - Add type and length cases in dtutils.c (DT compiler)
*/
/*
* ACPI Table Information, used to dump formatted ACPI tables
*
* Each entry is of the form: <Field Type, Field Offset, Field Name>
*/
/*******************************************************************************
*
* SLIC - Software Licensing Description Table. This table contains the standard
* ACPI header followed by proprietary data structures
*
******************************************************************************/
/* Single subtable, a proprietary format, so treat it as a buffer */
ACPI_DMTABLE_INFO AcpiDmTableInfoSlic[] =
{
{ACPI_DMT_RAW_BUFFER, 0, "Software Licensing Structure", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* SLIT - System Locality Information Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoSlit[] =
{
{ACPI_DMT_UINT64, ACPI_SLIT_OFFSET (LocalityCount), "Localities", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* SPCR - Serial Port Console Redirection table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoSpcr[] =
{
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (InterfaceType), "Interface Type", 0},
{ACPI_DMT_UINT24, ACPI_SPCR_OFFSET (Reserved[0]), "Reserved", 0},
{ACPI_DMT_GAS, ACPI_SPCR_OFFSET (SerialPort), "Serial Port Register", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (InterruptType), "Interrupt Type", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (PcInterrupt), "PCAT-compatible IRQ", 0},
{ACPI_DMT_UINT32, ACPI_SPCR_OFFSET (Interrupt), "Interrupt", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (BaudRate), "Baud Rate", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (Parity), "Parity", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (StopBits), "Stop Bits", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (FlowControl), "Flow Control", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (TerminalType), "Terminal Type", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (Reserved2), "Reserved", 0},
{ACPI_DMT_UINT16, ACPI_SPCR_OFFSET (PciDeviceId), "PCI Device ID", 0},
{ACPI_DMT_UINT16, ACPI_SPCR_OFFSET (PciVendorId), "PCI Vendor ID", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (PciBus), "PCI Bus", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (PciDevice), "PCI Device", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (PciFunction), "PCI Function", 0},
{ACPI_DMT_UINT32, ACPI_SPCR_OFFSET (PciFlags), "PCI Flags", 0},
{ACPI_DMT_UINT8, ACPI_SPCR_OFFSET (PciSegment), "PCI Segment", 0},
{ACPI_DMT_UINT32, ACPI_SPCR_OFFSET (Reserved2), "Reserved", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* SPMI - Server Platform Management Interface table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoSpmi[] =
{
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (InterfaceType), "Interface Type", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (Reserved), "Reserved", DT_NON_ZERO}, /* Value must be 1 */
{ACPI_DMT_UINT16, ACPI_SPMI_OFFSET (SpecRevision), "IPMI Spec Version", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (InterruptType), "Interrupt Type", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (GpeNumber), "GPE Number", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (Reserved1), "Reserved", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (PciDeviceFlag), "PCI Device Flag", 0},
{ACPI_DMT_UINT32, ACPI_SPMI_OFFSET (Interrupt), "Interrupt", 0},
{ACPI_DMT_GAS, ACPI_SPMI_OFFSET (IpmiRegister), "IPMI Register", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (PciSegment), "PCI Segment", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (PciBus), "PCI Bus", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (PciDevice), "PCI Device", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (PciFunction), "PCI Function", 0},
{ACPI_DMT_UINT8, ACPI_SPMI_OFFSET (Reserved2), "Reserved", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* SRAT - System Resource Affinity Table and Subtables
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoSrat[] =
{
{ACPI_DMT_UINT32, ACPI_SRAT_OFFSET (TableRevision), "Table Revision", 0},
{ACPI_DMT_UINT64, ACPI_SRAT_OFFSET (Reserved), "Reserved", 0},
ACPI_DMT_TERMINATOR
};
/* Common Subtable header (one per Subtable) */
ACPI_DMTABLE_INFO AcpiDmTableInfoSratHdr[] =
{
{ACPI_DMT_SRAT, ACPI_SRATH_OFFSET (Type), "Subtable Type", 0},
{ACPI_DMT_UINT8, ACPI_SRATH_OFFSET (Length), "Length", DT_LENGTH},
ACPI_DMT_TERMINATOR
};
/* SRAT Subtables */
/* 0: Processor Local APIC/SAPIC Affinity */
ACPI_DMTABLE_INFO AcpiDmTableInfoSrat0[] =
{
{ACPI_DMT_UINT8, ACPI_SRAT0_OFFSET (ProximityDomainLo), "Proximity Domain Low(8)", 0},
{ACPI_DMT_UINT8, ACPI_SRAT0_OFFSET (ApicId), "Apic ID", 0},
{ACPI_DMT_UINT32, ACPI_SRAT0_OFFSET (Flags), "Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_SRAT0_FLAG_OFFSET (Flags,0), "Enabled", 0},
{ACPI_DMT_UINT8, ACPI_SRAT0_OFFSET (LocalSapicEid), "Local Sapic EID", 0},
{ACPI_DMT_UINT24, ACPI_SRAT0_OFFSET (ProximityDomainHi[0]), "Proximity Domain High(24)", 0},
{ACPI_DMT_UINT32, ACPI_SRAT0_OFFSET (ClockDomain), "Clock Domain", 0},
ACPI_DMT_TERMINATOR
};
/* 1: Memory Affinity */
ACPI_DMTABLE_INFO AcpiDmTableInfoSrat1[] =
{
{ACPI_DMT_UINT32, ACPI_SRAT1_OFFSET (ProximityDomain), "Proximity Domain", 0},
{ACPI_DMT_UINT16, ACPI_SRAT1_OFFSET (Reserved), "Reserved1", 0},
{ACPI_DMT_UINT64, ACPI_SRAT1_OFFSET (BaseAddress), "Base Address", 0},
{ACPI_DMT_UINT64, ACPI_SRAT1_OFFSET (Length), "Address Length", 0},
{ACPI_DMT_UINT32, ACPI_SRAT1_OFFSET (Reserved1), "Reserved2", 0},
{ACPI_DMT_UINT32, ACPI_SRAT1_OFFSET (Flags), "Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_SRAT1_FLAG_OFFSET (Flags,0), "Enabled", 0},
{ACPI_DMT_FLAG1, ACPI_SRAT1_FLAG_OFFSET (Flags,0), "Hot Pluggable", 0},
{ACPI_DMT_FLAG2, ACPI_SRAT1_FLAG_OFFSET (Flags,0), "Non-Volatile", 0},
{ACPI_DMT_UINT64, ACPI_SRAT1_OFFSET (Reserved2), "Reserved3", 0},
ACPI_DMT_TERMINATOR
};
/* 2: Processor Local X2_APIC Affinity (ACPI 4.0) */
ACPI_DMTABLE_INFO AcpiDmTableInfoSrat2[] =
{
{ACPI_DMT_UINT16, ACPI_SRAT2_OFFSET (Reserved), "Reserved1", 0},
{ACPI_DMT_UINT32, ACPI_SRAT2_OFFSET (ProximityDomain), "Proximity Domain", 0},
{ACPI_DMT_UINT32, ACPI_SRAT2_OFFSET (ApicId), "Apic ID", 0},
{ACPI_DMT_UINT32, ACPI_SRAT2_OFFSET (Flags), "Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_SRAT2_FLAG_OFFSET (Flags,0), "Enabled", 0},
{ACPI_DMT_UINT32, ACPI_SRAT2_OFFSET (ClockDomain), "Clock Domain", 0},
{ACPI_DMT_UINT32, ACPI_SRAT2_OFFSET (Reserved2), "Reserved2", 0},
ACPI_DMT_TERMINATOR
};
/* 3: GICC Affinity (ACPI 5.1) */
ACPI_DMTABLE_INFO AcpiDmTableInfoSrat3[] =
{
{ACPI_DMT_UINT32, ACPI_SRAT3_OFFSET (ProximityDomain), "Proximity Domain", 0},
{ACPI_DMT_UINT32, ACPI_SRAT3_OFFSET (AcpiProcessorUid), "Acpi Processor UID", 0},
{ACPI_DMT_UINT32, ACPI_SRAT3_OFFSET (Flags), "Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_SRAT3_FLAG_OFFSET (Flags,0), "Enabled", 0},
{ACPI_DMT_UINT32, ACPI_SRAT3_OFFSET (ClockDomain), "Clock Domain", 0},
ACPI_DMT_TERMINATOR
};
/* 4: GCC ITS Affinity (ACPI 6.2) */
ACPI_DMTABLE_INFO AcpiDmTableInfoSrat4[] =
{
{ACPI_DMT_UINT32, ACPI_SRAT4_OFFSET (ProximityDomain), "Proximity Domain", 0},
{ACPI_DMT_UINT16, ACPI_SRAT4_OFFSET (Reserved), "Reserved", 0},
{ACPI_DMT_UINT32, ACPI_SRAT4_OFFSET (ItsId), "ITS ID", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* STAO - Status Override Table (_STA override) - ACPI 6.0
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoStao[] =
{
{ACPI_DMT_UINT8, ACPI_STAO_OFFSET (IgnoreUart), "Ignore UART", 0},
ACPI_DMT_TERMINATOR
};
ACPI_DMTABLE_INFO AcpiDmTableInfoStaoStr[] =
{
{ACPI_DMT_STRING, 0, "Namepath", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* TCPA - Trusted Computing Platform Alliance table (Client)
*
* NOTE: There are two versions of the table with the same signature --
* the client version and the server version. The common PlatformClass
* field is used to differentiate the two types of tables.
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoTcpaHdr[] =
{
{ACPI_DMT_UINT16, ACPI_TCPA_OFFSET (PlatformClass), "Platform Class", 0},
ACPI_DMT_TERMINATOR
};
ACPI_DMTABLE_INFO AcpiDmTableInfoTcpaClient[] =
{
{ACPI_DMT_UINT32, ACPI_TCPA_CLIENT_OFFSET (MinimumLogLength), "Min Event Log Length", 0},
{ACPI_DMT_UINT64, ACPI_TCPA_CLIENT_OFFSET (LogAddress), "Event Log Address", 0},
ACPI_DMT_TERMINATOR
};
ACPI_DMTABLE_INFO AcpiDmTableInfoTcpaServer[] =
{
{ACPI_DMT_UINT16, ACPI_TCPA_SERVER_OFFSET (Reserved), "Reserved", 0},
{ACPI_DMT_UINT64, ACPI_TCPA_SERVER_OFFSET (MinimumLogLength), "Min Event Log Length", 0},
{ACPI_DMT_UINT64, ACPI_TCPA_SERVER_OFFSET (LogAddress), "Event Log Address", 0},
{ACPI_DMT_UINT16, ACPI_TCPA_SERVER_OFFSET (SpecRevision), "Specification Revision", 0},
{ACPI_DMT_UINT8, ACPI_TCPA_SERVER_OFFSET (DeviceFlags), "Device Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_TCPA_SERVER_OFFSET (DeviceFlags), "Pci Device", 0},
{ACPI_DMT_FLAG1, ACPI_TCPA_SERVER_OFFSET (DeviceFlags), "Bus is Pnp", 0},
{ACPI_DMT_FLAG2, ACPI_TCPA_SERVER_OFFSET (DeviceFlags), "Address Valid", 0},
{ACPI_DMT_UINT8, ACPI_TCPA_SERVER_OFFSET (InterruptFlags), "Interrupt Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_TCPA_SERVER_OFFSET (InterruptFlags), "Mode", 0},
{ACPI_DMT_FLAG1, ACPI_TCPA_SERVER_OFFSET (InterruptFlags), "Polarity", 0},
{ACPI_DMT_FLAG2, ACPI_TCPA_SERVER_OFFSET (InterruptFlags), "GPE SCI Triggered", 0},
{ACPI_DMT_FLAG3, ACPI_TCPA_SERVER_OFFSET (InterruptFlags), "Global System Interrupt", 0},
{ACPI_DMT_UINT8, ACPI_TCPA_SERVER_OFFSET (GpeNumber), "Gpe Number", 0},
{ACPI_DMT_UINT24, ACPI_TCPA_SERVER_OFFSET (Reserved2[0]), "Reserved", 0},
{ACPI_DMT_UINT32, ACPI_TCPA_SERVER_OFFSET (GlobalInterrupt), "Global Interrupt", 0},
{ACPI_DMT_GAS, ACPI_TCPA_SERVER_OFFSET (Address), "Address", 0},
{ACPI_DMT_UINT32, ACPI_TCPA_SERVER_OFFSET (Reserved3), "Reserved", 0},
{ACPI_DMT_GAS, ACPI_TCPA_SERVER_OFFSET (ConfigAddress), "Configuration Address", 0},
{ACPI_DMT_UINT8, ACPI_TCPA_SERVER_OFFSET (Group), "Pci Group", 0},
{ACPI_DMT_UINT8, ACPI_TCPA_SERVER_OFFSET (Bus), "Pci Bus", 0},
{ACPI_DMT_UINT8, ACPI_TCPA_SERVER_OFFSET (Device), "Pci Device", 0},
{ACPI_DMT_UINT8, ACPI_TCPA_SERVER_OFFSET (Function), "Pci Function", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* TPM2 - Trusted Platform Module (TPM) 2.0 Hardware Interface Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoTpm2[] =
{
{ACPI_DMT_UINT16, ACPI_TPM2_OFFSET (PlatformClass), "Platform Class", 0},
{ACPI_DMT_UINT16, ACPI_TPM2_OFFSET (Reserved), "Reserved", 0},
{ACPI_DMT_UINT64, ACPI_TPM2_OFFSET (ControlAddress), "Control Address", 0},
{ACPI_DMT_TPM2, ACPI_TPM2_OFFSET (StartMethod), "Start Method", 0},
ACPI_DMT_TERMINATOR
};
/* Optional trailer. LogLength and LogAddress are additionally optional */
ACPI_DMTABLE_INFO AcpiDmTableInfoTpm2a[] =
{
{ACPI_DMT_BUF12, ACPI_TPM2A_OFFSET (MethodParameters), "Method Parameters", DT_OPTIONAL},
{ACPI_DMT_UINT32, ACPI_TPM2A_OFFSET (MinimumLogLength), "Minimum Log Length", DT_OPTIONAL},
{ACPI_DMT_UINT64, ACPI_TPM2A_OFFSET (LogAddress), "Log Address", DT_OPTIONAL},
ACPI_DMT_TERMINATOR
};
/* 11: Start Method for ARM SMC */
ACPI_DMTABLE_INFO AcpiDmTableInfoTpm211[] =
{
{ACPI_DMT_UINT32, ACPI_TPM211_OFFSET (GlobalInterrupt), "Global Interrupt", 0},
{ACPI_DMT_UINT8, ACPI_TPM211_OFFSET (InterruptFlags), "Interrupt Flags", 0},
{ACPI_DMT_UINT8, ACPI_TPM211_OFFSET (OperationFlags), "Operation Flags", 0},
{ACPI_DMT_UINT16, ACPI_TPM211_OFFSET (Reserved), "Reserved", 0},
{ACPI_DMT_UINT32, ACPI_TPM211_OFFSET (FunctionId), "Function ID", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* UEFI - UEFI Boot optimization Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoUefi[] =
{
{ACPI_DMT_UUID, ACPI_UEFI_OFFSET (Identifier[0]), "UUID Identifier", 0},
{ACPI_DMT_UINT16, ACPI_UEFI_OFFSET (DataOffset), "Data Offset", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* VRTC - Virtual Real Time Clock Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoVrtc[] =
{
ACPI_DMT_TERMINATOR
};
/* VRTC Subtables - VRTC Entry */
ACPI_DMTABLE_INFO AcpiDmTableInfoVrtc0[] =
{
{ACPI_DMT_GAS, ACPI_VRTC0_OFFSET (PhysicalAddress), "PhysicalAddress", 0},
{ACPI_DMT_UINT32, ACPI_VRTC0_OFFSET (Irq), "IRQ", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* WAET - Windows ACPI Emulated devices Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoWaet[] =
{
{ACPI_DMT_UINT32, ACPI_WAET_OFFSET (Flags), "Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_WAET_OFFSET (Flags), "RTC needs no INT ack", 0},
{ACPI_DMT_FLAG1, ACPI_WAET_OFFSET (Flags), "PM timer, one read only", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* WDAT - Watchdog Action Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoWdat[] =
{
{ACPI_DMT_UINT32, ACPI_WDAT_OFFSET (HeaderLength), "Header Length", DT_LENGTH},
{ACPI_DMT_UINT16, ACPI_WDAT_OFFSET (PciSegment), "PCI Segment", 0},
{ACPI_DMT_UINT8, ACPI_WDAT_OFFSET (PciBus), "PCI Bus", 0},
{ACPI_DMT_UINT8, ACPI_WDAT_OFFSET (PciDevice), "PCI Device", 0},
{ACPI_DMT_UINT8, ACPI_WDAT_OFFSET (PciFunction), "PCI Function", 0},
{ACPI_DMT_UINT24, ACPI_WDAT_OFFSET (Reserved[0]), "Reserved", 0},
{ACPI_DMT_UINT32, ACPI_WDAT_OFFSET (TimerPeriod), "Timer Period", 0},
{ACPI_DMT_UINT32, ACPI_WDAT_OFFSET (MaxCount), "Max Count", 0},
{ACPI_DMT_UINT32, ACPI_WDAT_OFFSET (MinCount), "Min Count", 0},
{ACPI_DMT_UINT8, ACPI_WDAT_OFFSET (Flags), "Flags (decoded below)", DT_FLAG},
{ACPI_DMT_FLAG0, ACPI_WDAT_OFFSET (Flags), "Enabled", 0},
{ACPI_DMT_FLAG7, ACPI_WDAT_OFFSET (Flags), "Stopped When Asleep", 0},
{ACPI_DMT_UINT24, ACPI_WDAT_OFFSET (Reserved2[0]), "Reserved", 0},
{ACPI_DMT_UINT32, ACPI_WDAT_OFFSET (Entries), "Watchdog Entry Count", 0},
ACPI_DMT_TERMINATOR
};
/* WDAT Subtables - Watchdog Instruction Entries */
ACPI_DMTABLE_INFO AcpiDmTableInfoWdat0[] =
{
{ACPI_DMT_UINT8, ACPI_WDAT0_OFFSET (Action), "Watchdog Action", 0},
{ACPI_DMT_UINT8, ACPI_WDAT0_OFFSET (Instruction), "Instruction", 0},
{ACPI_DMT_UINT16, ACPI_WDAT0_OFFSET (Reserved), "Reserved", 0},
{ACPI_DMT_GAS, ACPI_WDAT0_OFFSET (RegisterRegion), "Register Region", 0},
{ACPI_DMT_UINT32, ACPI_WDAT0_OFFSET (Value), "Value", 0},
{ACPI_DMT_UINT32, ACPI_WDAT0_OFFSET (Mask), "Register Mask", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* WDDT - Watchdog Description Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoWddt[] =
{
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (SpecVersion), "Specification Version", 0},
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (TableVersion), "Table Version", 0},
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (PciVendorId), "PCI Vendor ID", 0},
{ACPI_DMT_GAS, ACPI_WDDT_OFFSET (Address), "Timer Register", 0},
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (MaxCount), "Max Count", 0},
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (MinCount), "Min Count", 0},
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (Period), "Period", 0},
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (Status), "Status (decoded below)", 0},
/* Status Flags byte 0 */
{ACPI_DMT_FLAG0, ACPI_WDDT_FLAG_OFFSET (Status,0), "Available", 0},
{ACPI_DMT_FLAG1, ACPI_WDDT_FLAG_OFFSET (Status,0), "Active", 0},
{ACPI_DMT_FLAG2, ACPI_WDDT_FLAG_OFFSET (Status,0), "OS Owns", 0},
/* Status Flags byte 1 */
{ACPI_DMT_FLAG3, ACPI_WDDT_FLAG_OFFSET (Status,1), "User Reset", 0},
{ACPI_DMT_FLAG4, ACPI_WDDT_FLAG_OFFSET (Status,1), "Timeout Reset", 0},
{ACPI_DMT_FLAG5, ACPI_WDDT_FLAG_OFFSET (Status,1), "Power Fail Reset", 0},
{ACPI_DMT_FLAG6, ACPI_WDDT_FLAG_OFFSET (Status,1), "Unknown Reset", 0},
{ACPI_DMT_UINT16, ACPI_WDDT_OFFSET (Capability), "Capability (decoded below)", 0},
/* Capability Flags byte 0 */
{ACPI_DMT_FLAG0, ACPI_WDDT_FLAG_OFFSET (Capability,0), "Auto Reset", 0},
{ACPI_DMT_FLAG1, ACPI_WDDT_FLAG_OFFSET (Capability,0), "Timeout Alert", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* WDRT - Watchdog Resource Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoWdrt[] =
{
{ACPI_DMT_GAS, ACPI_WDRT_OFFSET (ControlRegister), "Control Register", 0},
{ACPI_DMT_GAS, ACPI_WDRT_OFFSET (CountRegister), "Count Register", 0},
{ACPI_DMT_UINT16, ACPI_WDRT_OFFSET (PciDeviceId), "PCI Device ID", 0},
{ACPI_DMT_UINT16, ACPI_WDRT_OFFSET (PciVendorId), "PCI Vendor ID", 0},
{ACPI_DMT_UINT8, ACPI_WDRT_OFFSET (PciBus), "PCI Bus", 0},
{ACPI_DMT_UINT8, ACPI_WDRT_OFFSET (PciDevice), "PCI Device", 0},
{ACPI_DMT_UINT8, ACPI_WDRT_OFFSET (PciFunction), "PCI Function", 0},
{ACPI_DMT_UINT8, ACPI_WDRT_OFFSET (PciSegment), "PCI Segment", 0},
{ACPI_DMT_UINT16, ACPI_WDRT_OFFSET (MaxCount), "Max Count", 0},
{ACPI_DMT_UINT8, ACPI_WDRT_OFFSET (Units), "Counter Units", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* WPBT - Windows Platform Environment Table (ACPI 6.0)
* Version 1
*
* Conforms to "Windows Platform Binary Table (WPBT)" 29 November 2011
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoWpbt[] =
{
{ACPI_DMT_UINT32, ACPI_WPBT_OFFSET (HandoffSize), "Handoff Size", 0},
{ACPI_DMT_UINT64, ACPI_WPBT_OFFSET (HandoffAddress), "Handoff Address", 0},
{ACPI_DMT_UINT8, ACPI_WPBT_OFFSET (Layout), "Layout", 0},
{ACPI_DMT_UINT8, ACPI_WPBT_OFFSET (Type), "Type", 0},
{ACPI_DMT_UINT16, ACPI_WPBT_OFFSET (ArgumentsLength), "Arguments Length", 0},
ACPI_DMT_TERMINATOR
};
ACPI_DMTABLE_INFO AcpiDmTableInfoWpbt0[] =
{
{ACPI_DMT_UNICODE, sizeof (ACPI_TABLE_WPBT), "Command-line Arguments", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* WSMT - Windows SMM Security Migrations Table
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoWsmt[] =
{
{ACPI_DMT_UINT32, ACPI_WSMT_OFFSET (ProtectionFlags), "Protection Flags", 0},
{ACPI_DMT_FLAG0, ACPI_WSMT_FLAG_OFFSET (ProtectionFlags,0), "FIXED_COMM_BUFFERS", 0},
{ACPI_DMT_FLAG1, ACPI_WSMT_FLAG_OFFSET (ProtectionFlags,0), "COMM_BUFFER_NESTED_PTR_PROTECTION", 0},
{ACPI_DMT_FLAG2, ACPI_WSMT_FLAG_OFFSET (ProtectionFlags,0), "SYSTEM_RESOURCE_PROTECTION", 0},
ACPI_DMT_TERMINATOR
};
/*******************************************************************************
*
* XENV - Xen Environment table (ACPI 6.0)
*
******************************************************************************/
ACPI_DMTABLE_INFO AcpiDmTableInfoXenv[] =
{
{ACPI_DMT_UINT64, ACPI_XENV_OFFSET (GrantTableAddress), "Grant Table Address", 0},
{ACPI_DMT_UINT64, ACPI_XENV_OFFSET (GrantTableSize), "Grant Table Size", 0},
{ACPI_DMT_UINT32, ACPI_XENV_OFFSET (EventInterrupt), "Event Interrupt", 0},
{ACPI_DMT_UINT8, ACPI_XENV_OFFSET (EventFlags), "Event Flags", 0},
ACPI_DMT_TERMINATOR
};
/*! [Begin] no source code translation */
/*
* Generic types (used in UEFI and custom tables)
*
* Examples:
*
* Buffer : cc 04 ff bb
* UINT8 : 11
* UINT16 : 1122
* UINT24 : 112233
* UINT32 : 11223344
* UINT56 : 11223344556677
* UINT64 : 1122334455667788
*
* String : "This is string"
* Unicode : "This string encoded to Unicode"
*
* GUID : 11223344-5566-7788-99aa-bbccddeeff00
* DevicePath : "\PciRoot(0)\Pci(0x1f,1)\Usb(0,0)"
*/
#define ACPI_DM_GENERIC_ENTRY(FieldType, FieldName) \
{{FieldType, 0, FieldName, 0}, ACPI_DMT_TERMINATOR}
ACPI_DMTABLE_INFO AcpiDmTableInfoGeneric[][2] =
{
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT8, "UINT8"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT16, "UINT16"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT24, "UINT24"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT32, "UINT32"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT40, "UINT40"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT48, "UINT48"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT56, "UINT56"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UINT64, "UINT64"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_STRING, "String"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UNICODE, "Unicode"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_BUFFER, "Buffer"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_UUID, "GUID"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_STRING, "DevicePath"),
ACPI_DM_GENERIC_ENTRY (ACPI_DMT_LABEL, "Label"),
{ACPI_DMT_TERMINATOR}
};
/*! [End] no source code translation !*/

View File

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

View File

@ -921,6 +921,13 @@ AslCommonError (
char *Filename,
char *ExtraMessage)
{
/* Check if user wants to ignore this exception */
if (AslIsExceptionIgnored (Level, MessageId))
{
return;
}
AslLogNewError (Level, MessageId, CurrentLineNumber, LogicalLineNumber,
LogicalByteOffset, Column, Filename, ExtraMessage,
NULL, NULL);

View File

@ -444,7 +444,7 @@ OpcAmlCheckForConstant (
if (Op->Asl.CompileFlags & OP_IS_TARGET)
{
DbgPrint (ASL_PARSE_OUTPUT,
"**** Valid Target, transform to Store ****\n");
"**** Valid Target, transform to Store or CopyObject ****\n");
return (AE_CTRL_RETURN_VALUE);
}
@ -468,7 +468,7 @@ OpcAmlCheckForConstant (
if (WalkState->Opcode == AML_BUFFER_OP)
{
DbgPrint (ASL_PARSE_OUTPUT,
"\nBuffer constant reduction is not supported yet\n");
"\nBuffer constant reduction is currently not supported\n");
if (NextOp) /* Found a Name() operator, error */
{
@ -623,6 +623,8 @@ TrTransformToStoreOp (
ACPI_PARSE_OBJECT *NewParent;
ACPI_PARSE_OBJECT *OriginalParent;
ACPI_STATUS Status;
UINT16 NewParseOpcode;
UINT16 NewAmlOpcode;
/* Extract the operands */
@ -646,9 +648,45 @@ TrTransformToStoreOp (
}
}
DbgPrint (ASL_PARSE_OUTPUT,
"Reduction/Transform to StoreOp: Store(%s, %s)\n",
Child1->Asl.ParseOpName, Child2->Asl.ParseOpName);
switch (Op->Asl.ParseOpcode)
{
/*
* Folding of the explicit conversion opcodes must use CopyObject
* instead of Store. This can change the object type of the target
* operand, as per the ACPI specification:
*
* "If the ASL operator is one of the explicit conversion operators
* (ToString, ToInteger, etc., and the CopyObject operator), no
* [implicit] conversion is performed. (In other words, the result
* object is stored directly to the target and completely overwrites
* any existing object already stored at the target)"
*/
case PARSEOP_TOINTEGER:
case PARSEOP_TOSTRING:
case PARSEOP_TOBUFFER:
case PARSEOP_TODECIMALSTRING:
case PARSEOP_TOHEXSTRING:
case PARSEOP_TOBCD:
case PARSEOP_FROMBCD:
NewParseOpcode = PARSEOP_COPYOBJECT;
NewAmlOpcode = AML_COPY_OBJECT_OP;
DbgPrint (ASL_PARSE_OUTPUT,
"Reduction/Transform to CopyObjectOp: CopyObject(%s, %s)\n",
Child1->Asl.ParseOpName, Child2->Asl.ParseOpName);
break;
default:
NewParseOpcode = PARSEOP_STORE;
NewAmlOpcode = AML_STORE_OP;
DbgPrint (ASL_PARSE_OUTPUT,
"Reduction/Transform to StoreOp: Store(%s, %s)\n",
Child1->Asl.ParseOpName, Child2->Asl.ParseOpName);
break;
}
/*
* Create a NULL (zero) target so that we can use the
@ -709,10 +747,10 @@ TrTransformToStoreOp (
TrInstallReducedConstant (Child1, ObjDesc);
/* Convert operator to STORE */
/* Convert operator to STORE or COPYOBJECT */
Op->Asl.ParseOpcode = PARSEOP_STORE;
Op->Asl.AmlOpcode = AML_STORE_OP;
Op->Asl.ParseOpcode = NewParseOpcode;
Op->Asl.AmlOpcode = NewAmlOpcode;
UtSetParseOpName (Op);
Op->Common.Parent = OriginalParent;

View File

@ -327,8 +327,8 @@ LdLoadFieldElements (
* The name already exists in this scope
* But continue processing the elements
*/
AslDualParseOpError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Child,
Child->Asl.Value.String, ASL_MSG_FOUND_HERE, Node->Op,
AslDualParseOpError (ASL_WARNING, ASL_MSG_EXTERN_COLLISION, Child,
Child->Asl.Value.String, ASL_MSG_EXTERN_FOUND_HERE, Node->Op,
Node->Op->Asl.ExternalName);
}
}
@ -830,8 +830,8 @@ LdNamespace1Begin (
if (Node->OwnerId == WalkState->OwnerId &&
!(Node->Flags & IMPLICIT_EXTERNAL))
{
AslDualParseOpError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op,
Op->Asl.ExternalName, ASL_MSG_FOUND_HERE, Node->Op,
AslDualParseOpError (ASL_WARNING, ASL_MSG_EXTERN_COLLISION, Op,
Op->Asl.ExternalName, ASL_MSG_EXTERN_FOUND_HERE, Node->Op,
Node->Op->Asl.ExternalName);
}
if (Node->Flags & IMPLICIT_EXTERNAL)
@ -853,8 +853,8 @@ LdNamespace1Begin (
if (Node->OwnerId == WalkState->OwnerId)
{
AslDualParseOpError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op,
Op->Asl.ExternalName, ASL_MSG_FOUND_HERE, Node->Op,
AslDualParseOpError (ASL_WARNING, ASL_MSG_EXTERN_COLLISION, Op,
Op->Asl.ExternalName, ASL_MSG_EXTERN_FOUND_HERE, Node->Op,
Node->Op->Asl.ExternalName);
}
}

View File

@ -352,7 +352,9 @@ const char *AslCompilerMsgs [] =
/* ASL_MSG_EXCEPTION_NOT_RECEIVED */ "Expected remark, warning, or error did not occur. Message ID:",
/* ASL_MSG_NULL_RESOURCE_TEMPLATE */ "Empty Resource Template (END_TAG only)",
/* ASL_MSG_FOUND_HERE */ "Original name creation/declaration below: ",
/* ASL_MSG_ILLEGAL_RECURSION */ "Illegal recursive call to method that creates named objects"
/* ASL_MSG_ILLEGAL_RECURSION */ "Illegal recursive call to method that creates named objects",
/* ASL_MSG_EXTERN_COLLISION */ "A name cannot be defined and declared external in the same table",
/* ASL_MSG_FOUND_HERE_EXTERN*/ "Remove one of the declarations indicated above or below:"
};
/* Table compiler */

View File

@ -355,6 +355,8 @@ typedef enum
ASL_MSG_NULL_RESOURCE_TEMPLATE,
ASL_MSG_FOUND_HERE,
ASL_MSG_ILLEGAL_RECURSION,
ASL_MSG_EXTERN_COLLISION,
ASL_MSG_EXTERN_FOUND_HERE,
/* These messages are used by the Data Table compiler only */

View File

@ -453,7 +453,7 @@ DtCompileDataTable (
DtInsertCompilerIds (*FieldList);
Status = DtCompileTable (FieldList, AcpiDmTableInfoHeader,
&Gbl_RootTable, TRUE);
&Gbl_RootTable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -492,7 +492,7 @@ DtCompileDataTable (
{
Subtable = NULL;
Status = DtCompileTable (FieldList, TableData->TableInfo,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -531,7 +531,6 @@ DtCompileDataTable (
* PARAMETERS: Field - Current field list pointer
* Info - Info table for this ACPI table
* RetSubtable - Compile result of table
* Required - If this subtable must exist
*
* RETURN: Status
*
@ -543,8 +542,7 @@ ACPI_STATUS
DtCompileTable (
DT_FIELD **Field,
ACPI_DMTABLE_INFO *Info,
DT_SUBTABLE **RetSubtable,
BOOLEAN Required)
DT_SUBTABLE **RetSubtable)
{
DT_FIELD *LocalField;
UINT32 Length;
@ -682,19 +680,19 @@ DtCompileTable (
case ACPI_DMT_GAS:
Status = DtCompileTable (Field, AcpiDmTableInfoGas,
&InlineSubtable, TRUE);
&InlineSubtable);
break;
case ACPI_DMT_HESTNTFY:
Status = DtCompileTable (Field, AcpiDmTableInfoHestNotify,
&InlineSubtable, TRUE);
&InlineSubtable);
break;
case ACPI_DMT_IORTMEM:
Status = DtCompileTable (Field, AcpiDmTableInfoIortAcc,
&InlineSubtable, TRUE);
&InlineSubtable);
break;
default:
@ -783,7 +781,7 @@ DtCompileTwoSubtables (
DT_FIELD **PFieldList = (DT_FIELD **) List;
Status = DtCompileTable (PFieldList, TableInfo1, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, TableInfo1, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -794,7 +792,7 @@ DtCompileTwoSubtables (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, TableInfo2, &Subtable, FALSE);
Status = DtCompileTable (PFieldList, TableInfo2, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);

View File

@ -275,8 +275,7 @@ ACPI_STATUS
DtCompileTable (
DT_FIELD **Field,
ACPI_DMTABLE_INFO *Info,
DT_SUBTABLE **RetSubtable,
BOOLEAN Required);
DT_SUBTABLE **RetSubtable);
ACPI_STATUS
DtCompileTwoSubtables (

View File

@ -209,7 +209,7 @@ DtResolveIntegerExpression (
* FUNCTION: DtDoOperator
*
* PARAMETERS: LeftValue - First 64-bit operand
* Operator - Parse token for the operator (EXPOP_*)
* Operator - Parse token for the operator (OP_EXP_*)
* RightValue - Second 64-bit operand
*
* RETURN: 64-bit result of the requested operation
@ -231,22 +231,22 @@ DtDoOperator (
switch (Operator)
{
case EXPOP_ONES_COMPLIMENT:
case OP_EXP_ONES_COMPLIMENT:
Result = ~RightValue;
break;
case EXPOP_LOGICAL_NOT:
case OP_EXP_LOGICAL_NOT:
Result = !RightValue;
break;
case EXPOP_MULTIPLY:
case OP_EXP_MULTIPLY:
Result = LeftValue * RightValue;
break;
case EXPOP_DIVIDE:
case OP_EXP_DIVIDE:
if (!RightValue)
{
@ -258,7 +258,7 @@ DtDoOperator (
Result = LeftValue / RightValue;
break;
case EXPOP_MODULO:
case OP_EXP_MODULO:
if (!RightValue)
{
@ -270,76 +270,76 @@ DtDoOperator (
Result = LeftValue % RightValue;
break;
case EXPOP_ADD:
case OP_EXP_ADD:
Result = LeftValue + RightValue;
break;
case EXPOP_SUBTRACT:
case OP_EXP_SUBTRACT:
Result = LeftValue - RightValue;
break;
case EXPOP_SHIFT_RIGHT:
case OP_EXP_SHIFT_RIGHT:
Result = LeftValue >> RightValue;
break;
case EXPOP_SHIFT_LEFT:
case OP_EXP_SHIFT_LEFT:
Result = LeftValue << RightValue;
break;
case EXPOP_LESS:
case OP_EXP_LESS:
Result = LeftValue < RightValue;
break;
case EXPOP_GREATER:
case OP_EXP_GREATER:
Result = LeftValue > RightValue;
break;
case EXPOP_LESS_EQUAL:
case OP_EXP_LESS_EQUAL:
Result = LeftValue <= RightValue;
break;
case EXPOP_GREATER_EQUAL:
case OP_EXP_GREATER_EQUAL:
Result = LeftValue >= RightValue;
break;
case EXPOP_EQUAL:
case OP_EXP_EQUAL:
Result = LeftValue == RightValue;
break;
case EXPOP_NOT_EQUAL:
case OP_EXP_NOT_EQUAL:
Result = LeftValue != RightValue;
break;
case EXPOP_AND:
case OP_EXP_AND:
Result = LeftValue & RightValue;
break;
case EXPOP_XOR:
case OP_EXP_XOR:
Result = LeftValue ^ RightValue;
break;
case EXPOP_OR:
case OP_EXP_OR:
Result = LeftValue | RightValue;
break;
case EXPOP_LOGICAL_AND:
case OP_EXP_LOGICAL_AND:
Result = LeftValue && RightValue;
break;
case EXPOP_LOGICAL_OR:
case OP_EXP_LOGICAL_OR:
Result = LeftValue || RightValue;
break;

View File

@ -171,37 +171,37 @@ NewLine [\n]
%%
\( return (EXPOP_PAREN_OPEN);
\) return (EXPOP_PAREN_CLOSE);
\~ return (EXPOP_ONES_COMPLIMENT);
\! return (EXPOP_LOGICAL_NOT);
\* return (EXPOP_MULTIPLY);
\/ return (EXPOP_DIVIDE);
\% return (EXPOP_MODULO);
\+ return (EXPOP_ADD);
\- return (EXPOP_SUBTRACT);
">>" return (EXPOP_SHIFT_RIGHT);
"<<" return (EXPOP_SHIFT_LEFT);
\< return (EXPOP_LESS);
\> return (EXPOP_GREATER);
"<=" return (EXPOP_LESS_EQUAL);
">=" return (EXPOP_GREATER_EQUAL);
"==" return (EXPOP_EQUAL);
"!=" return (EXPOP_NOT_EQUAL);
\& return (EXPOP_AND);
\^ return (EXPOP_XOR);
\| return (EXPOP_OR);
"&&" return (EXPOP_LOGICAL_AND);
"||" return (EXPOP_LOGICAL_OR);
<<EOF>> return (EXPOP_EOF); /* null end-of-string */
\( return (OP_EXP_PAREN_OPEN);
\) return (OP_EXP_PAREN_CLOSE);
\~ return (OP_EXP_ONES_COMPLIMENT);
\! return (OP_EXP_LOGICAL_NOT);
\* return (OP_EXP_MULTIPLY);
\/ return (OP_EXP_DIVIDE);
\% return (OP_EXP_MODULO);
\+ return (OP_EXP_ADD);
\- return (OP_EXP_SUBTRACT);
">>" return (OP_EXP_SHIFT_RIGHT);
"<<" return (OP_EXP_SHIFT_LEFT);
\< return (OP_EXP_LESS);
\> return (OP_EXP_GREATER);
"<=" return (OP_EXP_LESS_EQUAL);
">=" return (OP_EXP_GREATER_EQUAL);
"==" return (OP_EXP_EQUAL);
"!=" return (OP_EXP_NOT_EQUAL);
\& return (OP_EXP_AND);
\^ return (OP_EXP_XOR);
\| return (OP_EXP_OR);
"&&" return (OP_EXP_LOGICAL_AND);
"||" return (OP_EXP_LOGICAL_OR);
<<EOF>> return (OP_EXP_EOF); /* null end-of-string */
{LabelRef} return (EXPOP_LABEL);
{Number} return (EXPOP_NUMBER);
{HexNumber} return (EXPOP_HEX_NUMBER);
{NewLine} return (EXPOP_NEW_LINE);
{LabelRef} return (OP_EXP_LABEL);
{Number} return (OP_EXP_NUMBER);
{HexNumber} return (OP_EXP_HEX_NUMBER);
{NewLine} return (OP_EXP_NEW_LINE);
{WhiteSpace} /* Ignore */
. return (EXPOP_EOF);
. return (OP_EXP_EOF);
%%

View File

@ -193,26 +193,26 @@ UINT64 DtParserResult; /* Expression return value */
%type <value> Expression
%token <op> EXPOP_EOF
%token <op> EXPOP_NEW_LINE
%token <op> EXPOP_NUMBER
%token <op> EXPOP_HEX_NUMBER
%token <op> EXPOP_DECIMAL_NUMBER
%token <op> EXPOP_LABEL
%token <op> EXPOP_PAREN_OPEN
%token <op> EXPOP_PAREN_CLOSE
%token <op> OP_EXP_EOF
%token <op> OP_EXP_NEW_LINE
%token <op> OP_EXP_NUMBER
%token <op> OP_EXP_HEX_NUMBER
%token <op> OP_EXP_DECIMAL_NUMBER
%token <op> OP_EXP_LABEL
%token <op> OP_EXP_PAREN_OPEN
%token <op> OP_EXP_PAREN_CLOSE
%left <op> EXPOP_LOGICAL_OR
%left <op> EXPOP_LOGICAL_AND
%left <op> EXPOP_OR
%left <op> EXPOP_XOR
%left <op> EXPOP_AND
%left <op> EXPOP_EQUAL EXPOP_NOT_EQUAL
%left <op> EXPOP_GREATER EXPOP_LESS EXPOP_GREATER_EQUAL EXPOP_LESS_EQUAL
%left <op> EXPOP_SHIFT_RIGHT EXPOP_SHIFT_LEFT
%left <op> EXPOP_ADD EXPOP_SUBTRACT
%left <op> EXPOP_MULTIPLY EXPOP_DIVIDE EXPOP_MODULO
%right <op> EXPOP_ONES_COMPLIMENT EXPOP_LOGICAL_NOT
%left <op> OP_EXP_LOGICAL_OR
%left <op> OP_EXP_LOGICAL_AND
%left <op> OP_EXP_OR
%left <op> OP_EXP_XOR
%left <op> OP_EXP_AND
%left <op> OP_EXP_EQUAL OP_EXP_NOT_EQUAL
%left <op> OP_EXP_GREATER OP_EXP_LESS OP_EXP_GREATER_EQUAL OP_EXP_LESS_EQUAL
%left <op> OP_EXP_SHIFT_RIGHT OP_EXP_SHIFT_LEFT
%left <op> OP_EXP_ADD OP_EXP_SUBTRACT
%left <op> OP_EXP_MULTIPLY OP_EXP_DIVIDE OP_EXP_MODULO
%right <op> OP_EXP_ONES_COMPLIMENT OP_EXP_LOGICAL_NOT
%%
@ -233,46 +233,46 @@ UINT64 DtParserResult; /* Expression return value */
* 12) ||
*/
Value
: Expression EXPOP_NEW_LINE { DtParserResult=$1; return 0; } /* End of line (newline) */
| Expression EXPOP_EOF { DtParserResult=$1; return 0; } /* End of string (0) */
: Expression OP_EXP_NEW_LINE { DtParserResult=$1; return 0; } /* End of line (newline) */
| Expression OP_EXP_EOF { DtParserResult=$1; return 0; } /* End of string (0) */
;
Expression
/* Unary operators */
: EXPOP_LOGICAL_NOT Expression { $$ = DtDoOperator ($2, EXPOP_LOGICAL_NOT, $2);}
| EXPOP_ONES_COMPLIMENT Expression { $$ = DtDoOperator ($2, EXPOP_ONES_COMPLIMENT, $2);}
: OP_EXP_LOGICAL_NOT Expression { $$ = DtDoOperator ($2, OP_EXP_LOGICAL_NOT, $2);}
| OP_EXP_ONES_COMPLIMENT Expression { $$ = DtDoOperator ($2, OP_EXP_ONES_COMPLIMENT, $2);}
/* Binary operators */
| Expression EXPOP_MULTIPLY Expression { $$ = DtDoOperator ($1, EXPOP_MULTIPLY, $3);}
| Expression EXPOP_DIVIDE Expression { $$ = DtDoOperator ($1, EXPOP_DIVIDE, $3);}
| Expression EXPOP_MODULO Expression { $$ = DtDoOperator ($1, EXPOP_MODULO, $3);}
| Expression EXPOP_ADD Expression { $$ = DtDoOperator ($1, EXPOP_ADD, $3);}
| Expression EXPOP_SUBTRACT Expression { $$ = DtDoOperator ($1, EXPOP_SUBTRACT, $3);}
| Expression EXPOP_SHIFT_RIGHT Expression { $$ = DtDoOperator ($1, EXPOP_SHIFT_RIGHT, $3);}
| Expression EXPOP_SHIFT_LEFT Expression { $$ = DtDoOperator ($1, EXPOP_SHIFT_LEFT, $3);}
| Expression EXPOP_GREATER Expression { $$ = DtDoOperator ($1, EXPOP_GREATER, $3);}
| Expression EXPOP_LESS Expression { $$ = DtDoOperator ($1, EXPOP_LESS, $3);}
| Expression EXPOP_GREATER_EQUAL Expression { $$ = DtDoOperator ($1, EXPOP_GREATER_EQUAL, $3);}
| Expression EXPOP_LESS_EQUAL Expression { $$ = DtDoOperator ($1, EXPOP_LESS_EQUAL, $3);}
| Expression EXPOP_EQUAL Expression { $$ = DtDoOperator ($1, EXPOP_EQUAL, $3);}
| Expression EXPOP_NOT_EQUAL Expression { $$ = DtDoOperator ($1, EXPOP_NOT_EQUAL, $3);}
| Expression EXPOP_AND Expression { $$ = DtDoOperator ($1, EXPOP_AND, $3);}
| Expression EXPOP_XOR Expression { $$ = DtDoOperator ($1, EXPOP_XOR, $3);}
| Expression EXPOP_OR Expression { $$ = DtDoOperator ($1, EXPOP_OR, $3);}
| Expression EXPOP_LOGICAL_AND Expression { $$ = DtDoOperator ($1, EXPOP_LOGICAL_AND, $3);}
| Expression EXPOP_LOGICAL_OR Expression { $$ = DtDoOperator ($1, EXPOP_LOGICAL_OR, $3);}
| Expression OP_EXP_MULTIPLY Expression { $$ = DtDoOperator ($1, OP_EXP_MULTIPLY, $3);}
| Expression OP_EXP_DIVIDE Expression { $$ = DtDoOperator ($1, OP_EXP_DIVIDE, $3);}
| Expression OP_EXP_MODULO Expression { $$ = DtDoOperator ($1, OP_EXP_MODULO, $3);}
| Expression OP_EXP_ADD Expression { $$ = DtDoOperator ($1, OP_EXP_ADD, $3);}
| Expression OP_EXP_SUBTRACT Expression { $$ = DtDoOperator ($1, OP_EXP_SUBTRACT, $3);}
| Expression OP_EXP_SHIFT_RIGHT Expression { $$ = DtDoOperator ($1, OP_EXP_SHIFT_RIGHT, $3);}
| Expression OP_EXP_SHIFT_LEFT Expression { $$ = DtDoOperator ($1, OP_EXP_SHIFT_LEFT, $3);}
| Expression OP_EXP_GREATER Expression { $$ = DtDoOperator ($1, OP_EXP_GREATER, $3);}
| Expression OP_EXP_LESS Expression { $$ = DtDoOperator ($1, OP_EXP_LESS, $3);}
| Expression OP_EXP_GREATER_EQUAL Expression { $$ = DtDoOperator ($1, OP_EXP_GREATER_EQUAL, $3);}
| Expression OP_EXP_LESS_EQUAL Expression { $$ = DtDoOperator ($1, OP_EXP_LESS_EQUAL, $3);}
| Expression OP_EXP_EQUAL Expression { $$ = DtDoOperator ($1, OP_EXP_EQUAL, $3);}
| Expression OP_EXP_NOT_EQUAL Expression { $$ = DtDoOperator ($1, OP_EXP_NOT_EQUAL, $3);}
| Expression OP_EXP_AND Expression { $$ = DtDoOperator ($1, OP_EXP_AND, $3);}
| Expression OP_EXP_XOR Expression { $$ = DtDoOperator ($1, OP_EXP_XOR, $3);}
| Expression OP_EXP_OR Expression { $$ = DtDoOperator ($1, OP_EXP_OR, $3);}
| Expression OP_EXP_LOGICAL_AND Expression { $$ = DtDoOperator ($1, OP_EXP_LOGICAL_AND, $3);}
| Expression OP_EXP_LOGICAL_OR Expression { $$ = DtDoOperator ($1, OP_EXP_LOGICAL_OR, $3);}
/* Parentheses: '(' Expression ')' */
| EXPOP_PAREN_OPEN Expression
EXPOP_PAREN_CLOSE { $$ = $2;}
| OP_EXP_PAREN_OPEN Expression
OP_EXP_PAREN_CLOSE { $$ = $2;}
/* Label references (prefixed with $) */
| EXPOP_LABEL { $$ = DtResolveLabel (DtParsertext);}
| OP_EXP_LABEL { $$ = DtResolveLabel (DtParsertext);}
/*
* All constants for the data table compiler are in hex, whether a (optional) 0x
@ -283,15 +283,15 @@ Expression
/* Non-prefixed hex number */
| EXPOP_NUMBER { $$ = DtDoConstant (DtParsertext);}
| OP_EXP_NUMBER { $$ = DtDoConstant (DtParsertext);}
/* Standard hex number (0x1234) */
| EXPOP_HEX_NUMBER { $$ = DtDoConstant (DtParsertext);}
| OP_EXP_HEX_NUMBER { $$ = DtDoConstant (DtParsertext);}
/* Possible TBD: Decimal number with prefix (0d1234) - Not supported this time */
| EXPOP_DECIMAL_NUMBER { $$ = DtDoConstant (DtParsertext);}
| OP_EXP_DECIMAL_NUMBER { $$ = DtDoConstant (DtParsertext);}
;
%%
@ -300,7 +300,7 @@ Expression
/*
* Local support functions, including parser entry point
*/
#define PR_FIRST_PARSE_OPCODE EXPOP_EOF
#define PR_FIRST_PARSE_OPCODE OP_EXP_EOF
#define PR_YYTNAME_START 3
@ -329,7 +329,7 @@ DtParsererror (
*
* FUNCTION: DtGetOpName
*
* PARAMETERS: ParseOpcode - Parser token (EXPOP_*)
* PARAMETERS: ParseOpcode - Parser token (OP_EXP_*)
*
* RETURN: Pointer to the opcode name
*
@ -344,7 +344,7 @@ DtGetOpName (
#ifdef ASL_YYTNAME_START
/*
* First entries (PR_YYTNAME_START) in yytname are special reserved names.
* Ignore first 6 characters of name (EXPOP_)
* Ignore first 6 characters of name (OP_EXP_)
*/
return ((char *) yytname
[(ParseOpcode - PR_FIRST_PARSE_OPCODE) + PR_YYTNAME_START] + 6);

View File

@ -182,7 +182,7 @@ DtCompileRsdp (
/* Compile the "common" RSDP (ACPI 1.0) */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp1,
&Gbl_RootTable, TRUE);
&Gbl_RootTable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -196,7 +196,7 @@ DtCompileRsdp (
/* Compile the "extended" part of the RSDP as a subtable */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -240,7 +240,7 @@ DtCompileFadt (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt1,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -255,7 +255,7 @@ DtCompileFadt (
if (Revision == 2)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -266,7 +266,7 @@ DtCompileFadt (
else if (Revision >= 2)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt3,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -277,7 +277,7 @@ DtCompileFadt (
if (Revision >= 5)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt5,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -289,7 +289,7 @@ DtCompileFadt (
if (Revision >= 6)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt6,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -326,7 +326,7 @@ DtCompileFacs (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFacs,
&Gbl_RootTable, TRUE);
&Gbl_RootTable);
if (ACPI_FAILURE (Status))
{
return (Status);

View File

@ -202,7 +202,7 @@ DtCompileAsf (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -247,7 +247,7 @@ DtCompileAsf (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -307,7 +307,7 @@ DtCompileAsf (
while (DataCount > 0)
{
Status = DtCompileTable (PFieldList, DataInfoTable,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -323,7 +323,7 @@ DtCompileAsf (
for (i = 0; i < DataCount; i++)
{
Status = DtCompileTable (PFieldList, DataInfoTable,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -399,7 +399,7 @@ DtCompileCsrt (
/* Resource group subtable */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt0,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -424,7 +424,7 @@ DtCompileCsrt (
/* Shared info subtable (One per resource group) */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt1,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -438,7 +438,7 @@ DtCompileCsrt (
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -451,7 +451,7 @@ DtCompileCsrt (
if (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -504,7 +504,7 @@ DtCompileDbg2 (
/* Main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -529,7 +529,7 @@ DtCompileDbg2 (
/* Subtable: Debug Device Information */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Device,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -550,7 +550,7 @@ DtCompileDbg2 (
for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Addr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -566,7 +566,7 @@ DtCompileDbg2 (
for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Size,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -580,7 +580,7 @@ DtCompileDbg2 (
DeviceInfo->NamepathOffset = CurrentOffset;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Name,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -595,7 +595,7 @@ DtCompileDbg2 (
/* OemData - Variable-length data (Optional, size = OemDataLength) */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2OemData,
&Subtable, TRUE);
&Subtable);
if (Status == AE_END_OF_TABLE)
{
/* optional field was not found and we're at the end of the file */
@ -659,7 +659,7 @@ DtCompileDmar (
UINT32 PciPathLength;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -675,7 +675,7 @@ DtCompileDmar (
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -722,7 +722,7 @@ DtCompileDmar (
/* DMAR Subtable */
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -749,7 +749,7 @@ DtCompileDmar (
while (DeviceScopeLength)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope,
&Subtable, FALSE);
&Subtable);
if (Status == AE_NOT_FOUND)
{
break;
@ -767,7 +767,7 @@ DtCompileDmar (
while (PciPathLength)
{
Status = DtCompileTable (PFieldList, TableInfoDmarPciPath,
&Subtable, FALSE);
&Subtable);
if (Status == AE_NOT_FOUND)
{
DtPopSubtable ();
@ -823,7 +823,7 @@ DtCompileDrtm (
/* Compile DRTM header */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -841,7 +841,7 @@ DtCompileDrtm (
/* Compile VTL */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -857,7 +857,7 @@ DtCompileDrtm (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -877,7 +877,7 @@ DtCompileDrtm (
/* Compile RL */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -893,7 +893,7 @@ DtCompileDrtm (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -915,7 +915,7 @@ DtCompileDrtm (
/* Compile DPS */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1005,7 +1005,7 @@ DtCompileGtdt (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1018,7 +1018,7 @@ DtCompileGtdt (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdtHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1048,7 +1048,7 @@ DtCompileGtdt (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1074,7 +1074,7 @@ DtCompileGtdt (
while (GtCount)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt0a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1128,7 +1128,7 @@ DtCompileFpdt (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoFpdtHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1159,7 +1159,7 @@ DtCompileFpdt (
break;
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1201,7 +1201,7 @@ DtCompileHest (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1272,7 +1272,7 @@ DtCompileHest (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1312,7 +1312,7 @@ DtCompileHest (
while (BankCount)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1362,7 +1362,7 @@ DtCompileHmat (
ParentTable = DtPeekSubtable ();
Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmat,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1375,7 +1375,7 @@ DtCompileHmat (
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmatHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1410,7 +1410,7 @@ DtCompileHmat (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1433,7 +1433,7 @@ DtCompileHmat (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList,
AcpiDmTableInfoHmat1a, &Subtable, TRUE);
AcpiDmTableInfoHmat1a, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1454,7 +1454,7 @@ DtCompileHmat (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList,
AcpiDmTableInfoHmat1b, &Subtable, TRUE);
AcpiDmTableInfoHmat1b, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1479,7 +1479,7 @@ DtCompileHmat (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList,
AcpiDmTableInfoHmat1c, &Subtable, TRUE);
AcpiDmTableInfoHmat1c, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1513,7 +1513,7 @@ DtCompileHmat (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList,
AcpiDmTableInfoHmat2a, &Subtable, TRUE);
AcpiDmTableInfoHmat2a, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1576,7 +1576,7 @@ DtCompileIort (
ParentTable = DtPeekSubtable ();
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1598,7 +1598,7 @@ DtCompileIort (
*/
Iort->NodeOffset = sizeof (ACPI_TABLE_IORT);
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortPad,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1624,7 +1624,7 @@ DtCompileIort (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1642,7 +1642,7 @@ DtCompileIort (
case ACPI_IORT_NODE_ITS_GROUP:
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1656,7 +1656,7 @@ DtCompileIort (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1677,7 +1677,7 @@ DtCompileIort (
case ACPI_IORT_NODE_NAMED_COMPONENT:
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1692,7 +1692,7 @@ DtCompileIort (
* for filling this field.
*/
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1729,7 +1729,7 @@ DtCompileIort (
case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1742,7 +1742,7 @@ DtCompileIort (
case ACPI_IORT_NODE_SMMU:
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1756,7 +1756,7 @@ DtCompileIort (
IortSmmu->GlobalInterruptOffset = NodeLength;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1772,7 +1772,7 @@ DtCompileIort (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3b,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1797,7 +1797,7 @@ DtCompileIort (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3c,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1819,7 +1819,7 @@ DtCompileIort (
case ACPI_IORT_NODE_SMMU_V3:
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort4,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1842,7 +1842,7 @@ DtCompileIort (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortMap,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1905,7 +1905,7 @@ DtCompileIvrs (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1918,7 +1918,7 @@ DtCompileIvrs (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1950,7 +1950,7 @@ DtCompileIvrs (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -2012,7 +2012,7 @@ DtCompileIvrs (
}
Status = DtCompileTable (PFieldList, InfoTable,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);

View File

@ -191,7 +191,7 @@ DtCompileLpit (
/* LPIT Subtable header */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -218,7 +218,7 @@ DtCompileLpit (
/* LPIT Subtable */
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -259,7 +259,7 @@ DtCompileMadt (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -272,7 +272,7 @@ DtCompileMadt (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -372,7 +372,7 @@ DtCompileMadt (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -442,7 +442,7 @@ DtCompileMpst (
/* Main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -460,7 +460,7 @@ DtCompileMpst (
/* Subtable: Memory Power Node(s) */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -481,7 +481,7 @@ DtCompileMpst (
while (*PFieldList && PowerStateCount)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -496,7 +496,7 @@ DtCompileMpst (
while (*PFieldList && ComponentCount)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -514,7 +514,7 @@ DtCompileMpst (
DtPopSubtable ();
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -534,7 +534,7 @@ DtCompileMpst (
while (*PFieldList && SubtableCount)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -630,7 +630,7 @@ DtCompileNfit (
/* Main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -646,7 +646,7 @@ DtCompileNfit (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -708,7 +708,7 @@ DtCompileNfit (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -727,7 +727,7 @@ DtCompileNfit (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a,
&Subtable, FALSE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -752,7 +752,7 @@ DtCompileNfit (
if (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -772,7 +772,7 @@ DtCompileNfit (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a,
&Subtable, FALSE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -829,7 +829,7 @@ DtCompilePcct (
/* Main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -844,7 +844,7 @@ DtCompilePcct (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -889,7 +889,7 @@ DtCompilePcct (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -930,7 +930,7 @@ DtCompilePdtt (
/* Main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -949,7 +949,7 @@ DtCompilePdtt (
/* List of subchannel IDs, each 2 bytes */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt0,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -993,7 +993,7 @@ DtCompilePmtt (
/* Main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1007,7 +1007,7 @@ DtCompilePmtt (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1039,7 +1039,7 @@ DtCompilePmtt (
/* Subtable: Socket Structure */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1054,7 +1054,7 @@ DtCompilePmtt (
/* Subtable: Memory Controller Structure */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1070,7 +1070,7 @@ DtCompilePmtt (
while (DomainCount)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1086,7 +1086,7 @@ DtCompilePmtt (
/* Subtable: Physical Component Structure */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1141,7 +1141,7 @@ DtCompilePptt (
/* Compile PPTT subtable header */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoPpttHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1175,7 +1175,7 @@ DtCompilePptt (
/* Compile PPTT subtable body */
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1199,7 +1199,7 @@ DtCompilePptt (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList,
AcpiDmTableInfoPptt0a, &Subtable, TRUE);
AcpiDmTableInfoPptt0a, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1288,7 +1288,7 @@ DtCompileS3pt (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
&Gbl_RootTable, TRUE);
&Gbl_RootTable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1300,7 +1300,7 @@ DtCompileS3pt (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1330,7 +1330,7 @@ DtCompileS3pt (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1381,7 +1381,7 @@ DtCompileSdev (
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdevHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1416,7 +1416,7 @@ DtCompileSdev (
/* Compile SDEV subtable body */
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1434,7 +1434,7 @@ DtCompileSdev (
/* Append DeviceId namespace string */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev0a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1459,7 +1459,7 @@ DtCompileSdev (
if (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1491,7 +1491,7 @@ DtCompileSdev (
while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device"))
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a,
&Subtable, FALSE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1522,7 +1522,7 @@ DtCompileSdev (
if (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1583,7 +1583,7 @@ DtCompileSlic (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1625,7 +1625,7 @@ DtCompileSlit (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1681,7 +1681,7 @@ DtCompileSrat (
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1694,7 +1694,7 @@ DtCompileSrat (
{
SubtableStart = *PFieldList;
Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1739,7 +1739,7 @@ DtCompileSrat (
return (AE_ERROR);
}
Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1779,7 +1779,7 @@ DtCompileStao (
/* Compile the main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1793,7 +1793,7 @@ DtCompileStao (
while (*PFieldList)
{
Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1833,7 +1833,7 @@ DtCompileTcpa (
/* Compile the main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1853,13 +1853,13 @@ DtCompileTcpa (
case ACPI_TCPA_CLIENT_TABLE:
Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
&Subtable, TRUE);
&Subtable);
break;
case ACPI_TCPA_SERVER_TABLE:
Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
&Subtable, TRUE);
&Subtable);
break;
default:
@ -1902,7 +1902,7 @@ DtCompileTpm2 (
/* Compile the main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1919,7 +1919,7 @@ DtCompileTpm2 (
/* TBD: Optional fields above not fully implemented (not optional at this time) */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -1938,7 +1938,7 @@ DtCompileTpm2 (
/* Subtable specific to to ARM_SMC */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -2053,7 +2053,7 @@ DtCompileUefi (
/* Compile the predefined portion of the UEFI table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -2152,7 +2152,7 @@ DtCompileWpbt (
/* Compile the main table */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -2164,7 +2164,7 @@ DtCompileWpbt (
/* Compile the argument list subtable */
Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0,
&Subtable, TRUE);
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
@ -2284,7 +2284,7 @@ DtCompileGeneric (
}
Status = DtCompileTable (PFieldList, Info,
&Subtable, TRUE);
&Subtable);
if (ACPI_SUCCESS (Status))
{
DtInsertSubtable (ParentTable, Subtable);

View File

@ -481,6 +481,7 @@ AcpiDsGetPackageArguments (
Status = AcpiDsExecuteArguments (Node, Node,
ObjDesc->Package.AmlLength, ObjDesc->Package.AmlStart);
return_ACPI_STATUS (Status);
}

View File

@ -752,8 +752,8 @@ AcpiDsEvalDataObjectOperands (
if (!Op->Common.Value.Arg)
{
ACPI_ERROR ((AE_INFO,
"Dispatch: Missing child while executing TermArg for %X",
Op->Common.AmlOpcode));
"Missing child while evaluating opcode %4.4X, Op %p",
Op->Common.AmlOpcode, Op));
return_ACPI_STATUS (AE_OK);
}

View File

@ -155,6 +155,7 @@
#include <contrib/dev/acpica/include/amlcode.h>
#include <contrib/dev/acpica/include/acdispat.h>
#include <contrib/dev/acpica/include/acinterp.h>
#include <contrib/dev/acpica/include/acparser.h>
#define _COMPONENT ACPI_NAMESPACE
@ -208,6 +209,7 @@ AcpiDsBuildInternalPackageObj (
ACPI_PARSE_OBJECT *Parent;
ACPI_OPERAND_OBJECT *ObjDesc = NULL;
ACPI_STATUS Status = AE_OK;
BOOLEAN ModuleLevelCode = FALSE;
UINT16 ReferenceCount;
UINT32 Index;
UINT32 i;
@ -216,6 +218,13 @@ AcpiDsBuildInternalPackageObj (
ACPI_FUNCTION_TRACE (DsBuildInternalPackageObj);
/* Check if we are executing module level code */
if (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)
{
ModuleLevelCode = TRUE;
}
/* Find the parent of a possibly nested package */
Parent = Op->Common.Parent;
@ -250,25 +259,43 @@ AcpiDsBuildInternalPackageObj (
/*
* Allocate the element array (array of pointers to the individual
* objects) based on the NumElements parameter. Add an extra pointer slot
* so that the list is always null terminated.
* objects) if necessary. the count is based on the NumElements
* parameter. Add an extra pointer slot so that the list is always
* null terminated.
*/
ObjDesc->Package.Elements = ACPI_ALLOCATE_ZEROED (
((ACPI_SIZE) ElementCount + 1) * sizeof (void *));
if (!ObjDesc->Package.Elements)
{
AcpiUtDeleteObjectDesc (ObjDesc);
return_ACPI_STATUS (AE_NO_MEMORY);
ObjDesc->Package.Elements = ACPI_ALLOCATE_ZEROED (
((ACPI_SIZE) ElementCount + 1) * sizeof (void *));
if (!ObjDesc->Package.Elements)
{
AcpiUtDeleteObjectDesc (ObjDesc);
return_ACPI_STATUS (AE_NO_MEMORY);
}
ObjDesc->Package.Count = ElementCount;
}
ObjDesc->Package.Count = ElementCount;
/* First arg is element count. Second arg begins the initializer list */
Arg = Op->Common.Value.Arg;
Arg = Arg->Common.Next;
if (Arg)
/*
* If we are executing module-level code, we will defer the
* full resolution of the package elements in order to support
* forward references from the elements. This provides
* compatibility with other ACPI implementations.
*/
if (ModuleLevelCode)
{
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
ObjDesc->Package.AmlStart = WalkState->Aml;
ObjDesc->Package.AmlLength = 0;
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
"%s: Deferring resolution of Package elements\n",
ACPI_GET_FUNCTION_NAME));
}
/*
@ -308,12 +335,17 @@ AcpiDsBuildInternalPackageObj (
ACPI_ERROR ((AE_INFO, "%-48s", "****DS namepath not found"));
}
/*
* Initialize this package element. This function handles the
* resolution of named references within the package.
*/
AcpiDsInitPackageElement (0, ObjDesc->Package.Elements[i],
NULL, &ObjDesc->Package.Elements[i]);
if (!ModuleLevelCode)
{
/*
* Initialize this package element. This function handles the
* resolution of named references within the package.
* Forward references from module-level code are deferred
* until all ACPI tables are loaded.
*/
AcpiDsInitPackageElement (0, ObjDesc->Package.Elements[i],
NULL, &ObjDesc->Package.Elements[i]);
}
}
if (*ObjDescPtr)
@ -383,15 +415,21 @@ AcpiDsBuildInternalPackageObj (
* NumElements count.
*
* Note: this is not an error, the package is padded out
* with NULLs.
* with NULLs as per the ACPI specification.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Package List length (%u) smaller than NumElements "
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,
"%s: Package List length (%u) smaller than NumElements "
"count (%u), padded with null elements\n",
i, ElementCount));
ACPI_GET_FUNCTION_NAME, i, ElementCount));
}
/* Module-level packages will be resolved later */
if (!ModuleLevelCode)
{
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
}
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc);
return_ACPI_STATUS (Status);
}
@ -481,11 +519,12 @@ AcpiDsResolvePackageElement (
ACPI_OPERAND_OBJECT **ElementPtr)
{
ACPI_STATUS Status;
ACPI_STATUS Status2;
ACPI_GENERIC_STATE ScopeInfo;
ACPI_OPERAND_OBJECT *Element = *ElementPtr;
ACPI_NAMESPACE_NODE *ResolvedNode;
ACPI_NAMESPACE_NODE *OriginalNode;
char *ExternalPath = NULL;
char *ExternalPath = "";
ACPI_OBJECT_TYPE Type;
@ -496,6 +535,10 @@ AcpiDsResolvePackageElement (
if (Element->Reference.Resolved)
{
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
"%s: Package element is already resolved\n",
ACPI_GET_FUNCTION_NAME));
return_VOID;
}
@ -510,14 +553,41 @@ AcpiDsResolvePackageElement (
NULL, &ResolvedNode);
if (ACPI_FAILURE (Status))
{
Status = AcpiNsExternalizeName (ACPI_UINT32_MAX,
(char *) Element->Reference.Aml,
NULL, &ExternalPath);
#if defined ACPI_IGNORE_PACKAGE_RESOLUTION_ERRORS && !defined ACPI_APPLICATION
/*
* For the kernel-resident ACPICA, optionally be silent about the
* NOT_FOUND case. Although this is potentially a serious problem,
* it can generate a lot of noise/errors on platforms whose
* firmware carries around a bunch of unused Package objects.
* To disable these errors, define ACPI_IGNORE_PACKAGE_RESOLUTION_ERRORS
* in the OS-specific header.
*
* All errors are always reported for ACPICA applications such as
* AcpiExec.
*/
if (Status == AE_NOT_FOUND)
{
/* Reference name not found, set the element to NULL */
AcpiUtRemoveReference (*ElementPtr);
*ElementPtr = NULL;
return_VOID;
}
#endif
Status2 = AcpiNsExternalizeName (ACPI_UINT32_MAX,
(char *) Element->Reference.Aml, NULL, &ExternalPath);
ACPI_EXCEPTION ((AE_INFO, Status,
"Could not find/resolve named package element: %s", ExternalPath));
"While resolving a named reference package element - %s",
ExternalPath));
if (ACPI_SUCCESS (Status2))
{
ACPI_FREE (ExternalPath);
}
ACPI_FREE (ExternalPath);
/* Could not resolve name, set the element to NULL */
AcpiUtRemoveReference (*ElementPtr);
*ElementPtr = NULL;
return_VOID;
}
@ -531,24 +601,6 @@ AcpiDsResolvePackageElement (
*ElementPtr = NULL;
return_VOID;
}
#if 0
else if (ResolvedNode->Flags & ANOBJ_TEMPORARY)
{
/*
* A temporary node found here indicates that the reference is
* to a node that was created within this method. We are not
* going to allow it (especially if the package is returned
* from the method) -- the temporary node will be deleted out
* from under the method. (05/2017).
*/
ACPI_ERROR ((AE_INFO,
"Package element refers to a temporary name [%4.4s], "
"inserting a NULL element",
ResolvedNode->Name.Ascii));
*ElementPtr = NULL;
return_VOID;
}
#endif
/*
* Special handling for Alias objects. We need ResolvedNode to point
@ -587,22 +639,6 @@ AcpiDsResolvePackageElement (
return_VOID;
}
#if 0
/* TBD - alias support */
/*
* Special handling for Alias objects. We need to setup the type
* and the Op->Common.Node to point to the Alias target. Note,
* Alias has at most one level of indirection internally.
*/
Type = Op->Common.Node->Type;
if (Type == ACPI_TYPE_LOCAL_ALIAS)
{
Type = ObjDesc->Common.Type;
Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE,
Op->Common.Node->Object);
}
#endif
switch (Type)
{
/*

View File

@ -723,8 +723,8 @@ AcpiDsExecEndOp (
case AML_TYPE_CREATE_OBJECT:
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"Executing CreateObject (Buffer/Package) Op=%p AMLPtr=%p\n",
Op, Op->Named.Data));
"Executing CreateObject (Buffer/Package) Op=%p Child=%p ParentOpcode=%4.4X\n",
Op, Op->Named.Value.Arg, Op->Common.Parent->Common.AmlOpcode));
switch (Op->Common.Parent->Common.AmlOpcode)
{

View File

@ -264,7 +264,7 @@ AcpiDsLoad1BeginOp (
UINT32 Flags;
ACPI_FUNCTION_TRACE (DsLoad1BeginOp);
ACPI_FUNCTION_TRACE_PTR (DsLoad1BeginOp, WalkState->Op);
Op = WalkState->Op;

View File

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

View File

@ -309,14 +309,11 @@ AcpiExNameSegment (
return_ACPI_STATUS (AE_CTRL_PENDING);
}
ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Bytes from stream:\n"));
for (Index = 0;
(Index < ACPI_NAME_SIZE) && (AcpiUtValidNameChar (*AmlAddress, 0));
Index++)
{
CharBuf[Index] = *AmlAddress++;
ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "%c\n", CharBuf[Index]));
}
@ -330,9 +327,9 @@ AcpiExNameSegment (
if (NameString)
{
strcat (NameString, CharBuf);
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
"Appended to - %s\n", NameString));
"Appending NameSeg %s\n", CharBuf));
strcat (NameString, CharBuf);
}
else
{

View File

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

View File

@ -308,6 +308,7 @@ AcpiNsEvaluate (
*/
switch (AcpiNsGetType (Info->Node))
{
case ACPI_TYPE_ANY:
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_EVENT:
case ACPI_TYPE_MUTEX:
@ -315,13 +316,13 @@ AcpiNsEvaluate (
case ACPI_TYPE_THERMAL:
case ACPI_TYPE_LOCAL_SCOPE:
/*
* 1) Disallow evaluation of certain object types. For these,
* object evaluation is undefined and not supported.
* 1) Disallow evaluation of these object types. For these,
* object evaluation is undefined.
*/
ACPI_ERROR ((AE_INFO,
"%s: Evaluation of object type [%s] is not supported",
Info->FullPathname,
AcpiUtGetTypeName (Info->Node->Type)));
"%s: This object type [%s] "
"never contains data and cannot be evaluated",
Info->FullPathname, AcpiUtGetTypeName (Info->Node->Type)));
Status = AE_TYPE;
goto Cleanup;

View File

@ -418,7 +418,7 @@ AcpiNsInitializeDevices (
* RETURN: Status
*
* DESCRIPTION: Callback from AcpiWalkNamespace. Invoked for every object
* within the namespace.
* within the namespace.
*
* Currently, the only objects that require initialization are:
* 1) Methods
@ -540,6 +540,10 @@ AcpiNsInitOneObject (
break;
}
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
"%s: Completing resolution of Package elements\n",
ACPI_GET_FUNCTION_NAME));
/*
* Resolve all named references in package objects (and all
* sub-packages). This action has been deferred until the entire
@ -548,6 +552,7 @@ AcpiNsInitOneObject (
*/
Status = AcpiUtWalkPackageTree (ObjDesc, NULL,
AcpiDsInitPackageElement, NULL);
ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
break;

View File

@ -511,6 +511,9 @@ AcpiNsGetNormalizedPathname (
(void) AcpiNsBuildNormalizedPath (Node, NameBuffer, Size, NoTrailing);
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES, "%s: Path \"%s\"\n",
ACPI_GET_FUNCTION_NAME, NameBuffer));
return_PTR (NameBuffer);
}

View File

@ -232,8 +232,9 @@ AcpiNsExecuteTable (
goto Cleanup;
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Create table code block: %p\n", MethodObj));
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
"%s: Create table pseudo-method for [%4.4s] @%p, method %p\n",
ACPI_GET_FUNCTION_NAME, Table->Signature, Table, MethodObj));
MethodObj->Method.AmlStart = AmlStart;
MethodObj->Method.AmlLength = AmlLength;
@ -404,7 +405,8 @@ AcpiNsParseTable (
if (AcpiGbl_ParseTableAsTermList)
{
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Start load pass\n"));
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
"%s: **** Start table execution pass\n", ACPI_GET_FUNCTION_NAME));
Status = AcpiNsExecuteTable (TableIndex, StartNode);
if (ACPI_FAILURE (Status))

View File

@ -1067,10 +1067,9 @@ AcpiPsGetNextArg (
case ARGP_DATAOBJ:
case ARGP_TERMARG:
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"**** TermArg/DataObj: %s (%2.2X)\n",
AcpiUtGetArgumentTypeName (ArgType), ArgType));
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"**** TermArg/DataObj: %s (%2.2X)\n",
AcpiUtGetArgumentTypeName (ArgType), ArgType));
/* Single complex argument, nothing returned */

View File

@ -283,7 +283,7 @@ AcpiPsGetArguments (
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Final argument count: %u pass %u\n",
"Final argument count: %8.8X pass %u\n",
WalkState->ArgCount, WalkState->PassNumber));
/*
@ -697,7 +697,7 @@ AcpiPsParseLoop (
/* Check for arguments that need to be processed */
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Parseloop: argument count: %u\n", WalkState->ArgCount));
"Parseloop: argument count: %8.8X\n", WalkState->ArgCount));
if (WalkState->ArgCount)
{

View File

@ -576,7 +576,7 @@ AcpiPsParseAml (
if (!WalkState->ParserState.Aml)
{
return_ACPI_STATUS (AE_NULL_OBJECT);
return_ACPI_STATUS (AE_BAD_ADDRESS);
}
/* Create and initialize a new thread state */

View File

@ -438,6 +438,7 @@ AcpiPsGetChild (
case AML_BUFFER_OP:
case AML_PACKAGE_OP:
case AML_VARIABLE_PACKAGE_OP:
case AML_METHOD_OP:
case AML_IF_OP:
case AML_WHILE_OP:

View File

@ -415,8 +415,9 @@ AcpiOsAcquireObject (
Cache->CurrentDepth--;
ACPI_MEM_TRACKING (Cache->Hits++);
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"Object %p from %s cache\n", Object, Cache->ListName));
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,
"%s: Object %p from %s cache\n",
ACPI_GET_FUNCTION_NAME, Object, Cache->ListName));
Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES);
if (ACPI_FAILURE (Status))

View File

@ -454,8 +454,8 @@ AcpiUtDeleteInternalObj (
/* Now the object can be safely deleted */
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
Object, AcpiUtGetObjectTypeName (Object)));
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, "%s: Deleting Object %p [%s]\n",
ACPI_GET_FUNCTION_NAME, Object, AcpiUtGetObjectTypeName (Object)));
AcpiUtDeleteObjectDesc (Object);
return_VOID;
@ -581,9 +581,9 @@ AcpiUtUpdateRefCount (
Object));
}
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Type %.2X Refs %.2X [Decremented]\n",
Object, Object->Common.Type, NewCount));
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS,
"%s: Obj %p Type %.2X Refs %.2X [Decremented]\n",
ACPI_GET_FUNCTION_NAME, Object, Object->Common.Type, NewCount));
/* Actually delete the object on a reference count of zero */
@ -906,9 +906,9 @@ AcpiUtRemoveReference (
return;
}
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Current Refs=%X [To Be Decremented]\n",
Object, Object->Common.ReferenceCount));
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS,
"%s: Obj %p Current Refs=%X [To Be Decremented]\n",
ACPI_GET_FUNCTION_NAME, Object, Object->Common.ReferenceCount));
/*
* Decrement the reference count, and only actually delete the object

View File

@ -361,7 +361,7 @@
#define ARGI_FIELD_OP ARGI_INVALID_OPCODE
#define ARGI_FIND_SET_LEFT_BIT_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_FIND_SET_RIGHT_BIT_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_FROM_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_FROM_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_FIXED_TARGET)
#define ARGI_IF_OP ARGI_INVALID_OPCODE
#define ARGI_INCREMENT_OP ARGI_LIST1 (ARGI_TARGETREF)
#define ARGI_INDEX_FIELD_OP ARGI_INVALID_OPCODE
@ -425,12 +425,12 @@
#define ARGI_SUBTRACT_OP ARGI_LIST3 (ARGI_INTEGER, ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_THERMAL_ZONE_OP ARGI_INVALID_OPCODE
#define ARGI_TIMER_OP ARG_NONE
#define ARGI_TO_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_TO_BUFFER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_DEC_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_HEX_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_INTEGER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_TARGETREF)
#define ARGI_TO_STRING_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_TARGETREF)
#define ARGI_TO_BCD_OP ARGI_LIST2 (ARGI_INTEGER, ARGI_FIXED_TARGET)
#define ARGI_TO_BUFFER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_DEC_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_HEX_STR_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_INTEGER_OP ARGI_LIST2 (ARGI_COMPUTEDATA,ARGI_FIXED_TARGET)
#define ARGI_TO_STRING_OP ARGI_LIST3 (ARGI_BUFFER, ARGI_INTEGER, ARGI_FIXED_TARGET)
#define ARGI_UNLOAD_OP ARGI_LIST1 (ARGI_DDBHANDLE)
#define ARGI_VAR_PACKAGE_OP ARGI_LIST1 (ARGI_INTEGER)
#define ARGI_WAIT_OP ARGI_LIST2 (ARGI_EVENT, ARGI_INTEGER)

View File

@ -154,7 +154,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20180105
#define ACPI_CA_VERSION 0x20180209
#include <contrib/dev/acpica/include/acconfig.h>
#include <contrib/dev/acpica/include/actypes.h>
@ -302,6 +302,8 @@ ACPI_INIT_GLOBAL (UINT8, AcpiGbl_DoNotUseXsdt, FALSE);
/*
* Optionally support group module level code.
* NOTE, this is essentially obsolete and will be removed soon
* (01/2018).
*/
ACPI_INIT_GLOBAL (UINT8, AcpiGbl_GroupModuleLevelCode, FALSE);
@ -309,8 +311,10 @@ ACPI_INIT_GLOBAL (UINT8, AcpiGbl_GroupModuleLevelCode, FALSE);
* Optionally support module level code by parsing the entire table as
* a TermList. Default is FALSE, do not execute entire table until some
* lock order issues are fixed.
* NOTE, this is essentially obsolete and will be removed soon
* (01/2018).
*/
ACPI_INIT_GLOBAL (UINT8, AcpiGbl_ParseTableAsTermList, FALSE);
ACPI_INIT_GLOBAL (UINT8, AcpiGbl_ParseTableAsTermList, TRUE);
/*
* Optionally use 32-bit FADT addresses if and when there is a conflict

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -386,24 +386,9 @@
#define ARGI_DEVICE_REF 0x0D
#define ARGI_REFERENCE 0x0E
#define ARGI_TARGETREF 0x0F /* Target, subject to implicit conversion */
#define ARGI_SIMPLE_TARGET 0x10 /* Name, Local, Arg -- no implicit conversion */
#define ARGI_STORE_TARGET 0x11 /* Target for store is TARGETREF + package objects */
/*
* #define ARGI_FIXED_TARGET 0x10 Target, no implicit conversion
*
* Removed 10/2016. ARGI_FIXED_TARGET was used for these operators:
* FromBCD
* ToBCD
* ToDecimalString
* ToHexString
* ToInteger
* ToBuffer
* The purpose of this type was to disable "implicit result conversion",
* but this was incorrect per the ACPI spec and other ACPI implementations.
* These operators now have the target operand defined as a normal
* ARGI_TARGETREF.
*/
#define ARGI_FIXED_TARGET 0x10 /* Target, no implicit conversion */
#define ARGI_SIMPLE_TARGET 0x11 /* Name, Local, Arg -- no implicit conversion */
#define ARGI_STORE_TARGET 0x12 /* Target for store is TARGETREF + package objects */
/* Multiple/complex types */

View File

@ -6,7 +6,8 @@ PROG= iasl
SRCS= acfileio.c adfile.c adisasm.c adwalk.c ahids.c \
ahpredef.c ahtable.c ahuuids.c cmfsize.c dmextern.c \
dmrestag.c dmswitch.c dmtable.c dmtables.c dmtbdump.c \
dmtbinfo.c getopt.c
dmtbdump1.c dmtbdump2.c dmtbdump3.c dmtbinfo.c \
dmtbinfo1.c dmtbinfo2.c dmtbinfo3.c getopt.c
# compiler
SRCS+= aslallocate.c aslanalyze.c aslascii.c aslbtypes.c \