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

 *

 * Module Name: dmtbdump2 - 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    ("dmtbdump2")

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

 *

 * FUNCTION:    AcpiDmDumpIort

 *

 * PARAMETERS:  Table               - A IORT table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a IORT

 *

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

void

AcpiDmDumpIort (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_TABLE_IORT         *Iort;

    ACPI_IORT_NODE          *IortNode;

    ACPI_IORT_ITS_GROUP     *IortItsGroup = NULL;

    ACPI_IORT_SMMU          *IortSmmu = NULL;

    UINT32                  Offset;

    UINT32                  NodeOffset;

    UINT16		    NodeLength;

    UINT32                  Length;

    ACPI_DMTABLE_INFO       *InfoTable;

    char                    *String;

    UINT32                  i;

    UINT32		    TableLen;

    UINT32		    ItsCount;

    UINT32		    MappingCount;

    UINT32		    CtxIntCount;

    UINT32		    PmuIntCount;

    /* Main table */

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

    Status = AcpiDmDumpTable (TableLen, 0, Table, 0, AcpiDmTableInfoIort);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);

    Offset = sizeof (ACPI_TABLE_IORT);

    /* Dump the OptionalPadding (optional) */

    ACPI_MOVE_32_TO_32(&NodeOffset, &Iort->NodeOffset);

    if (NodeOffset > Offset)

    {

        Status = AcpiDmDumpTable (TableLen, Offset, Table,

            NodeOffset - Offset, AcpiDmTableInfoIortPad);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

    }

    ACPI_MOVE_32_TO_32(&Offset, &Iort->NodeOffset);

    while (Offset < TableLen)

    {

        /* Common subtable header */

        IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);

        AcpiOsPrintf ("\n");

        Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);

        Status = AcpiDmDumpTable (Table->Length, Offset,

            IortNode, Length, AcpiDmTableInfoIortHdr);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        NodeOffset = Length;

        switch (IortNode->Type)

        {

        case ACPI_IORT_NODE_ITS_GROUP:

            InfoTable = AcpiDmTableInfoIort0;

            Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);

            IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);

            break;

        case ACPI_IORT_NODE_NAMED_COMPONENT:

            InfoTable = AcpiDmTableInfoIort1;

            Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);

            String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);

            Length += strlen (String) + 1;

            break;

        case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:

            InfoTable = AcpiDmTableInfoIort2;

	    ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);

            Length = NodeLength - NodeOffset;

            break;

        case ACPI_IORT_NODE_SMMU:

            InfoTable = AcpiDmTableInfoIort3;

            Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);

            IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);

            break;

        case ACPI_IORT_NODE_SMMU_V3:

            InfoTable = AcpiDmTableInfoIort4;

	    ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);

            Length = NodeLength - NodeOffset;

            break;

        case ACPI_IORT_NODE_PMCG:

            InfoTable = AcpiDmTableInfoIort5;

            Length = IortNode->Length - NodeOffset;

            break;

        default:

            AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",

                IortNode->Type);

            /* Attempt to continue */

	    ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);

            if (!NodeLength)

            {

                AcpiOsPrintf ("Invalid zero length IORT node\n");

                return;

            }

            goto NextSubtable;

        }

        /* Dump the node subtable header */

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,

            ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),

            Length, InfoTable);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        NodeOffset += Length;

        /* Dump the node specific data */

        switch (IortNode->Type)

        {

        case ACPI_IORT_NODE_ITS_GROUP:

            /* Validate IortItsGroup to avoid compiler warnings */

            if (IortItsGroup)

            {

	        ACPI_MOVE_32_TO_32(&ItsCount, &IortItsGroup->ItsCount);

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

                {

                    Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,

                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),

                        4, AcpiDmTableInfoIort0a);

                    NodeOffset += 4;

                }

            }

            break;

        case ACPI_IORT_NODE_NAMED_COMPONENT:

            /* Dump the Padding (optional) */

	    ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);

            if (NodeLength > NodeOffset)

            {

                Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,

                    Table, NodeLength - NodeOffset, AcpiDmTableInfoIort1a);

                if (ACPI_FAILURE (Status))

                {

                    return;

                }

            }

            break;

        case ACPI_IORT_NODE_SMMU:

            AcpiOsPrintf ("\n");

            /* Validate IortSmmu to avoid compiler warnings */

            if (IortSmmu)

            {

                Length = 2 * sizeof (UINT64);

                ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->GlobalInterruptOffset);

                Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,

                    ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),

                    Length, AcpiDmTableInfoIort3a);

                if (ACPI_FAILURE (Status))

                {

                    return;

                }

                ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->ContextInterruptOffset);

                ACPI_MOVE_32_TO_32(&CtxIntCount, &IortSmmu->ContextInterruptCount);

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

                {

                    Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,

                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),

                        8, AcpiDmTableInfoIort3b);

                    if (ACPI_FAILURE (Status))

                    {

                        return;

                    }

                    NodeOffset += 8;

                }

                ACPI_MOVE_32_TO_32(&NodeOffset, &IortSmmu->PmuInterruptOffset);

                ACPI_MOVE_32_TO_32(&PmuIntCount, &IortSmmu->PmuInterruptCount);

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

                {

                    Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,

                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),

                        8, AcpiDmTableInfoIort3c);

                    if (ACPI_FAILURE (Status))

                    {

                        return;

                    }

                    NodeOffset += 8;

                }

            }

            break;

        default:

            break;

        }

        /* Dump the ID mappings */

        ACPI_MOVE_32_TO_32(&NodeOffset, &IortNode->MappingOffset);

        ACPI_MOVE_32_TO_32(&MappingCount, &IortNode->MappingCount);

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

        {

            AcpiOsPrintf ("\n");

            Length = sizeof (ACPI_IORT_ID_MAPPING);

            Status = AcpiDmDumpTable (TableLen, Offset + NodeOffset,

                ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),

                Length, AcpiDmTableInfoIortMap);

            if (ACPI_FAILURE (Status))

            {

                return;

            }

            NodeOffset += Length;

        }

