/******************************************************************************

 *

 * Module Name: dmtbdump1 - Dump ACPI data tables that contain no AML code

 *

 *****************************************************************************/

/*

 * Copyright (C) 2000 - 2018, Intel Corp.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions, and the following disclaimer,

 *    without modification.

 * 2. Redistributions in binary form must reproduce at minimum a disclaimer

 *    substantially similar to the "NO WARRANTY" disclaimer below

 *    ("Disclaimer") and any redistribution must be conditioned upon

 *    including a substantially similar Disclaimer requirement for further

 *    binary redistribution.

 * 3. Neither the names of the above-listed copyright holders nor the names

 *    of any contributors may be used to endorse or promote products derived

 *    from this software without specific prior written permission.

 *

 * Alternatively, this software may be distributed under the terms of the

 * GNU General Public License ("GPL") version 2 as published by the Free

 * Software Foundation.

 *

 * NO WARRANTY

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGES.

 */

#include "acpi.h"

#include "accommon.h"

#include "acdisasm.h"

#include "actables.h"

/* This module used for application-level code only */

#define _COMPONENT          ACPI_CA_DISASSEMBLER

        ACPI_MODULE_NAME    ("dmtbdump1")

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpAsf

 *

 * PARAMETERS:  Table               - A ASF table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a ASF table

 *

 ******************************************************************************/

void

AcpiDmDumpAsf (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    UINT32                  Offset = sizeof (ACPI_TABLE_HEADER);

    ACPI_ASF_INFO           *Subtable;

    ACPI_DMTABLE_INFO       *InfoTable;

    ACPI_DMTABLE_INFO       *DataInfoTable = NULL;

    UINT8                   *DataTable = NULL;

    UINT32                  DataCount = 0;

    UINT32                  DataLength = 0;

    UINT32                  DataOffset = 0;

    UINT32                  i;

    UINT8                   Type;

    UINT32		    Len;

    UINT16		    SubLen;

    /* No main table, only subtables */

    ACPI_MOVE_32_TO_32(&Len, &Table->Length);

    Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);

    while (Offset < Len)

    {

        /* Common subtable header */

	ACPI_MOVE_16_TO_16(&SubLen, &Subtable->Header.Length);

        Status = AcpiDmDumpTable (Len, Offset, Subtable,

            SubLen, AcpiDmTableInfoAsfHdr);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* The actual type is the lower 7 bits of Type */

        Type = (UINT8) (Subtable->Header.Type & 0x7F);

        switch (Type)

        {

        case ACPI_ASF_TYPE_INFO:

            InfoTable = AcpiDmTableInfoAsf0;

            break;

        case ACPI_ASF_TYPE_ALERT:

            InfoTable = AcpiDmTableInfoAsf1;

            DataInfoTable = AcpiDmTableInfoAsf1a;

            DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT));

            DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts;

            DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength;

            DataOffset = Offset + sizeof (ACPI_ASF_ALERT);

            break;

        case ACPI_ASF_TYPE_CONTROL:

            InfoTable = AcpiDmTableInfoAsf2;

            DataInfoTable = AcpiDmTableInfoAsf2a;

            DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE));

            DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls;

            DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength;

            DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);

            break;

        case ACPI_ASF_TYPE_BOOT:

            InfoTable = AcpiDmTableInfoAsf3;

            break;

        case ACPI_ASF_TYPE_ADDRESS:

            InfoTable = AcpiDmTableInfoAsf4;

            DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS));

            DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices;

            DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);

            break;

        default:

            AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",

                Subtable->Header.Type);

            return;

        }

        Status = AcpiDmDumpTable (Len, Offset, Subtable, SubLen, InfoTable);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* Dump variable-length extra data */

        switch (Type)

        {

        case ACPI_ASF_TYPE_ALERT:

        case ACPI_ASF_TYPE_CONTROL:

            for (i = 0; i < DataCount; i++)

            {

                AcpiOsPrintf ("\n");

                Status = AcpiDmDumpTable (Len, DataOffset,

                    DataTable, DataLength, DataInfoTable);

                if (ACPI_FAILURE (Status))

                {

                    return;

                }

                DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);

                DataOffset += DataLength;

            }

            break;

        case ACPI_ASF_TYPE_ADDRESS:

            for (i = 0; i < DataLength; i++)

            {

                if (!(i % 16))

                {

                    AcpiDmLineHeader (DataOffset, 1, "Addresses");

                }

                AcpiOsPrintf ("%2.2X ", *DataTable);

                DataTable++;

                DataOffset++;

                if (DataOffset > Table->Length)

                {

                    AcpiOsPrintf (

                        "**** ACPI table terminates in the middle of a "

                        "data structure! (ASF! table)\n");

                    return;

                }

            }

            AcpiOsPrintf ("\n");

            break;

        default:

            break;

        }

        AcpiOsPrintf ("\n");

        /* Point to next subtable */

        if (!SubLen)

        {

            AcpiOsPrintf ("Invalid zero subtable header length\n");

            return;

        }

        Offset += SubLen;

        Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable, SubLen);

    }

}

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpCpep

 *

 * PARAMETERS:  Table               - A CPEP table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a CPEP. This table type consists

 *              of an open-ended number of subtables.

 *

 ******************************************************************************/

