dmtbdump.c revision 217365 
1/******************************************************************************
2 *
3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2011, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include <contrib/dev/acpica/include/acpi.h>
45#include <contrib/dev/acpica/include/accommon.h>
46#include <contrib/dev/acpica/include/acdisasm.h>
47#include <contrib/dev/acpica/include/actables.h>
48
49/* This module used for application-level code only */
50
51#define _COMPONENT          ACPI_CA_DISASSEMBLER
52        ACPI_MODULE_NAME    ("dmtbdump")
53
54
55/*******************************************************************************
56 *
57 * FUNCTION:    AcpiDmDumpRsdp
58 *
59 * PARAMETERS:  Table               - A RSDP
60 *
61 * RETURN:      Length of the table (there is not always a length field,
62 *              use revision or length if available (ACPI 2.0+))
63 *
64 * DESCRIPTION: Format the contents of a RSDP
65 *
66 ******************************************************************************/
67
68UINT32
69AcpiDmDumpRsdp (
70    ACPI_TABLE_HEADER       *Table)
71{
72    ACPI_TABLE_RSDP         *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
73    UINT32                  Length = sizeof (ACPI_RSDP_COMMON);
74    UINT8                   Checksum;
75
76
77    /* Dump the common ACPI 1.0 portion */
78
79    AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
80
81    /* Validate the first checksum */
82
83    Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
84                Rsdp->Checksum);
85    if (Checksum != Rsdp->Checksum)
86    {
87        AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
88            Checksum);
89    }
90
91    /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
92
93    if (Rsdp->Revision > 0)
94    {
95        Length = Rsdp->Length;
96        AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
97
98        /* Validate the extended checksum over entire RSDP */
99
100        Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
101                    Rsdp->ExtendedChecksum);
102        if (Checksum != Rsdp->ExtendedChecksum)
103        {
104            AcpiOsPrintf (
105                "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
106                Checksum);
107        }
108    }
109
110    return (Length);
111}
112
113
114/*******************************************************************************
115 *
116 * FUNCTION:    AcpiDmDumpRsdt
117 *
118 * PARAMETERS:  Table               - A RSDT
119 *
120 * RETURN:      None
121 *
122 * DESCRIPTION: Format the contents of a RSDT
123 *
124 ******************************************************************************/
125
126void
127AcpiDmDumpRsdt (
128    ACPI_TABLE_HEADER       *Table)
129{
130    UINT32                  *Array;
131    UINT32                  Entries;
132    UINT32                  Offset;
133    UINT32                  i;
134
135
136    /* Point to start of table pointer array */
137
138    Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
139    Offset = sizeof (ACPI_TABLE_HEADER);
140
141    /* RSDT uses 32-bit pointers */
142
143    Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
144
145    for (i = 0; i < Entries; i++)
146    {
147        AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
148        AcpiOsPrintf ("%8.8X\n", Array[i]);
149        Offset += sizeof (UINT32);
150    }
151}
152
153
154/*******************************************************************************
155 *
156 * FUNCTION:    AcpiDmDumpXsdt
157 *
158 * PARAMETERS:  Table               - A XSDT
159 *
160 * RETURN:      None
161 *
162 * DESCRIPTION: Format the contents of a XSDT
163 *
164 ******************************************************************************/
165
166void
167AcpiDmDumpXsdt (
168    ACPI_TABLE_HEADER       *Table)
169{
170    UINT64                  *Array;
171    UINT32                  Entries;
172    UINT32                  Offset;
173    UINT32                  i;
174
175
176    /* Point to start of table pointer array */
177
178    Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
179    Offset = sizeof (ACPI_TABLE_HEADER);
180
181    /* XSDT uses 64-bit pointers */
182
183    Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
184
185    for (i = 0; i < Entries; i++)
186    {
187        AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
188        AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
189        Offset += sizeof (UINT64);
190    }
191}
192
193
194/*******************************************************************************
195 *
196 * FUNCTION:    AcpiDmDumpFadt
197 *
198 * PARAMETERS:  Table               - A FADT
199 *
200 * RETURN:      None
201 *
202 * DESCRIPTION: Format the contents of a FADT
203 *
204 ******************************************************************************/
205
206void
207AcpiDmDumpFadt (
208    ACPI_TABLE_HEADER       *Table)
209{
210
211    /* Common ACPI 1.0 portion of FADT */
212
213    AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
214
215    /* Check for ACPI 1.0B MS extensions (FADT revision 2) */
216
217    if (Table->Revision == 2)
218    {
219        AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
220    }
221
222    /* Check for ACPI 2.0+ extended data (FADT revision 3+) */
223
224    else if (Table->Length >= sizeof (ACPI_TABLE_FADT))
225    {
226        AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
227    }
228
229    /* Validate various fields in the FADT, including length */
230
231    AcpiTbCreateLocalFadt (Table, Table->Length);
232}
233
234
235/*******************************************************************************
236 *
237 * FUNCTION:    AcpiDmDumpAsf
238 *
239 * PARAMETERS:  Table               - A ASF table
240 *
241 * RETURN:      None
242 *
243 * DESCRIPTION: Format the contents of a ASF table
244 *
245 ******************************************************************************/
246
247void
248AcpiDmDumpAsf (
249    ACPI_TABLE_HEADER       *Table)
250{
251    ACPI_STATUS             Status;
252    UINT32                  Offset = sizeof (ACPI_TABLE_HEADER);
253    ACPI_ASF_INFO           *SubTable;
254    ACPI_DMTABLE_INFO       *InfoTable;
255    ACPI_DMTABLE_INFO       *DataInfoTable = NULL;
256    UINT8                   *DataTable = NULL;
257    UINT32                  DataCount = 0;
258    UINT32                  DataLength = 0;
259    UINT32                  DataOffset = 0;
260    UINT32                  i;
261    UINT8                   Type;
262
263
264    /* No main table, only sub-tables */
265
266    SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
267    while (Offset < Table->Length)
268    {
269        /* Common sub-table header */
270
271        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
272                    SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
273        if (ACPI_FAILURE (Status))
274        {
275            return;
276        }
277
278        /* The actual type is the lower 7 bits of Type */
279
280        Type = (UINT8) (SubTable->Header.Type & 0x7F);
281
282        switch (Type)
283        {
284        case ACPI_ASF_TYPE_INFO:
285            InfoTable = AcpiDmTableInfoAsf0;
286            break;
287
288        case ACPI_ASF_TYPE_ALERT:
289            InfoTable = AcpiDmTableInfoAsf1;
290            DataInfoTable = AcpiDmTableInfoAsf1a;
291            DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
292            DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
293            DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
294            DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
295            break;
296
297        case ACPI_ASF_TYPE_CONTROL:
298            InfoTable = AcpiDmTableInfoAsf2;
299            DataInfoTable = AcpiDmTableInfoAsf2a;
300            DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
301            DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
302            DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
303            DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
304            break;
305
306        case ACPI_ASF_TYPE_BOOT:
307            InfoTable = AcpiDmTableInfoAsf3;
308            break;
309
310        case ACPI_ASF_TYPE_ADDRESS:
311            InfoTable = AcpiDmTableInfoAsf4;
312            DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
313            DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
314            DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
315            break;
316
317        default:
318            AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type);
319            return;
320        }
321
322        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
323                    SubTable->Header.Length, InfoTable);
324        if (ACPI_FAILURE (Status))
325        {
326            return;
327        }
328
329        /* Dump variable-length extra data */
330
331        switch (Type)
332        {
333        case ACPI_ASF_TYPE_ALERT:
334        case ACPI_ASF_TYPE_CONTROL:
335
336            for (i = 0; i < DataCount; i++)
337            {
338                AcpiOsPrintf ("\n");
339                Status = AcpiDmDumpTable (Table->Length, DataOffset,
340                            DataTable, DataLength, DataInfoTable);
341                if (ACPI_FAILURE (Status))
342                {
343                    return;
344                }
345
346                DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
347                DataOffset += DataLength;
348            }
349            break;
350
351        case ACPI_ASF_TYPE_ADDRESS:
352
353            for (i = 0; i < DataLength; i++)
354            {
355                if (!(i % 16))
356                {
357                    AcpiDmLineHeader (DataOffset, 1, "Addresses");
358                }
359
360                AcpiOsPrintf ("%2.2X ", *DataTable);
361                DataTable++;
362                DataOffset++;
363                if (DataOffset > Table->Length)
364                {
365                    AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
366                    return;
367                }
368            }
369
370            AcpiOsPrintf ("\n");
371            break;
372
373        default:
374            break;
375        }
376
377        AcpiOsPrintf ("\n");
378
379        /* Point to next sub-table */
380
381        if (!SubTable->Header.Length)
382        {
383            AcpiOsPrintf ("Invalid zero subtable header length\n");
384            return;
385        }
386
387        Offset += SubTable->Header.Length;
388        SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
389    }
390}
391
392
393/*******************************************************************************
394 *
395 * FUNCTION:    AcpiDmDumpCpep
396 *
397 * PARAMETERS:  Table               - A CPEP table
398 *
399 * RETURN:      None
400 *
401 * DESCRIPTION: Format the contents of a CPEP. This table type consists
402 *              of an open-ended number of subtables.
403 *
404 ******************************************************************************/
405
406void
407AcpiDmDumpCpep (
408    ACPI_TABLE_HEADER       *Table)
409{
410    ACPI_STATUS             Status;
411    ACPI_CPEP_POLLING       *SubTable;
412    UINT32                  Length = Table->Length;
413    UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);
414
415
416    /* Main table */
417
418    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
419    if (ACPI_FAILURE (Status))
420    {
421        return;
422    }
423
424    /* Sub-tables */
425
426    SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
427    while (Offset < Table->Length)
428    {
429        AcpiOsPrintf ("\n");
430        Status = AcpiDmDumpTable (Length, Offset, SubTable,
431                    SubTable->Header.Length, AcpiDmTableInfoCpep0);
432        if (ACPI_FAILURE (Status))
433        {
434            return;
435        }
436
437        /* Point to next sub-table */
438
439        Offset += SubTable->Header.Length;
440        SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
441                    SubTable->Header.Length);
442    }
443}
444
445
446/*******************************************************************************
447 *
448 * FUNCTION:    AcpiDmDumpDmar
449 *
450 * PARAMETERS:  Table               - A DMAR table
451 *
452 * RETURN:      None
453 *
454 * DESCRIPTION: Format the contents of a DMAR. This table type consists
455 *              of an open-ended number of subtables.
456 *
457 ******************************************************************************/
458
459void
460AcpiDmDumpDmar (
461    ACPI_TABLE_HEADER       *Table)
462{
463    ACPI_STATUS             Status;
464    ACPI_DMAR_HEADER        *SubTable;
465    UINT32                  Length = Table->Length;
466    UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);
467    ACPI_DMTABLE_INFO       *InfoTable;
468    ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;
469    UINT32                  ScopeOffset;
470    UINT8                   *PciPath;
471    UINT32                  PathOffset;
472
473
474    /* Main table */
475
476    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
477    if (ACPI_FAILURE (Status))
478    {
479        return;
480    }
481
482    /* Sub-tables */
483
484    SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
485    while (Offset < Table->Length)
486    {
487        /* Common sub-table header */
488
489        AcpiOsPrintf ("\n");
490        Status = AcpiDmDumpTable (Length, Offset, SubTable,
491                    SubTable->Length, AcpiDmTableInfoDmarHdr);
492        if (ACPI_FAILURE (Status))
493        {
494            return;
495        }
496
497        switch (SubTable->Type)
498        {
499        case ACPI_DMAR_TYPE_HARDWARE_UNIT:
500            InfoTable = AcpiDmTableInfoDmar0;
501            ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
502            break;
503        case ACPI_DMAR_TYPE_RESERVED_MEMORY:
504            InfoTable = AcpiDmTableInfoDmar1;
505            ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
506            break;
507        case ACPI_DMAR_TYPE_ATSR:
508            InfoTable = AcpiDmTableInfoDmar2;
509            ScopeOffset = sizeof (ACPI_DMAR_ATSR);
510            break;
511        case ACPI_DMAR_HARDWARE_AFFINITY:
512            InfoTable = AcpiDmTableInfoDmar3;
513            ScopeOffset = sizeof (ACPI_DMAR_RHSA);
514            break;
515        default:
516            AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type);
517            return;
518        }
519
520        Status = AcpiDmDumpTable (Length, Offset, SubTable,
521                    SubTable->Length, InfoTable);
522        if (ACPI_FAILURE (Status))
523        {
524            return;
525        }
526
527        /* Dump the device scope entries (if any) */
528
529        ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
530        while (ScopeOffset < SubTable->Length)
531        {
532            AcpiOsPrintf ("\n");
533            Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
534                        ScopeTable->Length, AcpiDmTableInfoDmarScope);
535            if (ACPI_FAILURE (Status))
536            {
537                return;
538            }
539
540            /* Dump the PCI Path entries for this device scope */
541
542            PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
543
544            PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
545                sizeof (ACPI_DMAR_DEVICE_SCOPE));
546
547            while (PathOffset < ScopeTable->Length)
548            {
549                AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
550                AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
551
552                /* Point to next PCI Path entry */
553
554                PathOffset += 2;
555                PciPath += 2;
556            }
557
558            /* Point to next device scope entry */
559
560            ScopeOffset += ScopeTable->Length;
561            ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
562                ScopeTable, ScopeTable->Length);
563        }
564
565        /* Point to next sub-table */
566
567        Offset += SubTable->Length;
568        SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
569    }
570}
571
572
573/*******************************************************************************
574 *
575 * FUNCTION:    AcpiDmDumpEinj
576 *
577 * PARAMETERS:  Table               - A EINJ table
578 *
579 * RETURN:      None
580 *
581 * DESCRIPTION: Format the contents of a EINJ. This table type consists
582 *              of an open-ended number of subtables.
583 *
584 ******************************************************************************/
585
586void
587AcpiDmDumpEinj (
588    ACPI_TABLE_HEADER       *Table)
589{
590    ACPI_STATUS             Status;
591    ACPI_WHEA_HEADER        *SubTable;
592    UINT32                  Length = Table->Length;
593    UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
594
595
596    /* Main table */
597
598    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
599    if (ACPI_FAILURE (Status))
600    {
601        return;
602    }
603
604    /* Sub-tables */
605
606    SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
607    while (Offset < Table->Length)
608    {
609        AcpiOsPrintf ("\n");
610        Status = AcpiDmDumpTable (Length, Offset, SubTable,
611                    sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
612        if (ACPI_FAILURE (Status))
613        {
614            return;
615        }
616
617        /* Point to next sub-table (each subtable is of fixed length) */
618
619        Offset += sizeof (ACPI_WHEA_HEADER);
620        SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
621                        sizeof (ACPI_WHEA_HEADER));
622    }
623}
624
625
626/*******************************************************************************
627 *
628 * FUNCTION:    AcpiDmDumpErst
629 *
630 * PARAMETERS:  Table               - A ERST table
631 *
632 * RETURN:      None
633 *
634 * DESCRIPTION: Format the contents of a ERST. This table type consists
635 *              of an open-ended number of subtables.
636 *
637 ******************************************************************************/
638
639void
640AcpiDmDumpErst (
641    ACPI_TABLE_HEADER       *Table)
642{
643    ACPI_STATUS             Status;
644    ACPI_WHEA_HEADER        *SubTable;
645    UINT32                  Length = Table->Length;
646    UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
647
648
649    /* Main table */
650
651    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
652    if (ACPI_FAILURE (Status))
653    {
654        return;
655    }
656
657    /* Sub-tables */
658
659    SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
660    while (Offset < Table->Length)
661    {
662        AcpiOsPrintf ("\n");
663        Status = AcpiDmDumpTable (Length, Offset, SubTable,
664                    sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
665        if (ACPI_FAILURE (Status))
666        {
667            return;
668        }
669
670        /* Point to next sub-table (each subtable is of fixed length) */
671
672        Offset += sizeof (ACPI_WHEA_HEADER);
673        SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
674                        sizeof (ACPI_WHEA_HEADER));
675    }
676}
677
678
679/*******************************************************************************
680 *
681 * FUNCTION:    AcpiDmDumpHest
682 *
683 * PARAMETERS:  Table               - A HEST table
684 *
685 * RETURN:      None
686 *
687 * DESCRIPTION: Format the contents of a HEST. This table type consists
688 *              of an open-ended number of subtables.
689 *
690 ******************************************************************************/
691
692void
693AcpiDmDumpHest (
694    ACPI_TABLE_HEADER       *Table)
695{
696    ACPI_STATUS             Status;
697    ACPI_HEST_HEADER        *SubTable;
698    UINT32                  Length = Table->Length;
699    UINT32                  Offset = sizeof (ACPI_TABLE_HEST);
700    ACPI_DMTABLE_INFO       *InfoTable;
701    UINT32                  SubTableLength;
702    UINT32                  BankCount;
703    ACPI_HEST_IA_ERROR_BANK *BankTable;
704
705
706    /* Main table */
707
708    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
709    if (ACPI_FAILURE (Status))
710    {
711        return;
712    }
713
714    /* Sub-tables */
715
716    SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
717    while (Offset < Table->Length)
718    {
719        BankCount = 0;
720        switch (SubTable->Type)
721        {
722        case ACPI_HEST_TYPE_IA32_CHECK:
723            InfoTable = AcpiDmTableInfoHest0;
724            SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
725            BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
726                            SubTable))->NumHardwareBanks;
727            break;
728
729        case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
730            InfoTable = AcpiDmTableInfoHest1;
731            SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
732            BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
733                            SubTable))->NumHardwareBanks;
734            break;
735
736        case ACPI_HEST_TYPE_IA32_NMI:
737            InfoTable = AcpiDmTableInfoHest2;
738            SubTableLength = sizeof (ACPI_HEST_IA_NMI);
739            break;
740
741        case ACPI_HEST_TYPE_AER_ROOT_PORT:
742            InfoTable = AcpiDmTableInfoHest6;
743            SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
744            break;
745
746        case ACPI_HEST_TYPE_AER_ENDPOINT:
747            InfoTable = AcpiDmTableInfoHest7;
748            SubTableLength = sizeof (ACPI_HEST_AER);
749            break;
750
751        case ACPI_HEST_TYPE_AER_BRIDGE:
752            InfoTable = AcpiDmTableInfoHest8;
753            SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
754            break;
755
756        case ACPI_HEST_TYPE_GENERIC_ERROR:
757            InfoTable = AcpiDmTableInfoHest9;
758            SubTableLength = sizeof (ACPI_HEST_GENERIC);
759            break;
760
761        default:
762            /* Cannot continue on unknown type - no length */
763
764            AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type);
765            return;
766        }
767
768        AcpiOsPrintf ("\n");
769        Status = AcpiDmDumpTable (Length, Offset, SubTable,
770                    SubTableLength, InfoTable);
771        if (ACPI_FAILURE (Status))
772        {
773            return;
774        }
775
776        /* Point to end of current subtable (each subtable above is of fixed length) */
777
778        Offset += SubTableLength;
779
780        /* If there are any (fixed-length) Error Banks from above, dump them now */
781
782        if (BankCount)
783        {
784            BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
785            SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
786
787            while (BankCount)
788            {
789                AcpiOsPrintf ("\n");
790                Status = AcpiDmDumpTable (Length, Offset, BankTable,
791                            sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
792                if (ACPI_FAILURE (Status))
793                {
794                    return;
795                }
796                Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
797                BankTable++;
798                BankCount--;
799            }
800        }
801
802        /* Point to next sub-table */
803
804        SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
805    }
806}
807
808
809/*******************************************************************************
810 *
811 * FUNCTION:    AcpiDmDumpIvrs
812 *
813 * PARAMETERS:  Table               - A IVRS table
814 *
815 * RETURN:      None
816 *
817 * DESCRIPTION: Format the contents of a IVRS
818 *
819 ******************************************************************************/
820
821static UINT8 EntrySizes[] = {4,8,16,32};
822
823void
824AcpiDmDumpIvrs (
825    ACPI_TABLE_HEADER       *Table)
826{
827    ACPI_STATUS             Status;
828    UINT32                  Offset = sizeof (ACPI_TABLE_IVRS);
829    UINT32                  EntryOffset;
830    UINT32                  EntryLength;
831    UINT32                  EntryType;
832    ACPI_IVRS_DE_HEADER     *DeviceEntry;
833    ACPI_IVRS_HEADER        *SubTable;
834    ACPI_DMTABLE_INFO       *InfoTable;
835
836
837    /* Main table */
838
839    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
840    if (ACPI_FAILURE (Status))
841    {
842        return;
843    }
844
845    /* Sub-tables */
846
847    SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
848    while (Offset < Table->Length)
849    {
850        /* Common sub-table header */
851
852        AcpiOsPrintf ("\n");
853        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
854                    SubTable->Length, AcpiDmTableInfoIvrsHdr);
855        if (ACPI_FAILURE (Status))
856        {
857            return;
858        }
859
860        switch (SubTable->Type)
861        {
862        case ACPI_IVRS_TYPE_HARDWARE:
863            InfoTable = AcpiDmTableInfoIvrs0;
864            break;
865        case ACPI_IVRS_TYPE_MEMORY1:
866        case ACPI_IVRS_TYPE_MEMORY2:
867        case ACPI_IVRS_TYPE_MEMORY3:
868            InfoTable = AcpiDmTableInfoIvrs1;
869            break;
870        default:
871            AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n",
872                SubTable->Type);
873
874            /* Attempt to continue */
875
876            if (!SubTable->Length)
877            {
878                AcpiOsPrintf ("Invalid zero length subtable\n");
879                return;
880            }
881            goto NextSubTable;
882        }
883
884        /* Dump the subtable */
885
886        AcpiOsPrintf ("\n");
887        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
888                    SubTable->Length, InfoTable);
889        if (ACPI_FAILURE (Status))
890        {
891            return;
892        }
893
894        /* The hardware subtable can contain multiple device entries */
895
896        if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
897        {
898            EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
899            DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
900                            sizeof (ACPI_IVRS_HARDWARE));
901
902            while (EntryOffset < (Offset + SubTable->Length))
903            {
904                AcpiOsPrintf ("\n");
905                /*
906                 * Upper 2 bits of Type encode the length of the device entry
907                 *
908                 * 00 = 4 byte
909                 * 01 = 8 byte
910                 * 10 = 16 byte - currently no entries defined
911                 * 11 = 32 byte - currently no entries defined
912                 */
913                EntryType = DeviceEntry->Type;
914                EntryLength = EntrySizes [EntryType >> 6];
915
916                switch (EntryType)
917                {
918                /* 4-byte device entries */
919
920                case ACPI_IVRS_TYPE_PAD4:
921                case ACPI_IVRS_TYPE_ALL:
922                case ACPI_IVRS_TYPE_SELECT:
923                case ACPI_IVRS_TYPE_START:
924                case ACPI_IVRS_TYPE_END:
925
926                    InfoTable = AcpiDmTableInfoIvrs4;
927                    break;
928
929                /* 8-byte entries, type A */
930
931                case ACPI_IVRS_TYPE_ALIAS_SELECT:
932                case ACPI_IVRS_TYPE_ALIAS_START:
933
934                    InfoTable = AcpiDmTableInfoIvrs8a;
935                    break;
936
937                /* 8-byte entries, type B */
938
939                case ACPI_IVRS_TYPE_PAD8:
940                case ACPI_IVRS_TYPE_EXT_SELECT:
941                case ACPI_IVRS_TYPE_EXT_START:
942
943                    InfoTable = AcpiDmTableInfoIvrs8b;
944                    break;
945
946                /* 8-byte entries, type C */
947
948                case ACPI_IVRS_TYPE_SPECIAL:
949
950                    InfoTable = AcpiDmTableInfoIvrs8c;
951                    break;
952
953                default:
954                    InfoTable = AcpiDmTableInfoIvrs4;
955                    AcpiOsPrintf (
956                        "\n**** Unknown IVRS device entry type/length: "
957                        "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
958                        EntryType, EntryLength, EntryOffset);
959                    break;
960                }
961
962                /* Dump the Device Entry */
963
964                Status = AcpiDmDumpTable (Table->Length, EntryOffset,
965                            DeviceEntry, EntryLength, InfoTable);
966
967                EntryOffset += EntryLength;
968                DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
969                                EntryLength);
970            }
971        }
972
973NextSubTable:
974        /* Point to next sub-table */
975
976        Offset += SubTable->Length;
977        SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
978    }
979}
980
981
982/*******************************************************************************
983 *
984 * FUNCTION:    AcpiDmDumpMadt
985 *
986 * PARAMETERS:  Table               - A MADT table
987 *
988 * RETURN:      None
989 *
990 * DESCRIPTION: Format the contents of a MADT. This table type consists
991 *              of an open-ended number of subtables.
992 *
993 ******************************************************************************/
994
995void
996AcpiDmDumpMadt (
997    ACPI_TABLE_HEADER       *Table)
998{
999    ACPI_STATUS             Status;
1000    ACPI_SUBTABLE_HEADER    *SubTable;
1001    UINT32                  Length = Table->Length;
1002    UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
1003    ACPI_DMTABLE_INFO       *InfoTable;
1004
1005
1006    /* Main table */
1007
1008    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1009    if (ACPI_FAILURE (Status))
1010    {
1011        return;
1012    }
1013
1014    /* Sub-tables */
1015
1016    SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1017    while (Offset < Table->Length)
1018    {
1019        /* Common sub-table header */
1020
1021        AcpiOsPrintf ("\n");
1022        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1023                    SubTable->Length, AcpiDmTableInfoMadtHdr);
1024        if (ACPI_FAILURE (Status))
1025        {
1026            return;
1027        }
1028
1029        switch (SubTable->Type)
1030        {
1031        case ACPI_MADT_TYPE_LOCAL_APIC:
1032            InfoTable = AcpiDmTableInfoMadt0;
1033            break;
1034        case ACPI_MADT_TYPE_IO_APIC:
1035            InfoTable = AcpiDmTableInfoMadt1;
1036            break;
1037        case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
1038            InfoTable = AcpiDmTableInfoMadt2;
1039            break;
1040        case ACPI_MADT_TYPE_NMI_SOURCE:
1041            InfoTable = AcpiDmTableInfoMadt3;
1042            break;
1043        case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
1044            InfoTable = AcpiDmTableInfoMadt4;
1045            break;
1046        case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
1047            InfoTable = AcpiDmTableInfoMadt5;
1048            break;
1049        case ACPI_MADT_TYPE_IO_SAPIC:
1050            InfoTable = AcpiDmTableInfoMadt6;
1051            break;
1052        case ACPI_MADT_TYPE_LOCAL_SAPIC:
1053            InfoTable = AcpiDmTableInfoMadt7;
1054            break;
1055        case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
1056            InfoTable = AcpiDmTableInfoMadt8;
1057            break;
1058        case ACPI_MADT_TYPE_LOCAL_X2APIC:
1059            InfoTable = AcpiDmTableInfoMadt9;
1060            break;
1061        case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
1062            InfoTable = AcpiDmTableInfoMadt10;
1063            break;
1064        default:
1065            AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type);
1066
1067            /* Attempt to continue */
1068
1069            if (!SubTable->Length)
1070            {
1071                AcpiOsPrintf ("Invalid zero length subtable\n");
1072                return;
1073            }
1074            goto NextSubTable;
1075        }
1076
1077        Status = AcpiDmDumpTable (Length, Offset, SubTable,
1078                    SubTable->Length, InfoTable);
1079        if (ACPI_FAILURE (Status))
1080        {
1081            return;
1082        }
1083
1084NextSubTable:
1085        /* Point to next sub-table */
1086
1087        Offset += SubTable->Length;
1088        SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1089    }
1090}
1091
1092
1093/*******************************************************************************
1094 *
1095 * FUNCTION:    AcpiDmDumpMcfg
1096 *
1097 * PARAMETERS:  Table               - A MCFG Table
1098 *
1099 * RETURN:      None
1100 *
1101 * DESCRIPTION: Format the contents of a MCFG table
1102 *
1103 ******************************************************************************/
1104
1105void
1106AcpiDmDumpMcfg (
1107    ACPI_TABLE_HEADER       *Table)
1108{
1109    ACPI_STATUS             Status;
1110    UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
1111    ACPI_MCFG_ALLOCATION    *SubTable;
1112
1113
1114    /* Main table */
1115
1116    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1117    if (ACPI_FAILURE (Status))
1118    {
1119        return;
1120    }
1121
1122    /* Sub-tables */
1123
1124    SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1125    while (Offset < Table->Length)
1126    {
1127        if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1128        {
1129            AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1130                sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1131            return;
1132        }
1133
1134        AcpiOsPrintf ("\n");
1135        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1136                    sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1137        if (ACPI_FAILURE (Status))
1138        {
1139            return;
1140        }
1141
1142        /* Point to next sub-table (each subtable is of fixed length) */
1143
1144        Offset += sizeof (ACPI_MCFG_ALLOCATION);
1145        SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
1146                        sizeof (ACPI_MCFG_ALLOCATION));
1147    }
1148}
1149
1150
1151/*******************************************************************************
1152 *
1153 * FUNCTION:    AcpiDmDumpMsct
1154 *
1155 * PARAMETERS:  Table               - A MSCT table
1156 *
1157 * RETURN:      None
1158 *
1159 * DESCRIPTION: Format the contents of a MSCT
1160 *
1161 ******************************************************************************/
1162
1163void
1164AcpiDmDumpMsct (
1165    ACPI_TABLE_HEADER       *Table)
1166{
1167    ACPI_STATUS             Status;
1168    UINT32                  Offset = sizeof (ACPI_TABLE_MSCT);
1169    ACPI_MSCT_PROXIMITY     *SubTable;
1170
1171
1172    /* Main table */
1173
1174    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1175    if (ACPI_FAILURE (Status))
1176    {
1177        return;
1178    }
1179
1180    /* Sub-tables */
1181
1182    SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1183    while (Offset < Table->Length)
1184    {
1185        /* Common sub-table header */
1186
1187        AcpiOsPrintf ("\n");
1188        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1189                    sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1190        if (ACPI_FAILURE (Status))
1191        {
1192            return;
1193        }
1194
1195        /* Point to next sub-table */
1196
1197        Offset += sizeof (ACPI_MSCT_PROXIMITY);
1198        SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
1199    }
1200}
1201
1202
1203/*******************************************************************************
1204 *
1205 * FUNCTION:    AcpiDmDumpSlit
1206 *
1207 * PARAMETERS:  Table               - An SLIT
1208 *
1209 * RETURN:      None
1210 *
1211 * DESCRIPTION: Format the contents of a SLIT
1212 *
1213 ******************************************************************************/
1214
1215void
1216AcpiDmDumpSlit (
1217    ACPI_TABLE_HEADER       *Table)
1218{
1219    ACPI_STATUS             Status;
1220    UINT32                  Offset;
1221    UINT8                   *Row;
1222    UINT32                  Localities;
1223    UINT32                  i;
1224    UINT32                  j;
1225
1226
1227    /* Main table */
1228
1229    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
1230    if (ACPI_FAILURE (Status))
1231    {
1232        return;
1233    }
1234
1235    /* Display the Locality NxN Matrix */
1236
1237    Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
1238    Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
1239    Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
1240
1241    for (i = 0; i < Localities; i++)
1242    {
1243        /* Display one row of the matrix */
1244
1245        AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
1246        for  (j = 0; j < Localities; j++)
1247        {
1248            /* Check for beyond EOT */
1249
1250            if (Offset >= Table->Length)
1251            {
1252                AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
1253                return;
1254            }
1255
1256            AcpiOsPrintf ("%2.2X", Row[j]);
1257            Offset++;
1258
1259            /* Display up to 16 bytes per output row */
1260
1261            if ((j+1) < Localities)
1262            {
1263                AcpiOsPrintf (",");
1264
1265                if (j && (((j+1) % 16) == 0))
1266                {
1267                    AcpiOsPrintf ("\n");
1268                    AcpiDmLineHeader (Offset, 0, "");
1269                }
1270            }
1271        }
1272
1273        /* Point to next row */
1274
1275        AcpiOsPrintf ("\n");
1276        Row += Localities;
1277    }
1278}
1279
1280
1281/*******************************************************************************
1282 *
1283 * FUNCTION:    AcpiDmDumpSrat
1284 *
1285 * PARAMETERS:  Table               - A SRAT table
1286 *
1287 * RETURN:      None
1288 *
1289 * DESCRIPTION: Format the contents of a SRAT
1290 *
1291 ******************************************************************************/
1292
1293void
1294AcpiDmDumpSrat (
1295    ACPI_TABLE_HEADER       *Table)
1296{
1297    ACPI_STATUS             Status;
1298    UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
1299    ACPI_SUBTABLE_HEADER    *SubTable;
1300    ACPI_DMTABLE_INFO       *InfoTable;
1301
1302
1303    /* Main table */
1304
1305    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
1306    if (ACPI_FAILURE (Status))
1307    {
1308        return;
1309    }
1310
1311    /* Sub-tables */
1312
1313    SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1314    while (Offset < Table->Length)
1315    {
1316        /* Common sub-table header */
1317
1318        AcpiOsPrintf ("\n");
1319        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1320                    SubTable->Length, AcpiDmTableInfoSratHdr);
1321        if (ACPI_FAILURE (Status))
1322        {
1323            return;
1324        }
1325
1326        switch (SubTable->Type)
1327        {
1328        case ACPI_SRAT_TYPE_CPU_AFFINITY:
1329            InfoTable = AcpiDmTableInfoSrat0;
1330            break;
1331        case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1332            InfoTable = AcpiDmTableInfoSrat1;
1333            break;
1334        case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1335            InfoTable = AcpiDmTableInfoSrat2;
1336            break;
1337        default:
1338            AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type);
1339
1340            /* Attempt to continue */
1341
1342            if (!SubTable->Length)
1343            {
1344                AcpiOsPrintf ("Invalid zero length subtable\n");
1345                return;
1346            }
1347            goto NextSubTable;
1348        }
1349
1350        AcpiOsPrintf ("\n");
1351        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1352                    SubTable->Length, InfoTable);
1353        if (ACPI_FAILURE (Status))
1354        {
1355            return;
1356        }
1357
1358NextSubTable:
1359        /* Point to next sub-table */
1360
1361        Offset += SubTable->Length;
1362        SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1363    }
1364}
1365
1366
1367/*******************************************************************************
1368 *
1369 * FUNCTION:    AcpiDmDumpWdat
1370 *
1371 * PARAMETERS:  Table               - A WDAT table
1372 *
1373 * RETURN:      None
1374 *
1375 * DESCRIPTION: Format the contents of a WDAT
1376 *
1377 ******************************************************************************/
1378
1379void
1380AcpiDmDumpWdat (
1381    ACPI_TABLE_HEADER       *Table)
1382{
1383    ACPI_STATUS             Status;
1384    UINT32                  Offset = sizeof (ACPI_TABLE_WDAT);
1385    ACPI_WDAT_ENTRY         *SubTable;
1386
1387
1388    /* Main table */
1389
1390    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
1391    if (ACPI_FAILURE (Status))
1392    {
1393        return;
1394    }
1395
1396    /* Sub-tables */
1397
1398    SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
1399    while (Offset < Table->Length)
1400    {
1401        /* Common sub-table header */
1402
1403        AcpiOsPrintf ("\n");
1404        Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1405                    sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
1406        if (ACPI_FAILURE (Status))
1407        {
1408            return;
1409        }
1410
1411        /* Point to next sub-table */
1412
1413        Offset += sizeof (ACPI_WDAT_ENTRY);
1414        SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));
1415    }
1416}
1417