NextSubtable:

        /* Point to next node subtable */

	ACPI_MOVE_16_TO_16(&NodeLength, &IortNode->Length);

        Offset += NodeLength;

        IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeLength);

    }

}

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

 *

 * FUNCTION:    AcpiDmDumpIvrs

 *

 * PARAMETERS:  Table               - A IVRS table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a IVRS

 *

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

static UINT8 EntrySizes[] = {4,8,16,32};

void

AcpiDmDumpIvrs (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    UINT32                  Offset = sizeof (ACPI_TABLE_IVRS);

    UINT32                  EntryOffset;

    UINT32                  EntryLength;

    UINT32                  EntryType;

    ACPI_IVRS_DE_HEADER     *DeviceEntry;

    ACPI_IVRS_HEADER        *Subtable;

    ACPI_DMTABLE_INFO       *InfoTable;

    UINT32		    Length;

    UINT16		    SubLength;

    /* Main table */

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

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

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtables */

    Subtable = ACPI_ADD_PTR (ACPI_IVRS_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, AcpiDmTableInfoIvrsHdr);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        switch (Subtable->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:

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

                Subtable->Type);

            /* Attempt to continue */

            if (!SubLength)

            {

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

                return;

            }

            goto NextSubtable;

        }

        /* Dump the subtable */

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            SubLength, InfoTable);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* The hardware subtable can contain multiple device entries */

        if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE)

        {

            EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);

            DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,

                sizeof (ACPI_IVRS_HARDWARE));

            while (EntryOffset < (Offset + SubLength))

            {

                AcpiOsPrintf ("\n");

                /*

                 * Upper 2 bits of Type encode the length of the device entry

                 *

                 * 00 = 4 byte

                 * 01 = 8 byte

                 * 10 = 16 byte - currently no entries defined

                 * 11 = 32 byte - currently no entries defined

                 */

                EntryType = DeviceEntry->Type;

                EntryLength = EntrySizes [EntryType >> 6];

                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:

                    InfoTable = AcpiDmTableInfoIvrs4;

                    AcpiOsPrintf (

                        "\n**** Unknown IVRS device entry type/length: "

                        "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",

                        EntryType, EntryLength, EntryOffset);

                    break;

                }

                /* Dump the Device Entry */

                Status = AcpiDmDumpTable (Length, EntryOffset,

                    DeviceEntry, EntryLength, InfoTable);

                if (ACPI_FAILURE (Status))

                {

                    return;

                }

                EntryOffset += EntryLength;

                DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,

                    EntryLength);

            }

        }

NextSubtable:

        /* Point to next subtable */

        Offset += SubLength;

        Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, SubLength);

    }

}

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

 *

 * FUNCTION:    AcpiDmDumpLpit

 *

 * PARAMETERS:  Table               - A LPIT table

 *

 * RETURN:      None

 *

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

 *              of an open-ended number of subtables. Note: There are no

 *              entries in the main table. An LPIT consists of the table

 *              header and then subtables only.

 *

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

void

AcpiDmDumpLpit (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_LPIT_HEADER        *Subtable;

    UINT32                  Length;

    UINT32                  Offset = sizeof (ACPI_TABLE_LPIT);

    ACPI_DMTABLE_INFO       *InfoTable;

    UINT32                  SubtableLength;

    /* Subtables */

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

    Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);

    while (Offset < Length)

    {

        /* Common subtable header */

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        switch (Subtable->Type)

        {

        case ACPI_LPIT_TYPE_NATIVE_CSTATE:

            InfoTable = AcpiDmTableInfoLpit0;

            SubtableLength = sizeof (ACPI_LPIT_NATIVE);

            break;

        default:

            /* Cannot continue on unknown type - no length */

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

                Subtable->Type);

            return;

        }

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            SubtableLength, InfoTable);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        AcpiOsPrintf ("\n");

        /* Point to next subtable */

        Offset += SubtableLength;

        Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength);

    }

}

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

 *

 * FUNCTION:    AcpiDmDumpMadt

 *

 * PARAMETERS:  Table               - A MADT table

 *

 * RETURN:      None

 *

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

 *              of an open-ended number of subtables.

 *

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