void

AcpiDmDumpCpep (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_CPEP_POLLING       *Subtable;

    UINT32                  Length;

    UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);

    /* Main table */

    ACPI_MOVE_32_TO_32(&Length, &Table->Length);

    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtables */

    Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);

    while (Offset < Length)

    {

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            Subtable->Header.Length, AcpiDmTableInfoCpep0);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* Point to next subtable */

        Offset += Subtable->Header.Length;

        Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable,

            Subtable->Header.Length);

    }

}

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpCsrt

 *

 * PARAMETERS:  Table               - A CSRT table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a CSRT. This table type consists

 *              of an open-ended number of subtables.

 *

 ******************************************************************************/

void

AcpiDmDumpCsrt (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_CSRT_GROUP         *Subtable;

    ACPI_CSRT_SHARED_INFO   *SharedInfoTable;

    ACPI_CSRT_DESCRIPTOR    *SubSubtable;

    UINT32                  Length;

    UINT32                  SubLength;

    UINT32                  SubSubLength;

    UINT32                  SharedInfoLength;

    UINT32                  Offset = sizeof (ACPI_TABLE_CSRT);

    UINT32                  SubOffset;

    UINT32                  SubSubOffset;

    UINT32                  InfoLength;

    /* The main table only contains the ACPI header, thus already handled */

    /* Subtables (Resource Groups) */

    ACPI_MOVE_32_TO_32(&Length, &Table->Length);

    Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);

    while (Offset < Length)

    {

        /* Resource group subtable */

        AcpiOsPrintf ("\n");

        ACPI_MOVE_32_TO_32(&SubLength, &Subtable->Length);

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            SubLength, AcpiDmTableInfoCsrt0);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* Shared info subtable (One per resource group) */

        SubOffset = sizeof (ACPI_CSRT_GROUP);

        SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,

            Offset + SubOffset);

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,

            sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

	ACPI_MOVE_32_TO_32(&SharedInfoLength, &Subtable->SharedInfoLength);

        SubOffset += SharedInfoLength;

        /* Sub-Subtables (Resource Descriptors) */

        SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,

            Offset + SubOffset);

        while ((SubOffset < SubLength) && ((Offset + SubOffset) < Length))

        {

            AcpiOsPrintf ("\n");

	    ACPI_MOVE_32_TO_32(&SubSubLength, &SubSubtable->Length);

            Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable,

                SubSubLength, AcpiDmTableInfoCsrt2);

            if (ACPI_FAILURE (Status))

            {

                return;

            }

            SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);

            /* Resource-specific info buffer */

            InfoLength = SubSubLength - SubSubOffset;

            if (InfoLength)

            {

                Status = AcpiDmDumpTable (Length,

                    Offset + SubOffset + SubSubOffset, Table,

                    InfoLength, AcpiDmTableInfoCsrt2a);

                if (ACPI_FAILURE (Status))

                {

                    return;

                }

                SubSubOffset += InfoLength;

            }

            /* Point to next sub-subtable */

            SubOffset += SubSubLength;

            SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable,

                SubSubLength);

        }

        /* Point to next subtable */

        Offset += SubLength;

        Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable, SubLength);

    }

}

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpDbg2

 *

 * PARAMETERS:  Table               - A DBG2 table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a DBG2. This table type consists

 *              of an open-ended number of subtables.

 *

 ******************************************************************************/

void

