WebSVN – Kolibri OS – Diff – /drivers/devman/acpica/compiler/dttable.c


/******************************************************************************
 *
 * Module Name: dttable.c - handling for specific ACPI tables
 *
 *****************************************************************************/
 
/******************************************************************************
 *
 * 1. Copyright Notice
 *
 * Some or all of this work - Copyright (c) 1999 - 2011, 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.
 *
 *****************************************************************************/
 
#define __DTTABLE_C__
 
/* Compile all complex data tables */
 
#include "aslcompiler.h"
#include "dtcompiler.h"
 
#define _COMPONENT          DT_COMPILER
        ACPI_MODULE_NAME    ("dttable")
 
 
/* TBD: merge these into dmtbinfo.c? */
 
static ACPI_DMTABLE_INFO           TableInfoAsfAddress[] =
{
    {ACPI_DMT_BUFFER,   0,               "Addresses", 0},
    {ACPI_DMT_EXIT,     0,               NULL, 0}
};
 
static ACPI_DMTABLE_INFO           TableInfoDmarPciPath[] =
{
    {ACPI_DMT_PCI_PATH, 0,               "PCI Path", 0},
    {ACPI_DMT_EXIT,     0,               NULL, 0}
};
 
 
/* TBD: move to acmacros.h */
 
#define ACPI_SUB_PTR(t, a, b) \
    ACPI_CAST_PTR (t, (ACPI_CAST_PTR (UINT8, (a)) - (ACPI_SIZE)(b)))
 
 
/* Local prototypes */
 
static ACPI_STATUS
DtCompileTwoSubtables (
    void                    **List,
    ACPI_DMTABLE_INFO       *TableInfo1,
    ACPI_DMTABLE_INFO       *TableInfo2);
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileTwoSubtables
 *
 * PARAMETERS:  List                - Current field list pointer
 *              TableInfo1          - Info table 1
 *              TableInfo1          - Info table 2
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile tables with a header and one or more same subtables.
 *              Include CPEP, EINJ, ERST, MCFG, MSCT, WDAT
 *
 *****************************************************************************/
 