void

AcpiDmDumpMadt (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    ACPI_SUBTABLE_HEADER    *Subtable;

    UINT32                  Length;

    UINT32                  Offset = sizeof (ACPI_TABLE_MADT);

    ACPI_DMTABLE_INFO       *InfoTable;

    /* Main table */

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

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

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtables */

    Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);

    while (Offset < Length)

    {

        /* Common subtable header */

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            Subtable->Length, AcpiDmTableInfoMadtHdr);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        switch (Subtable->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;

        case ACPI_MADT_TYPE_GENERIC_INTERRUPT:

            InfoTable = AcpiDmTableInfoMadt11;

            break;

        case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:

            InfoTable = AcpiDmTableInfoMadt12;

            break;

        case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:

            InfoTable = AcpiDmTableInfoMadt13;

            break;

        case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:

            InfoTable = AcpiDmTableInfoMadt14;

            break;

        case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:

            InfoTable = AcpiDmTableInfoMadt15;

            break;

        default:

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

                Subtable->Type);

            /* Attempt to continue */

            if (!Subtable->Length)

            {

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

                return;

            }

            goto NextSubtable;

        }

        Status = AcpiDmDumpTable (Length, Offset, Subtable,

            Subtable->Length, InfoTable);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

NextSubtable:

        /* Point to next subtable */

        Offset += Subtable->Length;

        Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable,

            Subtable->Length);

    }

}

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

 *

 * FUNCTION:    AcpiDmDumpMcfg

 *

 * PARAMETERS:  Table               - A MCFG Table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a MCFG table

 *

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

void

AcpiDmDumpMcfg (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);

    ACPI_MCFG_ALLOCATION    *Subtable;

    UINT32		    Len;

    /* Main table */

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

    Status = AcpiDmDumpTable (Len, 0, Table, 0, AcpiDmTableInfoMcfg);

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtables */

    Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);

    while (Offset < Len)

    {

        if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Len)

        {

            AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",

                sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Len));

            return;

        }

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (Len, Offset, Subtable,

            sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

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

        Offset += sizeof (ACPI_MCFG_ALLOCATION);

        Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable,

            sizeof (ACPI_MCFG_ALLOCATION));

    }

}

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

 *

 * FUNCTION:    AcpiDmDumpMpst

 *

 * PARAMETERS:  Table               - A MPST Table

 *

 * RETURN:      None

 *

 * DESCRIPTION: Format the contents of a MPST table

 *

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

void

AcpiDmDumpMpst (

    ACPI_TABLE_HEADER       *Table)

{

    ACPI_STATUS             Status;

    UINT32                  Offset = sizeof (ACPI_TABLE_MPST);

    ACPI_TABLE_MPST	    *Mpst;

    ACPI_MPST_POWER_NODE    *Subtable0;

    ACPI_MPST_POWER_STATE   *Subtable0A;

    ACPI_MPST_COMPONENT     *Subtable0B;

    ACPI_MPST_DATA_HDR      *Subtable1;

    ACPI_MPST_POWER_DATA    *Subtable2;

    UINT16                  SubtableCount;

    UINT32                  PowerStateCount;

    UINT32                  ComponentCount;

    UINT32		    Length;

    /* Main table */

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

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

    if (ACPI_FAILURE (Status))

    {

        return;

    }

    /* Subtable: Memory Power Node(s) */

    Mpst = ACPI_CAST_PTR (ACPI_TABLE_MPST, Table);

    ACPI_MOVE_16_TO_16(&SubtableCount, &Mpst->PowerNodeCount);

    Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);

    while ((Offset < Length) && SubtableCount)

    {

        AcpiOsPrintf ("\n");

        Status = AcpiDmDumpTable (Length, Offset, Subtable0,

            sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);

        if (ACPI_FAILURE (Status))

        {

            return;

        }

        /* Extract the sub-subtable counts */

        ACPI_MOVE_32_TO_32(&PowerStateCount, &Subtable0->NumPowerStates);

        ACPI_MOVE_32_TO_32(&ComponentCount, &Subtable0->NumPhysicalComponents);

        Offset += sizeof (ACPI_MPST_POWER_NODE);

        /* Sub-subtables - Memory Power State Structure(s) */

        Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0,

            sizeof (ACPI_MPST_POWER_NODE));

        while (PowerStateCount)

        {

            AcpiOsPrintf ("\n");

            Status = AcpiDmDumpTable (Length, Offset, Subtable0A,

                sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);