AcpiDmDumpDbg2 (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_DBG2_DEVICE        *Subtable;

    UINT32                  Length;

    UINT16                  SubLength;

    UINT32                  Offset = sizeof (ACPI_TABLE_DBG2);

    UINT32                  i;

    UINT32                  ArrayOffset;

    UINT32                  AbsoluteOffset;

    UINT8                   *Array;

    UINT16		    Tmp16;

    UINT16		    AlsoTmp16;

    /* Main table */

    ACPI_MOVE_32_TO_32(&Length, &Table->Length);

    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtables */

    Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);

    while (Offset < Length)

    {

        AcpiOsPrintf ("\n");

        ACPI_MOVE_16_TO_16(&SubLength, &Subtable->Length);

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            SubLength, AcpiDmTableInfoDbg2Device);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* Dump the BaseAddress array */

        for (i = 0; i < Subtable->RegisterCount; i++)

        {

	    ACPI_MOVE_16_TO_16(&Tmp16, &Subtable->BaseAddressOffset);

            ArrayOffset = Tmp16 + (sizeof (ACPI_GENERIC_ADDRESS) * i);

            AbsoluteOffset = Offset + ArrayOffset;

            Array = (UINT8 *) Subtable + ArrayOffset;

            Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,

                SubLength, AcpiDmTableInfoDbg2Addr);

            if (ACPI_FAILURE (Status))

            {

                return;

            }

        }

        /* Dump the AddressSize array */

        for (i = 0; i < Subtable->RegisterCount; i++)

        {

	    ACPI_MOVE_16_TO_16(&Tmp16, &Subtable->AddressSizeOffset);

            ArrayOffset = Tmp16 + (sizeof (UINT32) * i);

            AbsoluteOffset = Offset + ArrayOffset;

            Array = (UINT8 *) Subtable + ArrayOffset;

            Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,

                SubLength, AcpiDmTableInfoDbg2Size);

            if (ACPI_FAILURE (Status))

            {

                return;

            }

        }

        /* Dump the Namestring (required) */

        AcpiOsPrintf ("\n");

	ACPI_MOVE_16_TO_16(&Tmp16, &Subtable->NamepathOffset);

        ArrayOffset = Tmp16;

        AbsoluteOffset = Offset + ArrayOffset;

        Array = (UINT8 *) Subtable + ArrayOffset;

        Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,

            SubLength, AcpiDmTableInfoDbg2Name);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* Dump the OemData (optional) */

        if (Subtable->OemDataOffset)

        {

	    ACPI_MOVE_16_TO_16(&Tmp16, &Subtable->OemDataOffset);

	    ACPI_MOVE_16_TO_16(&AlsoTmp16, &Subtable->OemDataLength);

            Status = AcpiDmDumpTable (Length, Offset + Tmp16,

                Table, AlsoTmp16, AcpiDmTableInfoDbg2OemData);

            if (ACPI_FAILURE (Status))

            {

                return;

            }

        }

        /* Point to next subtable */

        Offset += SubLength;

        Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable,

            SubLength);

    }

}

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpDmar

 *

 * PARAMETERS:  Table               - A DMAR table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a DMAR. This table type consists

 *              of an open-ended number of subtables.

 *

 ******************************************************************************/

void

AcpiDmDumpDmar (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_DMAR_HEADER        *Subtable;

    UINT32                  Length;

    UINT16                  SubLength;

    UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);

    ACPI_DMTABLE_INFO       *InfoTable;

    ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;

    UINT32                  ScopeOffset;

    UINT8                   *PciPath;

    UINT32                  PathOffset;

    UINT16		    SubType;

    /* Main table */

    ACPI_MOVE_32_TO_32(&Length, &Table->Length);

    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtables */

    Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);

    while (Offset < Length)

    {

        /* Common subtable header */

        AcpiOsPrintf ("\n");

	ACPI_MOVE_16_TO_16(&SubLength, &Subtable->Length);

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            SubLength, AcpiDmTableInfoDmarHdr);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        AcpiOsPrintf ("\n");

	ACPI_MOVE_16_TO_16(&SubType, &Subtable->Type);

        switch (SubType)

        {

        case ACPI_DMAR_TYPE_HARDWARE_UNIT:

            InfoTable = AcpiDmTableInfoDmar0;

            ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);

            break;

        case ACPI_DMAR_TYPE_RESERVED_MEMORY:

            InfoTable = AcpiDmTableInfoDmar1;

            ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);

            break;

        case ACPI_DMAR_TYPE_ROOT_ATS:

            InfoTable = AcpiDmTableInfoDmar2;

            ScopeOffset = sizeof (ACPI_DMAR_ATSR);

            break;

        case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:

            InfoTable = AcpiDmTableInfoDmar3;

            ScopeOffset = sizeof (ACPI_DMAR_RHSA);

            break;

        case ACPI_DMAR_TYPE_NAMESPACE:

            InfoTable = AcpiDmTableInfoDmar4;

            ScopeOffset = sizeof (ACPI_DMAR_ANDD);

            break;

        default:

            AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",

                SubType);

            return;

        }

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            SubLength, InfoTable);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /*

         * Dump the optional device scope entries

         */

        if ((SubType == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||

            (SubType == ACPI_DMAR_TYPE_NAMESPACE))

        {

            /* These types do not support device scopes */

            goto NextSubtable;

        }

        ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset);

        while (ScopeOffset < SubLength)

        {

            AcpiOsPrintf ("\n");

            Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,

                ScopeTable->Length, AcpiDmTableInfoDmarScope);

            if (ACPI_FAILURE (Status))

            {

                return;

            }

            AcpiOsPrintf ("\n");

            /* Dump the PCI Path entries for this device scope */

            PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */

            PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,

                sizeof (ACPI_DMAR_DEVICE_SCOPE));

            while (PathOffset < ScopeTable->Length)

            {

                AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,

                    "PCI Path");

                AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);

                /* Point to next PCI Path entry */

                PathOffset += 2;

                PciPath += 2;

                AcpiOsPrintf ("\n");

            }

            /* Point to next device scope entry */

            ScopeOffset += ScopeTable->Length;

            ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,

                ScopeTable, ScopeTable->Length);

        }