static ACPI_STATUS
DtCompileTwoSubtables (
    void                    **List,
    ACPI_DMTABLE_INFO       *TableInfo1,
    ACPI_DMTABLE_INFO       *TableInfo2)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
 
 
    Status = DtCompileTable (PFieldList, TableInfo1, &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    while (*PFieldList)
    {
        Status = DtCompileTable (PFieldList, TableInfo2, &Subtable, FALSE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        DtInsertSubtable (ParentTable, Subtable);
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileFacs
 *
 * PARAMETERS:  PFieldList          - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile FACS.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileFacs (
    DT_FIELD                **PFieldList)
{
    DT_SUBTABLE             *Subtable;
    UINT8                   *ReservedBuffer;
    ACPI_STATUS             Status;
    UINT32                  ReservedSize;
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoFacs,
                &Gbl_RootTable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /* Large FACS reserved area at the end of the table */
 
    ReservedSize = (UINT32) sizeof (((ACPI_TABLE_FACS *) NULL)->Reserved1);
    ReservedBuffer = UtLocalCalloc (ReservedSize);
 
    DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable);
 
    ACPI_FREE (ReservedBuffer);
    DtInsertSubtable (Gbl_RootTable, Subtable);
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileRsdp
 *
 * PARAMETERS:  PFieldList          - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile RSDP.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileRsdp (
    DT_FIELD                **PFieldList)
{
    DT_SUBTABLE             *Subtable;
    ACPI_TABLE_RSDP         *Rsdp;
    ACPI_RSDP_EXTENSION     *RsdpExtension;
    ACPI_STATUS             Status;
 
 
    /* Compile the "common" RSDP (ACPI 1.0) */
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp1,
                &Gbl_RootTable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Gbl_RootTable->Buffer);
    DtSetTableChecksum (&Rsdp->Checksum);
 
    if (Rsdp->Revision > 0)
    {
        /* Compile the "extended" part of the RSDP as a subtable */
 
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp2,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        DtInsertSubtable (Gbl_RootTable, Subtable);
 
        /* Set length and extended checksum for entire RSDP */
 
        RsdpExtension = ACPI_CAST_PTR (ACPI_RSDP_EXTENSION, Subtable->Buffer);
        RsdpExtension->Length = Gbl_RootTable->Length + Subtable->Length;
        DtSetTableChecksum (&RsdpExtension->ExtendedChecksum);
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileAsf
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile ASF!.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileAsf (
    void                    **List)
{
    ACPI_ASF_INFO           *AsfTable;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    ACPI_DMTABLE_INFO       *InfoTable;
    ACPI_DMTABLE_INFO       *DataInfoTable = NULL;
    UINT32                  DataCount = 0;
    ACPI_STATUS             Status;
    UINT32                  i;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *SubtableStart;
 
 
    while (*PFieldList)
    {
        SubtableStart = *PFieldList;
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPushSubtable (Subtable);
 
        AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer);
 
        switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
        {
        case ACPI_ASF_TYPE_INFO:
            InfoTable = AcpiDmTableInfoAsf0;
            break;
 
        case ACPI_ASF_TYPE_ALERT:
            InfoTable = AcpiDmTableInfoAsf1;
            break;
 
        case ACPI_ASF_TYPE_CONTROL:
            InfoTable = AcpiDmTableInfoAsf2;
            break;
 
        case ACPI_ASF_TYPE_BOOT:
            InfoTable = AcpiDmTableInfoAsf3;
            break;
 
        case ACPI_ASF_TYPE_ADDRESS:
            InfoTable = AcpiDmTableInfoAsf4;
            break;
 
        default:
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
            return (AE_ERROR);
        }
 
        Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
 
        switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
        {
        case ACPI_ASF_TYPE_INFO:
            DataInfoTable = NULL;
            break;
 
        case ACPI_ASF_TYPE_ALERT:
            DataInfoTable = AcpiDmTableInfoAsf1a;
            DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT,
                        ACPI_SUB_PTR (UINT8, Subtable->Buffer,
                            sizeof (ACPI_ASF_HEADER)))->Alerts;
            break;
 
        case ACPI_ASF_TYPE_CONTROL:
            DataInfoTable = AcpiDmTableInfoAsf2a;
            DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE,
                        ACPI_SUB_PTR (UINT8, Subtable->Buffer,
                            sizeof (ACPI_ASF_HEADER)))->Controls;
            break;
 
        case ACPI_ASF_TYPE_BOOT:
            DataInfoTable = NULL;
            break;
 
        case ACPI_ASF_TYPE_ADDRESS:
            DataInfoTable = TableInfoAsfAddress;
            DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS,
                        ACPI_SUB_PTR (UINT8, Subtable->Buffer,
                            sizeof (ACPI_ASF_HEADER)))->Devices;
            break;
 
        default:
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
            return (AE_ERROR);
        }
 
        if (DataInfoTable)
        {
            switch (AsfTable->Header.Type & 0x7F)
            {
            case ACPI_ASF_TYPE_ADDRESS:
 
                while (DataCount > 0)
                {
                    Status = DtCompileTable (PFieldList, DataInfoTable,
                                &Subtable, TRUE);
                    if (ACPI_FAILURE (Status))
                    {
                        return (Status);
                    }
 
                    DtInsertSubtable (ParentTable, Subtable);
                    DataCount = DataCount - Subtable->Length;
                }
                break;
 
            default:
 
                for (i = 0; i < DataCount; i++)
                {
                    Status = DtCompileTable (PFieldList, DataInfoTable,
                                &Subtable, TRUE);
                    if (ACPI_FAILURE (Status))
                    {
                        return (Status);
                    }
 
                    DtInsertSubtable (ParentTable, Subtable);
                }
                break;
            }
        }
 
        DtPopSubtable ();
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileCpep
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile CPEP.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileCpep (
    void                    **List)
{
    ACPI_STATUS             Status;
 
 
    Status = DtCompileTwoSubtables (List,
                 AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0);
    return (Status);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileDmar
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile DMAR.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileDmar (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *SubtableStart;
    ACPI_DMTABLE_INFO       *InfoTable;
    ACPI_DMAR_HEADER        *DmarHeader;
    UINT8                   *ReservedBuffer;
    UINT32                  ReservedSize;
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    /* DMAR Reserved area */
 
    ReservedSize = (UINT32) sizeof (((ACPI_TABLE_DMAR *) NULL)->Reserved);
    ReservedBuffer = UtLocalCalloc (ReservedSize);
 
    DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable);
 
    ACPI_FREE (ReservedBuffer);
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    while (*PFieldList)
    {
        /* DMAR Header */
 
        SubtableStart = *PFieldList;
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarHdr,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPushSubtable (Subtable);
 
        DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer);
 
        switch (DmarHeader->Type)
        {
        case ACPI_DMAR_TYPE_HARDWARE_UNIT:
            InfoTable = AcpiDmTableInfoDmar0;
            break;
        case ACPI_DMAR_TYPE_RESERVED_MEMORY:
            InfoTable = AcpiDmTableInfoDmar1;
            break;
        case ACPI_DMAR_TYPE_ATSR:
            InfoTable = AcpiDmTableInfoDmar2;
            break;
        case ACPI_DMAR_HARDWARE_AFFINITY:
            InfoTable = AcpiDmTableInfoDmar3;
            break;
        default:
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "DMAR");
            return (AE_ERROR);
        }
 
        /* DMAR Subtable */
 
        Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
 
        /* Optional Device Scope subtables */
 
        while (*PFieldList)
        {
            Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope,
                        &Subtable, FALSE);
            if (Status == AE_NOT_FOUND)
            {
                break;
            }
 
            ParentTable = DtPeekSubtable ();
            DtInsertSubtable (ParentTable, Subtable);
            DtPushSubtable (Subtable);
 
            /* Optional PCI Paths */
 
            while (*PFieldList)
            {
                Status = DtCompileTable (PFieldList, TableInfoDmarPciPath,
                            &Subtable, FALSE);
                if (Status == AE_NOT_FOUND)
                {
                    DtPopSubtable ();
                    break;
                }
 
                ParentTable = DtPeekSubtable ();
                DtInsertSubtable (ParentTable, Subtable);
            }
        }
 
        DtPopSubtable ();
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileEinj
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile EINJ.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileEinj (
    void                    **List)
{
    ACPI_STATUS             Status;
 
 
    Status = DtCompileTwoSubtables (List,
                 AcpiDmTableInfoEinj, AcpiDmTableInfoEinj0);
    return (Status);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileErst
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile ERST.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileErst (
    void                    **List)
{
    ACPI_STATUS             Status;
 
 
    Status = DtCompileTwoSubtables (List,
                 AcpiDmTableInfoErst, AcpiDmTableInfoEinj0);
    return (Status);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileFadt
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile FADT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileFadt (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    ACPI_TABLE_HEADER       *Table;
    UINT8                   Revision;
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt1,
                &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer);
    Revision = Table->Revision;
 
    if (Revision == 2)
    {
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt2,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        DtInsertSubtable (ParentTable, Subtable);
    }
    else if (Revision >= 2)
    {
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt3,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        DtInsertSubtable (ParentTable, Subtable);
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileHest
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile HEST.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileHest (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *SubtableStart;
    ACPI_DMTABLE_INFO       *InfoTable;
    UINT16                  Type;
    UINT32                  BankCount;
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest,
                &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    while (*PFieldList)
    {
        /* Get subtable type */
 
        SubtableStart = *PFieldList;
        DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0);
 
        switch (Type)
        {
        case ACPI_HEST_TYPE_IA32_CHECK:
            InfoTable = AcpiDmTableInfoHest0;
            break;
 
        case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
            InfoTable = AcpiDmTableInfoHest1;
            break;
 
        case ACPI_HEST_TYPE_IA32_NMI:
            InfoTable = AcpiDmTableInfoHest2;
            break;
 
        case ACPI_HEST_TYPE_AER_ROOT_PORT:
            InfoTable = AcpiDmTableInfoHest6;
            break;
 
        case ACPI_HEST_TYPE_AER_ENDPOINT:
            InfoTable = AcpiDmTableInfoHest7;
            break;
 
        case ACPI_HEST_TYPE_AER_BRIDGE:
            InfoTable = AcpiDmTableInfoHest8;
            break;
 
        case ACPI_HEST_TYPE_GENERIC_ERROR:
            InfoTable = AcpiDmTableInfoHest9;
            break;
 
        default:
            /* Cannot continue on unknown type */
 
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HEST");
            return (AE_ERROR);
        }
 
        Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        DtInsertSubtable (ParentTable, Subtable);
 
        /*
         * Additional subtable data - IA32 Error Bank(s)
         */
        BankCount = 0;
        switch (Type)
        {
        case ACPI_HEST_TYPE_IA32_CHECK:
            BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
                            Subtable->Buffer))->NumHardwareBanks;
            break;
 
        case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
            BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
                            Subtable->Buffer))->NumHardwareBanks;
            break;
 
        default:
            break;
        }
 
        while (BankCount)
        {
            Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank,
                        &Subtable, TRUE);
            if (ACPI_FAILURE (Status))
            {
                return (Status);
            }
 
            DtInsertSubtable (ParentTable, Subtable);
            BankCount--;
        }
    }
 
    return AE_OK;
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileIvrs
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile IVRS.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileIvrs (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *SubtableStart;
    ACPI_DMTABLE_INFO       *InfoTable;
    ACPI_IVRS_HEADER        *IvrsHeader;
    UINT8                   EntryType;
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs,
                &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    while (*PFieldList)
    {
        SubtableStart = *PFieldList;
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHdr,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPushSubtable (Subtable);
 
        IvrsHeader = ACPI_CAST_PTR (ACPI_IVRS_HEADER, Subtable->Buffer);
 
        switch (IvrsHeader->Type)
        {
        case ACPI_IVRS_TYPE_HARDWARE:
            InfoTable = AcpiDmTableInfoIvrs0;
            break;
 
        case ACPI_IVRS_TYPE_MEMORY1:
        case ACPI_IVRS_TYPE_MEMORY2:
        case ACPI_IVRS_TYPE_MEMORY3:
            InfoTable = AcpiDmTableInfoIvrs1;
            break;
 
        default:
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IVRS");
            return (AE_ERROR);
        }
 
        Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
 
        if (IvrsHeader->Type == ACPI_IVRS_TYPE_HARDWARE)
        {
            while (*PFieldList &&
                    !ACPI_STRCMP ((*PFieldList)->Name, "Entry Type"))
            {
                SubtableStart = *PFieldList;
                DtCompileInteger (&EntryType, *PFieldList, 1, 0);
 
                switch (EntryType)
                {
                /* 4-byte device entries */
 
                case ACPI_IVRS_TYPE_PAD4:
                case ACPI_IVRS_TYPE_ALL:
                case ACPI_IVRS_TYPE_SELECT:
                case ACPI_IVRS_TYPE_START:
                case ACPI_IVRS_TYPE_END:
 
                    InfoTable = AcpiDmTableInfoIvrs4;
                    break;
 
                /* 8-byte entries, type A */
 
                case ACPI_IVRS_TYPE_ALIAS_SELECT:
                case ACPI_IVRS_TYPE_ALIAS_START:
 
                    InfoTable = AcpiDmTableInfoIvrs8a;
                    break;
 
                /* 8-byte entries, type B */
 
                case ACPI_IVRS_TYPE_PAD8:
                case ACPI_IVRS_TYPE_EXT_SELECT:
                case ACPI_IVRS_TYPE_EXT_START:
 
                    InfoTable = AcpiDmTableInfoIvrs8b;
                    break;
 
                /* 8-byte entries, type C */
 
                case ACPI_IVRS_TYPE_SPECIAL:
 
                    InfoTable = AcpiDmTableInfoIvrs8c;
                    break;
 
                default:
                    DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart,
                        "IVRS Device Entry");
                    return (AE_ERROR);
                }
 
                Status = DtCompileTable (PFieldList, InfoTable,
                            &Subtable, TRUE);
                if (ACPI_FAILURE (Status))
                {
                    return (Status);
                }
 
                DtInsertSubtable (ParentTable, Subtable);
            }
        }
 
        DtPopSubtable ();
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileMadt
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile MADT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileMadt (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *SubtableStart;
    ACPI_SUBTABLE_HEADER    *MadtHeader;
    ACPI_DMTABLE_INFO       *InfoTable;
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt,
                &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    while (*PFieldList)
    {
        SubtableStart = *PFieldList;
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPushSubtable (Subtable);
 
        MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
 
        switch (MadtHeader->Type)
        {
        case ACPI_MADT_TYPE_LOCAL_APIC:
            InfoTable = AcpiDmTableInfoMadt0;
            break;
        case ACPI_MADT_TYPE_IO_APIC:
            InfoTable = AcpiDmTableInfoMadt1;
            break;
        case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
            InfoTable = AcpiDmTableInfoMadt2;
            break;
        case ACPI_MADT_TYPE_NMI_SOURCE:
            InfoTable = AcpiDmTableInfoMadt3;
            break;
        case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
            InfoTable = AcpiDmTableInfoMadt4;
            break;
        case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
            InfoTable = AcpiDmTableInfoMadt5;
            break;
        case ACPI_MADT_TYPE_IO_SAPIC:
            InfoTable = AcpiDmTableInfoMadt6;
            break;
        case ACPI_MADT_TYPE_LOCAL_SAPIC:
            InfoTable = AcpiDmTableInfoMadt7;
            break;
        case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
            InfoTable = AcpiDmTableInfoMadt8;
            break;
        case ACPI_MADT_TYPE_LOCAL_X2APIC:
            InfoTable = AcpiDmTableInfoMadt9;
            break;
        case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
            InfoTable = AcpiDmTableInfoMadt10;
            break;
        default:
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT");
            return (AE_ERROR);
        }
 
        Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPopSubtable ();
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileMcfg
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile MCFG.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileMcfg (
    void                    **List)
{
    ACPI_STATUS             Status;
 
 
    Status = DtCompileTwoSubtables (List,
                 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0);
    return (Status);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileMsct
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile MSCT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileMsct (
    void                    **List)
{
    ACPI_STATUS             Status;
 
 
    Status = DtCompileTwoSubtables (List,
                 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0);
    return (Status);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileRsdt
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile RSDT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileRsdt (
    void                    **List)
{
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                *FieldList = *(DT_FIELD **) List;
    UINT32                  Address;
 
 
    ParentTable = DtPeekSubtable ();
 
    while (FieldList)
    {
        DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO);
 
        DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable);
        DtInsertSubtable (ParentTable, Subtable);
        FieldList = FieldList->Next;
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileSlic
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile SLIC.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileSlic (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *SubtableStart;
    ACPI_SLIC_HEADER        *SlicHeader;
    ACPI_DMTABLE_INFO       *InfoTable;
 
 
    while (*PFieldList)
    {
        SubtableStart = *PFieldList;
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlicHdr,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPushSubtable (Subtable);
 
        SlicHeader = ACPI_CAST_PTR (ACPI_SLIC_HEADER, Subtable->Buffer);
 
        switch (SlicHeader->Type)
        {
        case ACPI_SLIC_TYPE_PUBLIC_KEY:
            InfoTable = AcpiDmTableInfoSlic0;
            break;
        case ACPI_SLIC_TYPE_WINDOWS_MARKER:
            InfoTable = AcpiDmTableInfoSlic1;
            break;
        default:
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SLIC");
            return (AE_ERROR);
        }
 
        Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPopSubtable ();
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileSlit
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile SLIT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileSlit (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *FieldList;
    UINT32                  Localities;
    UINT8                   *LocalityBuffer;
 
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
                &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
    LocalityBuffer = UtLocalCalloc (Localities);
 
    /* Compile each locality buffer */
 
    FieldList = *PFieldList;
    while (FieldList)
    {
 
 
        DtCompileBuffer (LocalityBuffer,
 
 
 
 
            FieldList->Value, FieldList, Localities);
 
 
 
        DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
        DtInsertSubtable (ParentTable, Subtable);
        FieldList = FieldList->Next;
    }
 
    ACPI_FREE (LocalityBuffer);
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileSrat
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile SRAT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileSrat (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    DT_FIELD                *SubtableStart;
    ACPI_SUBTABLE_HEADER    *SratHeader;
    ACPI_DMTABLE_INFO       *InfoTable;
 
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
                &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    while (*PFieldList)
    {
        SubtableStart = *PFieldList;
        Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
                    &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPushSubtable (Subtable);
 
        SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
 
        switch (SratHeader->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;
        default:
            DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
            return (AE_ERROR);
        }
 
        Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
 
        ParentTable = DtPeekSubtable ();
        DtInsertSubtable (ParentTable, Subtable);
        DtPopSubtable ();
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtGetGenericTableInfo
 *
 * PARAMETERS:  Name                - Generic type name
 *
 * RETURN:      Info entry
 *
 * DESCRIPTION: Obtain table info for a generic name entry
 *
 *****************************************************************************/
 
ACPI_DMTABLE_INFO *
DtGetGenericTableInfo (
    char                    *Name)
{
    ACPI_DMTABLE_INFO       *Info;
    UINT32                  i;
 
 
    if (!Name)
    {
        return (NULL);
    }
 
    /* Search info table for name match */
 
    for (i = 0; ; i++)
    {
        Info = AcpiDmTableInfoGeneric[i];
        if (Info->Opcode == ACPI_DMT_EXIT)
        {
            Info = NULL;
            break;
        }
 
        if (!ACPI_STRCMP (Name, Info->Name))
        {
            break;
        }
    }
 
    return (Info);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileUefi
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile UEFI.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileUefi (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    UINT16                  *DataOffset;
 
 
    /* Compile the predefined portion of the UEFI table */
 
    Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
                &Subtable, TRUE);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    DataOffset = (UINT16 *) (Subtable->Buffer + 16);
    *DataOffset = sizeof (ACPI_TABLE_UEFI);
 
    ParentTable = DtPeekSubtable ();
    DtInsertSubtable (ParentTable, Subtable);
 
    /*
     * Compile the "generic" portion of the UEFI table. This
     * part of the table is not predefined and any of the generic
     * operators may be used.
     */
 
    DtCompileGeneric ((void **) PFieldList);
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileWdat
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile WDAT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileWdat (
    void                    **List)
{
    ACPI_STATUS             Status;
 
 
    Status = DtCompileTwoSubtables (List,
                 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
    return (Status);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileXsdt
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile XSDT.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileXsdt (
    void                    **List)
{
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                *FieldList = *(DT_FIELD **) List;
    UINT64                  Address;
 
    ParentTable = DtPeekSubtable ();
 
    while (FieldList)
    {
        DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
 
        DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
        DtInsertSubtable (ParentTable, Subtable);
        FieldList = FieldList->Next;
    }
 
    return (AE_OK);
}
 
 
/******************************************************************************
 *
 * FUNCTION:    DtCompileGeneric
 *
 * PARAMETERS:  List                - Current field list pointer
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Compile generic unknown table.
 *
 *****************************************************************************/
 
ACPI_STATUS
DtCompileGeneric (
    void                    **List)
{
    ACPI_STATUS             Status;
    DT_SUBTABLE             *Subtable;
    DT_SUBTABLE             *ParentTable;
    DT_FIELD                **PFieldList = (DT_FIELD **) List;
    ACPI_DMTABLE_INFO       *Info;
 
 
    ParentTable = DtPeekSubtable ();
 
    /*
     * Compile the "generic" portion of the table. This
     * part of the table is not predefined and any of the generic
     * operators may be used.
     */
 
    /* Find any and all labels in the entire generic portion */
 
    DtDetectAllLabels (*PFieldList);
 
    /* Now we can actually compile the parse tree */
 
    while (*PFieldList)
    {
        Info = DtGetGenericTableInfo ((*PFieldList)->Name);
        if (!Info)
        {
            sprintf (MsgBuffer, "Generic data type \"%s\" not found",
                (*PFieldList)->Name);
            DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
                (*PFieldList), MsgBuffer);
 
            *PFieldList = (*PFieldList)->Next;
            continue;
        }
 
        Status = DtCompileTable (PFieldList, Info,
                    &Subtable, TRUE);
        if (ACPI_SUCCESS (Status))
        {
            DtInsertSubtable (ParentTable, Subtable);
        }
        else
        {
            *PFieldList = (*PFieldList)->Next;
 
            if (Status == AE_NOT_FOUND)
            {
                sprintf (MsgBuffer, "Generic data type \"%s\" not found",
                    (*PFieldList)->Name);
                DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
                    (*PFieldList), MsgBuffer);
            }
        }
    }
 
    return (AE_OK);
}

Rev 1498	Rev 2216
1	/******************************************************************************	1	/******************************************************************************
2	*	2	*
3	* Module Name: dttable.c - handling for specific ACPI tables	3	* Module Name: dttable.c - handling for specific ACPI tables
4	*	4	*
5	*****************************************************************************/	5	*****************************************************************************/
6		6
7	/******************************************************************************	7	/******************************************************************************
8	*	8	*
9	* 1. Copyright Notice	9	* 1. Copyright Notice
10	*	10	*
11	* Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.	11	* Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
12	* All rights reserved.	12	* All rights reserved.
13	*	13	*
14	* 2. License	14	* 2. License
15	*	15	*
16	* 2.1. This is your license from Intel Corp. under its intellectual property	16	* 2.1. This is your license from Intel Corp. under its intellectual property
17	* rights. You may have additional license terms from the party that provided	17	* rights. You may have additional license terms from the party that provided
18	* you this software, covering your right to use that party's intellectual	18	* you this software, covering your right to use that party's intellectual
19	* property rights.	19	* property rights.
20	*	20	*
21	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a	21	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22	* copy of the source code appearing in this file ("Covered Code") an	22	* copy of the source code appearing in this file ("Covered Code") an
23	* irrevocable, perpetual, worldwide license under Intel's copyrights in the	23	* irrevocable, perpetual, worldwide license under Intel's copyrights in the
24	* base code distributed originally by Intel ("Original Intel Code") to copy,	24	* base code distributed originally by Intel ("Original Intel Code") to copy,
25	* make derivatives, distribute, use and display any portion of the Covered	25	* make derivatives, distribute, use and display any portion of the Covered
26	* Code in any form, with the right to sublicense such rights; and	26	* Code in any form, with the right to sublicense such rights; and
27	*	27	*
28	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent	28	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29	* license (with the right to sublicense), under only those claims of Intel	29	* license (with the right to sublicense), under only those claims of Intel
30	* patents that are infringed by the Original Intel Code, to make, use, sell,	30	* patents that are infringed by the Original Intel Code, to make, use, sell,
31	* offer to sell, and import the Covered Code and derivative works thereof	31	* offer to sell, and import the Covered Code and derivative works thereof
32	* solely to the minimum extent necessary to exercise the above copyright	32	* solely to the minimum extent necessary to exercise the above copyright
33	* license, and in no event shall the patent license extend to any additions	33	* license, and in no event shall the patent license extend to any additions
34	* to or modifications of the Original Intel Code. No other license or right	34	* to or modifications of the Original Intel Code. No other license or right
35	* is granted directly or by implication, estoppel or otherwise;	35	* is granted directly or by implication, estoppel or otherwise;
36	*	36	*
37	* The above copyright and patent license is granted only if the following	37	* The above copyright and patent license is granted only if the following
38	* conditions are met:	38	* conditions are met:
39	*	39	*
40	* 3. Conditions	40	* 3. Conditions
41	*	41	*
42	* 3.1. Redistribution of Source with Rights to Further Distribute Source.	42	* 3.1. Redistribution of Source with Rights to Further Distribute Source.
43	* Redistribution of source code of any substantial portion of the Covered	43	* Redistribution of source code of any substantial portion of the Covered
44	* Code or modification with rights to further distribute source must include	44	* Code or modification with rights to further distribute source must include
45	* the above Copyright Notice, the above License, this list of Conditions,	45	* the above Copyright Notice, the above License, this list of Conditions,
46	* and the following Disclaimer and Export Compliance provision. In addition,	46	* and the following Disclaimer and Export Compliance provision. In addition,
47	* Licensee must cause all Covered Code to which Licensee contributes to	47	* Licensee must cause all Covered Code to which Licensee contributes to
48	* contain a file documenting the changes Licensee made to create that Covered	48	* contain a file documenting the changes Licensee made to create that Covered
49	* Code and the date of any change. Licensee must include in that file the	49	* Code and the date of any change. Licensee must include in that file the
50	* documentation of any changes made by any predecessor Licensee. Licensee	50	* documentation of any changes made by any predecessor Licensee. Licensee
51	* must include a prominent statement that the modification is derived,	51	* must include a prominent statement that the modification is derived,
52	* directly or indirectly, from Original Intel Code.	52	* directly or indirectly, from Original Intel Code.
53	*	53	*
54	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.	54	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55	* Redistribution of source code of any substantial portion of the Covered	55	* Redistribution of source code of any substantial portion of the Covered
56	* Code or modification without rights to further distribute source must	56	* Code or modification without rights to further distribute source must
57	* include the following Disclaimer and Export Compliance provision in the	57	* include the following Disclaimer and Export Compliance provision in the
58	* documentation and/or other materials provided with distribution. In	58	* documentation and/or other materials provided with distribution. In
59	* addition, Licensee may not authorize further sublicense of source of any	59	* addition, Licensee may not authorize further sublicense of source of any
60	* portion of the Covered Code, and must include terms to the effect that the	60	* portion of the Covered Code, and must include terms to the effect that the
61	* license from Licensee to its licensee is limited to the intellectual	61	* license from Licensee to its licensee is limited to the intellectual
62	* property embodied in the software Licensee provides to its licensee, and	62	* property embodied in the software Licensee provides to its licensee, and
63	* not to intellectual property embodied in modifications its licensee may	63	* not to intellectual property embodied in modifications its licensee may
64	* make.	64	* make.
65	*	65	*
66	* 3.3. Redistribution of Executable. Redistribution in executable form of any	66	* 3.3. Redistribution of Executable. Redistribution in executable form of any
67	* substantial portion of the Covered Code or modification must reproduce the	67	* substantial portion of the Covered Code or modification must reproduce the
68	* above Copyright Notice, and the following Disclaimer and Export Compliance	68	* above Copyright Notice, and the following Disclaimer and Export Compliance
69	* provision in the documentation and/or other materials provided with the	69	* provision in the documentation and/or other materials provided with the
70	* distribution.	70	* distribution.
71	*	71	*
72	* 3.4. Intel retains all right, title, and interest in and to the Original	72	* 3.4. Intel retains all right, title, and interest in and to the Original
73	* Intel Code.	73	* Intel Code.
74	*	74	*
75	* 3.5. Neither the name Intel nor any other trademark owned or controlled by	75	* 3.5. Neither the name Intel nor any other trademark owned or controlled by
76	* Intel shall be used in advertising or otherwise to promote the sale, use or	76	* Intel shall be used in advertising or otherwise to promote the sale, use or
77	* other dealings in products derived from or relating to the Covered Code	77	* other dealings in products derived from or relating to the Covered Code
78	* without prior written authorization from Intel.	78	* without prior written authorization from Intel.
79	*	79	*
80	* 4. Disclaimer and Export Compliance	80	* 4. Disclaimer and Export Compliance
81	*	81	*
82	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED	82	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE	83	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,	84	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY	85	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY	86	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A	87	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88	* PARTICULAR PURPOSE.	88	* PARTICULAR PURPOSE.
89	*	89	*
90	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES	90	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR	91	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,	92	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY	93	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL	94	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS	95	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY	96	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97	* LIMITED REMEDY.	97	* LIMITED REMEDY.
98	*	98	*
99	* 4.3. Licensee shall not export, either directly or indirectly, any of this	99	* 4.3. Licensee shall not export, either directly or indirectly, any of this
100	* software or system incorporating such software without first obtaining any	100	* software or system incorporating such software without first obtaining any
101	* required license or other approval from the U. S. Department of Commerce or	101	* required license or other approval from the U. S. Department of Commerce or
102	* any other agency or department of the United States Government. In the	102	* any other agency or department of the United States Government. In the
103	* event Licensee exports any such software from the United States or	103	* event Licensee exports any such software from the United States or
104	* re-exports any such software from a foreign destination, Licensee shall	104	* re-exports any such software from a foreign destination, Licensee shall
105	* ensure that the distribution and export/re-export of the software is in	105	* ensure that the distribution and export/re-export of the software is in
106	* compliance with all laws, regulations, orders, or other restrictions of the	106	* compliance with all laws, regulations, orders, or other restrictions of the
107	* U.S. Export Administration Regulations. Licensee agrees that neither it nor	107	* U.S. Export Administration Regulations. Licensee agrees that neither it nor
108	* any of its subsidiaries will export/re-export any technical data, process,	108	* any of its subsidiaries will export/re-export any technical data, process,
109	* software, or service, directly or indirectly, to any country for which the	109	* software, or service, directly or indirectly, to any country for which the
110	* United States government or any agency thereof requires an export license,	110	* United States government or any agency thereof requires an export license,
111	* other governmental approval, or letter of assurance, without first obtaining	111	* other governmental approval, or letter of assurance, without first obtaining
112	* such license, approval or letter.	112	* such license, approval or letter.
113	*	113	*
114	*****************************************************************************/	114	*****************************************************************************/
115		115
116	#define __DTTABLE_C__	116	#define __DTTABLE_C__
117		117
118	/* Compile all complex data tables */	118	/* Compile all complex data tables */
119		119
120	#include "aslcompiler.h"	120	#include "aslcompiler.h"
121	#include "dtcompiler.h"	121	#include "dtcompiler.h"
122		122
123	#define _COMPONENT DT_COMPILER	123	#define _COMPONENT DT_COMPILER
124	ACPI_MODULE_NAME ("dttable")	124	ACPI_MODULE_NAME ("dttable")
125		125
126		126
127	/* TBD: merge these into dmtbinfo.c? */	127	/* TBD: merge these into dmtbinfo.c? */
128		128
129	static ACPI_DMTABLE_INFO TableInfoAsfAddress[] =	129	static ACPI_DMTABLE_INFO TableInfoAsfAddress[] =
130	{	130	{
131	{ACPI_DMT_BUFFER, 0, "Addresses", 0},	131	{ACPI_DMT_BUFFER, 0, "Addresses", 0},
132	{ACPI_DMT_EXIT, 0, NULL, 0}	132	{ACPI_DMT_EXIT, 0, NULL, 0}
133	};	133	};
134		134
135	static ACPI_DMTABLE_INFO TableInfoDmarPciPath[] =	135	static ACPI_DMTABLE_INFO TableInfoDmarPciPath[] =
136	{	136	{
137	{ACPI_DMT_PCI_PATH, 0, "PCI Path", 0},	137	{ACPI_DMT_PCI_PATH, 0, "PCI Path", 0},
138	{ACPI_DMT_EXIT, 0, NULL, 0}	138	{ACPI_DMT_EXIT, 0, NULL, 0}
139	};	139	};
140		140
141		141
142	/* TBD: move to acmacros.h */	142	/* TBD: move to acmacros.h */
143		143
144	#define ACPI_SUB_PTR(t, a, b) \	144	#define ACPI_SUB_PTR(t, a, b) \
145	ACPI_CAST_PTR (t, (ACPI_CAST_PTR (UINT8, (a)) - (ACPI_SIZE)(b)))	145	ACPI_CAST_PTR (t, (ACPI_CAST_PTR (UINT8, (a)) - (ACPI_SIZE)(b)))
146		146
147		147
148	/* Local prototypes */	148	/* Local prototypes */
149		149
150	static ACPI_STATUS	150	static ACPI_STATUS
151	DtCompileTwoSubtables (	151	DtCompileTwoSubtables (
152	void **List,	152	void **List,
153	ACPI_DMTABLE_INFO *TableInfo1,	153	ACPI_DMTABLE_INFO *TableInfo1,
154	ACPI_DMTABLE_INFO *TableInfo2);	154	ACPI_DMTABLE_INFO *TableInfo2);
155		155
156		156
157	/******************************************************************************	157	/******************************************************************************
158	*	158	*
159	* FUNCTION: DtCompileTwoSubtables	159	* FUNCTION: DtCompileTwoSubtables
160	*	160	*
161	* PARAMETERS: List - Current field list pointer	161	* PARAMETERS: List - Current field list pointer
162	* TableInfo1 - Info table 1	162	* TableInfo1 - Info table 1
163	* TableInfo1 - Info table 2	163	* TableInfo1 - Info table 2
164	*	164	*
165	* RETURN: Status	165	* RETURN: Status
166	*	166	*
167	* DESCRIPTION: Compile tables with a header and one or more same subtables.	167	* DESCRIPTION: Compile tables with a header and one or more same subtables.
168	* Include CPEP, EINJ, ERST, MCFG, MSCT, WDAT	168	* Include CPEP, EINJ, ERST, MCFG, MSCT, WDAT
169	*	169	*
170	*****************************************************************************/	170	*****************************************************************************/
171		171
172	static ACPI_STATUS	172	static ACPI_STATUS
173	DtCompileTwoSubtables (	173	DtCompileTwoSubtables (
174	void **List,	174	void **List,
175	ACPI_DMTABLE_INFO *TableInfo1,	175	ACPI_DMTABLE_INFO *TableInfo1,
176	ACPI_DMTABLE_INFO *TableInfo2)	176	ACPI_DMTABLE_INFO *TableInfo2)
177	{	177	{
178	ACPI_STATUS Status;	178	ACPI_STATUS Status;
179	DT_SUBTABLE *Subtable;	179	DT_SUBTABLE *Subtable;
180	DT_SUBTABLE *ParentTable;	180	DT_SUBTABLE *ParentTable;
181	DT_FIELD PFieldList = (DT_FIELD ) List;	181	DT_FIELD PFieldList = (DT_FIELD ) List;
182		182
183		183
184	Status = DtCompileTable (PFieldList, TableInfo1, &Subtable, TRUE);	184	Status = DtCompileTable (PFieldList, TableInfo1, &Subtable, TRUE);
185	if (ACPI_FAILURE (Status))	185	if (ACPI_FAILURE (Status))
186	{	186	{
187	return (Status);	187	return (Status);
188	}	188	}
189		189
190	ParentTable = DtPeekSubtable ();	190	ParentTable = DtPeekSubtable ();
191	DtInsertSubtable (ParentTable, Subtable);	191	DtInsertSubtable (ParentTable, Subtable);
192		192
193	while (*PFieldList)	193	while (*PFieldList)
194	{	194	{
195	Status = DtCompileTable (PFieldList, TableInfo2, &Subtable, FALSE);	195	Status = DtCompileTable (PFieldList, TableInfo2, &Subtable, FALSE);
196	if (ACPI_FAILURE (Status))	196	if (ACPI_FAILURE (Status))
197	{	197	{
198	return (Status);	198	return (Status);
199	}	199	}
200		200
201	DtInsertSubtable (ParentTable, Subtable);	201	DtInsertSubtable (ParentTable, Subtable);
202	}	202	}
203		203
204	return (AE_OK);	204	return (AE_OK);
205	}	205	}
206		206
207		207
208	/******************************************************************************	208	/******************************************************************************
209	*	209	*
210	* FUNCTION: DtCompileFacs	210	* FUNCTION: DtCompileFacs
211	*	211	*
212	* PARAMETERS: PFieldList - Current field list pointer	212	* PARAMETERS: PFieldList - Current field list pointer
213	*	213	*
214	* RETURN: Status	214	* RETURN: Status
215	*	215	*
216	* DESCRIPTION: Compile FACS.	216	* DESCRIPTION: Compile FACS.
217	*	217	*
218	*****************************************************************************/	218	*****************************************************************************/
219		219
220	ACPI_STATUS	220	ACPI_STATUS
221	DtCompileFacs (	221	DtCompileFacs (
222	DT_FIELD **PFieldList)	222	DT_FIELD **PFieldList)
223	{	223	{
224	DT_SUBTABLE *Subtable;	224	DT_SUBTABLE *Subtable;
225	UINT8 *ReservedBuffer;	225	UINT8 *ReservedBuffer;
226	ACPI_STATUS Status;	226	ACPI_STATUS Status;
227	UINT32 ReservedSize;	227	UINT32 ReservedSize;
228		228
229		229
230	Status = DtCompileTable (PFieldList, AcpiDmTableInfoFacs,	230	Status = DtCompileTable (PFieldList, AcpiDmTableInfoFacs,
231	&Gbl_RootTable, TRUE);	231	&Gbl_RootTable, TRUE);
232	if (ACPI_FAILURE (Status))	232	if (ACPI_FAILURE (Status))
233	{	233	{
234	return (Status);	234	return (Status);
235	}	235	}
236		236
237	/* Large FACS reserved area at the end of the table */	237	/* Large FACS reserved area at the end of the table */
238		238
239	ReservedSize = (UINT32) sizeof (((ACPI_TABLE_FACS *) NULL)->Reserved1);	239	ReservedSize = (UINT32) sizeof (((ACPI_TABLE_FACS *) NULL)->Reserved1);
240	ReservedBuffer = UtLocalCalloc (ReservedSize);	240	ReservedBuffer = UtLocalCalloc (ReservedSize);
241		241
242	DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable);	242	DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable);
243		243
244	ACPI_FREE (ReservedBuffer);	244	ACPI_FREE (ReservedBuffer);
245	DtInsertSubtable (Gbl_RootTable, Subtable);	245	DtInsertSubtable (Gbl_RootTable, Subtable);
246	return (AE_OK);	246	return (AE_OK);
247	}	247	}
248		248
249		249
250	/******************************************************************************	250	/******************************************************************************
251	*	251	*
252	* FUNCTION: DtCompileRsdp	252	* FUNCTION: DtCompileRsdp
253	*	253	*
254	* PARAMETERS: PFieldList - Current field list pointer	254	* PARAMETERS: PFieldList - Current field list pointer
255	*	255	*
256	* RETURN: Status	256	* RETURN: Status
257	*	257	*
258	* DESCRIPTION: Compile RSDP.	258	* DESCRIPTION: Compile RSDP.
259	*	259	*
260	*****************************************************************************/	260	*****************************************************************************/
261		261
262	ACPI_STATUS	262	ACPI_STATUS
263	DtCompileRsdp (	263	DtCompileRsdp (
264	DT_FIELD **PFieldList)	264	DT_FIELD **PFieldList)
265	{	265	{
266	DT_SUBTABLE *Subtable;	266	DT_SUBTABLE *Subtable;
267	ACPI_TABLE_RSDP *Table;	267	ACPI_TABLE_RSDP *Rsdp;
-		268	ACPI_RSDP_EXTENSION *RsdpExtension;
268	ACPI_STATUS Status;	269	ACPI_STATUS Status;
269		270
-		271
-		272	/* Compile the "common" RSDP (ACPI 1.0) */
270		273
271	Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp1,	274	Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp1,
272	&Gbl_RootTable, TRUE);	275	&Gbl_RootTable, TRUE);
273	if (ACPI_FAILURE (Status))	276	if (ACPI_FAILURE (Status))
274	{	277	{
275	return (Status);	278	return (Status);
276	}	279	}
277		280
278	Table = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Gbl_RootTable->Buffer);	281	Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Gbl_RootTable->Buffer);
279	DtSetTableChecksum (&Table->Checksum);	282	DtSetTableChecksum (&Rsdp->Checksum);
280		283
-		284	if (Rsdp->Revision > 0)
-		285	{
281	if (Table->Revision > 0)	286	/* Compile the "extended" part of the RSDP as a subtable */
282	{	287
283	Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp2,	288	Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp2,
284	&Subtable, TRUE);	289	&Subtable, TRUE);
285	if (ACPI_FAILURE (Status))	290	if (ACPI_FAILURE (Status))
286	{	291	{
287	return (Status);	292	return (Status);
288	}	293	}
289		294
290	DtInsertSubtable (Gbl_RootTable, Subtable);	295	DtInsertSubtable (Gbl_RootTable, Subtable);
-		296
-		297	/* Set length and extended checksum for entire RSDP */
-		298
-		299	RsdpExtension = ACPI_CAST_PTR (ACPI_RSDP_EXTENSION, Subtable->Buffer);
-		300	RsdpExtension->Length = Gbl_RootTable->Length + Subtable->Length;
291	DtSetTableChecksum (&Table->ExtendedChecksum);	301	DtSetTableChecksum (&RsdpExtension->ExtendedChecksum);
292	}	302	}
293		303
294	return (AE_OK);	304	return (AE_OK);
295	}	305	}
296		306
297		307
298	/******************************************************************************	308	/******************************************************************************
299	*	309	*
300	* FUNCTION: DtCompileAsf	310	* FUNCTION: DtCompileAsf
301	*	311	*
302	* PARAMETERS: List - Current field list pointer	312	* PARAMETERS: List - Current field list pointer
303	*	313	*
304	* RETURN: Status	314	* RETURN: Status
305	*	315	*
306	* DESCRIPTION: Compile ASF!.	316	* DESCRIPTION: Compile ASF!.
307	*	317	*
308	*****************************************************************************/	318	*****************************************************************************/
309		319
310	ACPI_STATUS	320	ACPI_STATUS
311	DtCompileAsf (	321	DtCompileAsf (
312	void **List)	322	void **List)
313	{	323	{
314	ACPI_ASF_INFO *AsfTable;	324	ACPI_ASF_INFO *AsfTable;
315	DT_SUBTABLE *Subtable;	325	DT_SUBTABLE *Subtable;
316	DT_SUBTABLE *ParentTable;	326	DT_SUBTABLE *ParentTable;
317	ACPI_DMTABLE_INFO *InfoTable;	327	ACPI_DMTABLE_INFO *InfoTable;
318	ACPI_DMTABLE_INFO *DataInfoTable = NULL;	328	ACPI_DMTABLE_INFO *DataInfoTable = NULL;
319	UINT32 DataCount = 0;	329	UINT32 DataCount = 0;
320	ACPI_STATUS Status;	330	ACPI_STATUS Status;
321	UINT32 i;	331	UINT32 i;
322	DT_FIELD PFieldList = (DT_FIELD ) List;	332	DT_FIELD PFieldList = (DT_FIELD ) List;
323	DT_FIELD *SubtableStart;	333	DT_FIELD *SubtableStart;
324		334
325		335
326	while (*PFieldList)	336	while (*PFieldList)
327	{	337	{
328	SubtableStart = *PFieldList;	338	SubtableStart = *PFieldList;
329	Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr,	339	Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr,
330	&Subtable, TRUE);	340	&Subtable, TRUE);
331	if (ACPI_FAILURE (Status))	341	if (ACPI_FAILURE (Status))
332	{	342	{
333	return (Status);	343	return (Status);
334	}	344	}
335		345
336	ParentTable = DtPeekSubtable ();	346	ParentTable = DtPeekSubtable ();
337	DtInsertSubtable (ParentTable, Subtable);	347	DtInsertSubtable (ParentTable, Subtable);
338	DtPushSubtable (Subtable);	348	DtPushSubtable (Subtable);
339		349
340	AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer);	350	AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer);
341		351
342	switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */	352	switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
343	{	353	{
344	case ACPI_ASF_TYPE_INFO:	354	case ACPI_ASF_TYPE_INFO:
345	InfoTable = AcpiDmTableInfoAsf0;	355	InfoTable = AcpiDmTableInfoAsf0;
346	break;	356	break;
347		357
348	case ACPI_ASF_TYPE_ALERT:	358	case ACPI_ASF_TYPE_ALERT:
349	InfoTable = AcpiDmTableInfoAsf1;	359	InfoTable = AcpiDmTableInfoAsf1;
350	break;	360	break;
351		361
352	case ACPI_ASF_TYPE_CONTROL:	362	case ACPI_ASF_TYPE_CONTROL:
353	InfoTable = AcpiDmTableInfoAsf2;	363	InfoTable = AcpiDmTableInfoAsf2;
354	break;	364	break;
355		365
356	case ACPI_ASF_TYPE_BOOT:	366	case ACPI_ASF_TYPE_BOOT:
357	InfoTable = AcpiDmTableInfoAsf3;	367	InfoTable = AcpiDmTableInfoAsf3;
358	break;	368	break;
359		369
360	case ACPI_ASF_TYPE_ADDRESS:	370	case ACPI_ASF_TYPE_ADDRESS:
361	InfoTable = AcpiDmTableInfoAsf4;	371	InfoTable = AcpiDmTableInfoAsf4;
362	break;	372	break;
363		373
364	default:	374	default:
365	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");	375	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
366	return (AE_ERROR);	376	return (AE_ERROR);
367	}	377	}
368		378
369	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);	379	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
370	if (ACPI_FAILURE (Status))	380	if (ACPI_FAILURE (Status))
371	{	381	{
372	return (Status);	382	return (Status);
373	}	383	}
374		384
375	ParentTable = DtPeekSubtable ();	385	ParentTable = DtPeekSubtable ();
376	DtInsertSubtable (ParentTable, Subtable);	386	DtInsertSubtable (ParentTable, Subtable);
377		387
378	switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */	388	switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
379	{	389	{
380	case ACPI_ASF_TYPE_INFO:	390	case ACPI_ASF_TYPE_INFO:
381	DataInfoTable = NULL;	391	DataInfoTable = NULL;
382	break;	392	break;
383		393
384	case ACPI_ASF_TYPE_ALERT:	394	case ACPI_ASF_TYPE_ALERT:
385	DataInfoTable = AcpiDmTableInfoAsf1a;	395	DataInfoTable = AcpiDmTableInfoAsf1a;
386	DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT,	396	DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT,
387	ACPI_SUB_PTR (UINT8, Subtable->Buffer,	397	ACPI_SUB_PTR (UINT8, Subtable->Buffer,
388	sizeof (ACPI_ASF_HEADER)))->Alerts;	398	sizeof (ACPI_ASF_HEADER)))->Alerts;
389	break;	399	break;
390		400
391	case ACPI_ASF_TYPE_CONTROL:	401	case ACPI_ASF_TYPE_CONTROL:
392	DataInfoTable = AcpiDmTableInfoAsf2a;	402	DataInfoTable = AcpiDmTableInfoAsf2a;
393	DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE,	403	DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE,
394	ACPI_SUB_PTR (UINT8, Subtable->Buffer,	404	ACPI_SUB_PTR (UINT8, Subtable->Buffer,
395	sizeof (ACPI_ASF_HEADER)))->Controls;	405	sizeof (ACPI_ASF_HEADER)))->Controls;
396	break;	406	break;
397		407
398	case ACPI_ASF_TYPE_BOOT:	408	case ACPI_ASF_TYPE_BOOT:
399	DataInfoTable = NULL;	409	DataInfoTable = NULL;
400	break;	410	break;
401		411
402	case ACPI_ASF_TYPE_ADDRESS:	412	case ACPI_ASF_TYPE_ADDRESS:
403	DataInfoTable = TableInfoAsfAddress;	413	DataInfoTable = TableInfoAsfAddress;
404	DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS,	414	DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS,
405	ACPI_SUB_PTR (UINT8, Subtable->Buffer,	415	ACPI_SUB_PTR (UINT8, Subtable->Buffer,
406	sizeof (ACPI_ASF_HEADER)))->Devices;	416	sizeof (ACPI_ASF_HEADER)))->Devices;
407	break;	417	break;
408		418
409	default:	419	default:
410	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");	420	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
411	return (AE_ERROR);	421	return (AE_ERROR);
412	}	422	}
413		423
414	if (DataInfoTable)	424	if (DataInfoTable)
415	{	425	{
416	switch (AsfTable->Header.Type & 0x7F)	426	switch (AsfTable->Header.Type & 0x7F)
417	{	427	{
418	case ACPI_ASF_TYPE_ADDRESS:	428	case ACPI_ASF_TYPE_ADDRESS:
419		429
420	while (DataCount > 0)	430	while (DataCount > 0)
421	{	431	{
422	Status = DtCompileTable (PFieldList, DataInfoTable,	432	Status = DtCompileTable (PFieldList, DataInfoTable,
423	&Subtable, TRUE);	433	&Subtable, TRUE);
424	if (ACPI_FAILURE (Status))	434	if (ACPI_FAILURE (Status))
425	{	435	{
426	return (Status);	436	return (Status);
427	}	437	}
428		438
429	DtInsertSubtable (ParentTable, Subtable);	439	DtInsertSubtable (ParentTable, Subtable);
430	DataCount = DataCount - Subtable->Length;	440	DataCount = DataCount - Subtable->Length;
431	}	441	}
432	break;	442	break;
433		443
434	default:	444	default:
435		445
436	for (i = 0; i < DataCount; i++)	446	for (i = 0; i < DataCount; i++)
437	{	447	{
438	Status = DtCompileTable (PFieldList, DataInfoTable,	448	Status = DtCompileTable (PFieldList, DataInfoTable,
439	&Subtable, TRUE);	449	&Subtable, TRUE);
440	if (ACPI_FAILURE (Status))	450	if (ACPI_FAILURE (Status))
441	{	451	{
442	return (Status);	452	return (Status);
443	}	453	}
444		454
445	DtInsertSubtable (ParentTable, Subtable);	455	DtInsertSubtable (ParentTable, Subtable);
446	}	456	}
447	break;	457	break;
448	}	458	}
449	}	459	}
450		460
451	DtPopSubtable ();	461	DtPopSubtable ();
452	}	462	}
453		463
454	return (AE_OK);	464	return (AE_OK);
455	}	465	}
456		466
457		467
458	/******************************************************************************	468	/******************************************************************************
459	*	469	*
460	* FUNCTION: DtCompileCpep	470	* FUNCTION: DtCompileCpep
461	*	471	*
462	* PARAMETERS: List - Current field list pointer	472	* PARAMETERS: List - Current field list pointer
463	*	473	*
464	* RETURN: Status	474	* RETURN: Status
465	*	475	*
466	* DESCRIPTION: Compile CPEP.	476	* DESCRIPTION: Compile CPEP.
467	*	477	*
468	*****************************************************************************/	478	*****************************************************************************/
469		479
470	ACPI_STATUS	480	ACPI_STATUS
471	DtCompileCpep (	481	DtCompileCpep (
472	void **List)	482	void **List)
473	{	483	{
474	ACPI_STATUS Status;	484	ACPI_STATUS Status;
475		485
476		486
477	Status = DtCompileTwoSubtables (List,	487	Status = DtCompileTwoSubtables (List,
478	AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0);	488	AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0);
479	return (Status);	489	return (Status);
480	}	490	}
481		491
482		492
483	/******************************************************************************	493	/******************************************************************************
484	*	494	*
485	* FUNCTION: DtCompileDmar	495	* FUNCTION: DtCompileDmar
486	*	496	*
487	* PARAMETERS: List - Current field list pointer	497	* PARAMETERS: List - Current field list pointer
488	*	498	*
489	* RETURN: Status	499	* RETURN: Status
490	*	500	*

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/compiler/dttable.c – Rev 1498 → 2216