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