NextSubtable:

        /* Point to next subtable */

        Offset += SubLength;

        Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable, SubLength);

    }

}

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpDrtm

 *

 * PARAMETERS:  Table               - A DRTM table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a DRTM.

 *

 ******************************************************************************/

void

AcpiDmDumpDrtm (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    UINT32                  Offset;

    ACPI_DRTM_VTABLE_LIST   *DrtmVtl;

    ACPI_DRTM_RESOURCE_LIST *DrtmRl;

    ACPI_DRTM_DPS_ID        *DrtmDps;

    UINT32                  Count;

    UINT32                  ValidatedCount;

    UINT32                  ResourceCount;

    UINT32		    Length;

    /* Main table */

    ACPI_MOVE_32_TO_32(&Length, &Table->Length);

    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDrtm);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    Offset = sizeof (ACPI_TABLE_DRTM);

    /* Sub-tables */

    /* Dump ValidatedTable length */

    DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);

    AcpiOsPrintf ("\n");

    Status = AcpiDmDumpTable (Length, Offset,

        DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),

        AcpiDmTableInfoDrtm0);

    if (ACPI_FAILURE (Status))

    {

            return;

    }

    Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);

    /* Dump Validated table addresses */

    Count = 0;

    ACPI_MOVE_32_TO_32(&ValidatedCount, &DrtmVtl->ValidatedTableCount);

    while ((Offset < Length) &&

            (ValidatedCount > Count))

    {

        Status = AcpiDmDumpTable (Length, Offset,

            ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),

            AcpiDmTableInfoDrtm0a);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        Offset += sizeof (UINT64);

        Count++;

    }

    /* Dump ResourceList length */

    DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);

    AcpiOsPrintf ("\n");

    Status = AcpiDmDumpTable (Length, Offset,

        DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),

        AcpiDmTableInfoDrtm1);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);

    /* Dump the Resource List */

    Count = 0;

    ACPI_MOVE_32_TO_32(&ResourceCount, &DrtmRl->ResourceCount);

    while ((Offset < Length) &&

           (ResourceCount > Count))

    {

        Status = AcpiDmDumpTable (Length, Offset,

            ACPI_ADD_PTR (void, Table, Offset),

            sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        Offset += sizeof (ACPI_DRTM_RESOURCE);

        Count++;

    }

    /* Dump DPS */

    DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);

    AcpiOsPrintf ("\n");

    (void) AcpiDmDumpTable (Length, Offset,

        DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);

}

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpEinj

 *

 * PARAMETERS:  Table               - A EINJ table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a EINJ. This table type consists

 *              of an open-ended number of subtables.

 *

 ******************************************************************************/

void

AcpiDmDumpEinj (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_WHEA_HEADER        *Subtable;

    UINT32                  Length;

    UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);

    /* Main table */

    ACPI_MOVE_32_TO_32(&Length, &Table->Length);

    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtables */

    Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);

    while (Offset < Length)

    {

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* Point to next subtable (each subtable is of fixed length) */

        Offset += sizeof (ACPI_WHEA_HEADER);

        Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,

            sizeof (ACPI_WHEA_HEADER));

    }

}

/*******************************************************************************

 *

 * FUNCTION:    AcpiDmDumpErst

 *

 * PARAMETERS:  Table               - A ERST table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a ERST. This table type consists

 *              of an open-ended number of subtables.

 *

 ******************************************************************************/

void

AcpiDmDumpErst (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_WHEA_HEADER        *Subtable;

    UINT32                  Length;

    UINT32                  Offset = sizeof (ACPI_TABLE_ERST);

    /* Main table */

    ACPI_MOVE_32_TO_32(&Length, &Table->Length);

    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);

    if (ACPI_FAILURE (Status))