dmtbdump.c revision 1.1.1.12 1 /******************************************************************************
2 *
3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2017, 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 "acpi.h"
45 #include "accommon.h"
46 #include "acdisasm.h"
47 #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 /* Local prototypes */
56
57 static void
58 AcpiDmValidateFadtLength (
59 UINT32 Revision,
60 UINT32 Length);
61
62
63 /*******************************************************************************
64 *
65 * FUNCTION: AcpiDmDumpBuffer
66 *
67 * PARAMETERS: Table - ACPI Table or subtable
68 * BufferOffset - Offset of buffer from Table above
69 * Length - Length of the buffer
70 * AbsoluteOffset - Offset of buffer in the main ACPI table
71 * Header - Name of the buffer field (printed on the
72 * first line only.)
73 *
74 * RETURN: None
75 *
76 * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the
77 * disassembler output format.)
78 *
79 ******************************************************************************/
80
81 void
82 AcpiDmDumpBuffer (
83 void *Table,
84 UINT32 BufferOffset,
85 UINT32 Length,
86 UINT32 AbsoluteOffset,
87 char *Header)
88 {
89 UINT8 *Buffer;
90 UINT32 i;
91
92
93 if (!Length)
94 {
95 return;
96 }
97
98 Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset;
99 i = 0;
100
101 while (i < Length)
102 {
103 if (!(i % 16))
104 {
105 /* Insert a backslash - line continuation character */
106
107 if (Length > 16)
108 {
109 AcpiOsPrintf ("\\\n ");
110 }
111 }
112
113 AcpiOsPrintf ("%.02X ", *Buffer);
114 i++;
115 Buffer++;
116 AbsoluteOffset++;
117 }
118
119 AcpiOsPrintf ("\n");
120 }
121
122
123 /*******************************************************************************
124 *
125 * FUNCTION: AcpiDmDumpUnicode
126 *
127 * PARAMETERS: Table - ACPI Table or subtable
128 * BufferOffset - Offset of buffer from Table above
129 * ByteLength - Length of the buffer
130 *
131 * RETURN: None
132 *
133 * DESCRIPTION: Validate and dump the contents of a buffer that contains
134 * unicode data. The output is a standard ASCII string. If it
135 * appears that the data is not unicode, the buffer is dumped
136 * as hex characters.
137 *
138 ******************************************************************************/
139
140 void
141 AcpiDmDumpUnicode (
142 void *Table,
143 UINT32 BufferOffset,
144 UINT32 ByteLength)
145 {
146 UINT8 *Buffer;
147 UINT32 Length;
148 UINT32 i;
149
150
151 Buffer = ((UINT8 *) Table) + BufferOffset;
152 Length = ByteLength - 2; /* Last two bytes are the null terminator */
153
154 /* Ensure all low bytes are entirely printable ASCII */
155
156 for (i = 0; i < Length; i += 2)
157 {
158 if (!isprint (Buffer[i]))
159 {
160 goto DumpRawBuffer;
161 }
162 }
163
164 /* Ensure all high bytes are zero */
165
166 for (i = 1; i < Length; i += 2)
167 {
168 if (Buffer[i])
169 {
170 goto DumpRawBuffer;
171 }
172 }
173
174 /* Dump the buffer as a normal string */
175
176 AcpiOsPrintf ("\"");
177 for (i = 0; i < Length; i += 2)
178 {
179 AcpiOsPrintf ("%c", Buffer[i]);
180 }
181
182 AcpiOsPrintf ("\"\n");
183 return;
184
185 DumpRawBuffer:
186 AcpiDmDumpBuffer (Table, BufferOffset, ByteLength,
187 BufferOffset, NULL);
188 AcpiOsPrintf ("\n");
189 }
190
191
192 /*******************************************************************************
193 *
194 * FUNCTION: AcpiDmDumpRsdp
195 *
196 * PARAMETERS: Table - A RSDP
197 *
198 * RETURN: Length of the table (there is not always a length field,
199 * use revision or length if available (ACPI 2.0+))
200 *
201 * DESCRIPTION: Format the contents of a RSDP
202 *
203 ******************************************************************************/
204
205 UINT32
206 AcpiDmDumpRsdp (
207 ACPI_TABLE_HEADER *Table)
208 {
209 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
210 UINT32 Length = sizeof (ACPI_RSDP_COMMON);
211 UINT8 Checksum;
212 ACPI_STATUS Status;
213
214
215 /* Dump the common ACPI 1.0 portion */
216
217 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
218 if (ACPI_FAILURE (Status))
219 {
220 return (Length);
221 }
222
223 /* Validate the first checksum */
224
225 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
226 Rsdp->Checksum);
227 if (Checksum != Rsdp->Checksum)
228 {
229 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
230 Checksum);
231 }
232
233 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
234
235 if (Rsdp->Revision > 0)
236 {
237 Length = Rsdp->Length;
238 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
239 if (ACPI_FAILURE (Status))
240 {
241 return (Length);
242 }
243
244 /* Validate the extended checksum over entire RSDP */
245
246 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
247 Rsdp->ExtendedChecksum);
248 if (Checksum != Rsdp->ExtendedChecksum)
249 {
250 AcpiOsPrintf (
251 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
252 Checksum);
253 }
254 }
255
256 return (Length);
257 }
258
259
260 /*******************************************************************************
261 *
262 * FUNCTION: AcpiDmDumpRsdt
263 *
264 * PARAMETERS: Table - A RSDT
265 *
266 * RETURN: None
267 *
268 * DESCRIPTION: Format the contents of a RSDT
269 *
270 ******************************************************************************/
271
272 void
273 AcpiDmDumpRsdt (
274 ACPI_TABLE_HEADER *Table)
275 {
276 UINT32 *Array;
277 UINT32 Entries;
278 UINT32 Offset;
279 UINT32 i;
280
281
282 /* Point to start of table pointer array */
283
284 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
285 Offset = sizeof (ACPI_TABLE_HEADER);
286
287 /* RSDT uses 32-bit pointers */
288
289 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
290
291 for (i = 0; i < Entries; i++)
292 {
293 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
294 AcpiOsPrintf ("%8.8X\n", Array[i]);
295 Offset += sizeof (UINT32);
296 }
297 }
298
299
300 /*******************************************************************************
301 *
302 * FUNCTION: AcpiDmDumpXsdt
303 *
304 * PARAMETERS: Table - A XSDT
305 *
306 * RETURN: None
307 *
308 * DESCRIPTION: Format the contents of a XSDT
309 *
310 ******************************************************************************/
311
312 void
313 AcpiDmDumpXsdt (
314 ACPI_TABLE_HEADER *Table)
315 {
316 UINT64 *Array;
317 UINT32 Entries;
318 UINT32 Offset;
319 UINT32 i;
320
321
322 /* Point to start of table pointer array */
323
324 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
325 Offset = sizeof (ACPI_TABLE_HEADER);
326
327 /* XSDT uses 64-bit pointers */
328
329 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
330
331 for (i = 0; i < Entries; i++)
332 {
333 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
334 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
335 Offset += sizeof (UINT64);
336 }
337 }
338
339
340 /*******************************************************************************
341 *
342 * FUNCTION: AcpiDmDumpFadt
343 *
344 * PARAMETERS: Table - A FADT
345 *
346 * RETURN: None
347 *
348 * DESCRIPTION: Format the contents of a FADT
349 *
350 * NOTE: We cannot depend on the FADT version to indicate the actual
351 * contents of the FADT because of BIOS bugs. The table length
352 * is the only reliable indicator.
353 *
354 ******************************************************************************/
355
356 void
357 AcpiDmDumpFadt (
358 ACPI_TABLE_HEADER *Table)
359 {
360 ACPI_STATUS Status;
361
362
363 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
364
365 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
366 AcpiDmTableInfoFadt1);
367 if (ACPI_FAILURE (Status))
368 {
369 return;
370 }
371
372 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
373
374 if ((Table->Length > ACPI_FADT_V1_SIZE) &&
375 (Table->Length <= ACPI_FADT_V2_SIZE))
376 {
377 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
378 AcpiDmTableInfoFadt2);
379 if (ACPI_FAILURE (Status))
380 {
381 return;
382 }
383 }
384
385 /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */
386
387 else if (Table->Length > ACPI_FADT_V2_SIZE)
388 {
389 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
390 AcpiDmTableInfoFadt3);
391 if (ACPI_FAILURE (Status))
392 {
393 return;
394 }
395
396 /* Check for FADT revision 5 fields and up (ACPI 5.0+) */
397
398 if (Table->Length > ACPI_FADT_V3_SIZE)
399 {
400 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
401 AcpiDmTableInfoFadt5);
402 if (ACPI_FAILURE (Status))
403 {
404 return;
405 }
406 }
407
408 /* Check for FADT revision 6 fields and up (ACPI 6.0+) */
409
410 if (Table->Length > ACPI_FADT_V3_SIZE)
411 {
412 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
413 AcpiDmTableInfoFadt6);
414 if (ACPI_FAILURE (Status))
415 {
416 return;
417 }
418 }
419 }
420
421 /* Validate various fields in the FADT, including length */
422
423 AcpiTbCreateLocalFadt (Table, Table->Length);
424
425 /* Validate FADT length against the revision */
426
427 AcpiDmValidateFadtLength (Table->Revision, Table->Length);
428 }
429
430
431 /*******************************************************************************
432 *
433 * FUNCTION: AcpiDmValidateFadtLength
434 *
435 * PARAMETERS: Revision - FADT revision (Header->Revision)
436 * Length - FADT length (Header->Length
437 *
438 * RETURN: None
439 *
440 * DESCRIPTION: Check the FADT revision against the expected table length for
441 * that revision. Issue a warning if the length is not what was
442 * expected. This seems to be such a common BIOS bug that the
443 * FADT revision has been rendered virtually meaningless.
444 *
445 ******************************************************************************/
446
447 static void
448 AcpiDmValidateFadtLength (
449 UINT32 Revision,
450 UINT32 Length)
451 {
452 UINT32 ExpectedLength;
453
454
455 switch (Revision)
456 {
457 case 0:
458
459 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
460 return;
461
462 case 1:
463
464 ExpectedLength = ACPI_FADT_V1_SIZE;
465 break;
466
467 case 2:
468
469 ExpectedLength = ACPI_FADT_V2_SIZE;
470 break;
471
472 case 3:
473 case 4:
474
475 ExpectedLength = ACPI_FADT_V3_SIZE;
476 break;
477
478 case 5:
479
480 ExpectedLength = ACPI_FADT_V5_SIZE;
481 break;
482
483 default:
484
485 return;
486 }
487
488 if (Length == ExpectedLength)
489 {
490 return;
491 }
492
493 AcpiOsPrintf (
494 "\n// ACPI Warning: FADT revision %X does not match length: "
495 "found %X expected %X\n",
496 Revision, Length, ExpectedLength);
497 }
498
499
500 /*******************************************************************************
501 *
502 * FUNCTION: AcpiDmDumpAsf
503 *
504 * PARAMETERS: Table - A ASF table
505 *
506 * RETURN: None
507 *
508 * DESCRIPTION: Format the contents of a ASF table
509 *
510 ******************************************************************************/
511
512 void
513 AcpiDmDumpAsf (
514 ACPI_TABLE_HEADER *Table)
515 {
516 ACPI_STATUS Status;
517 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
518 ACPI_ASF_INFO *SubTable;
519 ACPI_DMTABLE_INFO *InfoTable;
520 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
521 UINT8 *DataTable = NULL;
522 UINT32 DataCount = 0;
523 UINT32 DataLength = 0;
524 UINT32 DataOffset = 0;
525 UINT32 i;
526 UINT8 Type;
527
528
529 /* No main table, only subtables */
530
531 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
532 while (Offset < Table->Length)
533 {
534 /* Common subtable header */
535
536 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
537 SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
538 if (ACPI_FAILURE (Status))
539 {
540 return;
541 }
542
543 /* The actual type is the lower 7 bits of Type */
544
545 Type = (UINT8) (SubTable->Header.Type & 0x7F);
546
547 switch (Type)
548 {
549 case ACPI_ASF_TYPE_INFO:
550
551 InfoTable = AcpiDmTableInfoAsf0;
552 break;
553
554 case ACPI_ASF_TYPE_ALERT:
555
556 InfoTable = AcpiDmTableInfoAsf1;
557 DataInfoTable = AcpiDmTableInfoAsf1a;
558 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
559 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
560 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
561 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
562 break;
563
564 case ACPI_ASF_TYPE_CONTROL:
565
566 InfoTable = AcpiDmTableInfoAsf2;
567 DataInfoTable = AcpiDmTableInfoAsf2a;
568 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
569 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
570 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
571 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
572 break;
573
574 case ACPI_ASF_TYPE_BOOT:
575
576 InfoTable = AcpiDmTableInfoAsf3;
577 break;
578
579 case ACPI_ASF_TYPE_ADDRESS:
580
581 InfoTable = AcpiDmTableInfoAsf4;
582 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
583 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
584 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
585 break;
586
587 default:
588
589 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
590 SubTable->Header.Type);
591 return;
592 }
593
594 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
595 SubTable->Header.Length, InfoTable);
596 if (ACPI_FAILURE (Status))
597 {
598 return;
599 }
600
601 /* Dump variable-length extra data */
602
603 switch (Type)
604 {
605 case ACPI_ASF_TYPE_ALERT:
606 case ACPI_ASF_TYPE_CONTROL:
607
608 for (i = 0; i < DataCount; i++)
609 {
610 AcpiOsPrintf ("\n");
611 Status = AcpiDmDumpTable (Table->Length, DataOffset,
612 DataTable, DataLength, DataInfoTable);
613 if (ACPI_FAILURE (Status))
614 {
615 return;
616 }
617
618 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
619 DataOffset += DataLength;
620 }
621 break;
622
623 case ACPI_ASF_TYPE_ADDRESS:
624
625 for (i = 0; i < DataLength; i++)
626 {
627 if (!(i % 16))
628 {
629 AcpiDmLineHeader (DataOffset, 1, "Addresses");
630 }
631
632 AcpiOsPrintf ("%2.2X ", *DataTable);
633 DataTable++;
634 DataOffset++;
635
636 if (DataOffset > Table->Length)
637 {
638 AcpiOsPrintf (
639 "**** ACPI table terminates in the middle of a "
640 "data structure! (ASF! table)\n");
641 return;
642 }
643 }
644
645 AcpiOsPrintf ("\n");
646 break;
647
648 default:
649
650 break;
651 }
652
653 AcpiOsPrintf ("\n");
654
655 /* Point to next subtable */
656
657 if (!SubTable->Header.Length)
658 {
659 AcpiOsPrintf ("Invalid zero subtable header length\n");
660 return;
661 }
662
663 Offset += SubTable->Header.Length;
664 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable,
665 SubTable->Header.Length);
666 }
667 }
668
669
670 /*******************************************************************************
671 *
672 * FUNCTION: AcpiDmDumpCpep
673 *
674 * PARAMETERS: Table - A CPEP table
675 *
676 * RETURN: None
677 *
678 * DESCRIPTION: Format the contents of a CPEP. This table type consists
679 * of an open-ended number of subtables.
680 *
681 ******************************************************************************/
682
683 void
684 AcpiDmDumpCpep (
685 ACPI_TABLE_HEADER *Table)
686 {
687 ACPI_STATUS Status;
688 ACPI_CPEP_POLLING *SubTable;
689 UINT32 Length = Table->Length;
690 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
691
692
693 /* Main table */
694
695 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
696 if (ACPI_FAILURE (Status))
697 {
698 return;
699 }
700
701 /* Subtables */
702
703 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
704 while (Offset < Table->Length)
705 {
706 AcpiOsPrintf ("\n");
707 Status = AcpiDmDumpTable (Length, Offset, SubTable,
708 SubTable->Header.Length, AcpiDmTableInfoCpep0);
709 if (ACPI_FAILURE (Status))
710 {
711 return;
712 }
713
714 /* Point to next subtable */
715
716 Offset += SubTable->Header.Length;
717 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
718 SubTable->Header.Length);
719 }
720 }
721
722
723 /*******************************************************************************
724 *
725 * FUNCTION: AcpiDmDumpCsrt
726 *
727 * PARAMETERS: Table - A CSRT table
728 *
729 * RETURN: None
730 *
731 * DESCRIPTION: Format the contents of a CSRT. This table type consists
732 * of an open-ended number of subtables.
733 *
734 ******************************************************************************/
735
736 void
737 AcpiDmDumpCsrt (
738 ACPI_TABLE_HEADER *Table)
739 {
740 ACPI_STATUS Status;
741 ACPI_CSRT_GROUP *SubTable;
742 ACPI_CSRT_SHARED_INFO *SharedInfoTable;
743 ACPI_CSRT_DESCRIPTOR *SubSubTable;
744 UINT32 Length = Table->Length;
745 UINT32 Offset = sizeof (ACPI_TABLE_CSRT);
746 UINT32 SubOffset;
747 UINT32 SubSubOffset;
748 UINT32 InfoLength;
749
750
751 /* The main table only contains the ACPI header, thus already handled */
752
753 /* Subtables (Resource Groups) */
754
755 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
756 while (Offset < Table->Length)
757 {
758 /* Resource group subtable */
759
760 AcpiOsPrintf ("\n");
761 Status = AcpiDmDumpTable (Length, Offset, SubTable,
762 SubTable->Length, AcpiDmTableInfoCsrt0);
763 if (ACPI_FAILURE (Status))
764 {
765 return;
766 }
767
768 /* Shared info subtable (One per resource group) */
769
770 SubOffset = sizeof (ACPI_CSRT_GROUP);
771 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
772 Offset + SubOffset);
773
774 AcpiOsPrintf ("\n");
775 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
776 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
777 if (ACPI_FAILURE (Status))
778 {
779 return;
780 }
781
782 SubOffset += SubTable->SharedInfoLength;
783
784 /* Sub-Subtables (Resource Descriptors) */
785
786 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
787 Offset + SubOffset);
788
789 while ((SubOffset < SubTable->Length) &&
790 ((Offset + SubOffset) < Table->Length))
791 {
792 AcpiOsPrintf ("\n");
793 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
794 SubSubTable->Length, AcpiDmTableInfoCsrt2);
795 if (ACPI_FAILURE (Status))
796 {
797 return;
798 }
799
800 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
801
802 /* Resource-specific info buffer */
803
804 InfoLength = SubSubTable->Length - SubSubOffset;
805 if (InfoLength)
806 {
807 Status = AcpiDmDumpTable (Length,
808 Offset + SubOffset + SubSubOffset, Table,
809 InfoLength, AcpiDmTableInfoCsrt2a);
810 if (ACPI_FAILURE (Status))
811 {
812 return;
813 }
814 SubSubOffset += InfoLength;
815 }
816
817 /* Point to next sub-subtable */
818
819 SubOffset += SubSubTable->Length;
820 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
821 SubSubTable->Length);
822 }
823
824 /* Point to next subtable */
825
826 Offset += SubTable->Length;
827 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
828 SubTable->Length);
829 }
830 }
831
832
833 /*******************************************************************************
834 *
835 * FUNCTION: AcpiDmDumpDbg2
836 *
837 * PARAMETERS: Table - A DBG2 table
838 *
839 * RETURN: None
840 *
841 * DESCRIPTION: Format the contents of a DBG2. This table type consists
842 * of an open-ended number of subtables.
843 *
844 ******************************************************************************/
845
846 void
847 AcpiDmDumpDbg2 (
848 ACPI_TABLE_HEADER *Table)
849 {
850 ACPI_STATUS Status;
851 ACPI_DBG2_DEVICE *SubTable;
852 UINT32 Length = Table->Length;
853 UINT32 Offset = sizeof (ACPI_TABLE_DBG2);
854 UINT32 i;
855 UINT32 ArrayOffset;
856 UINT32 AbsoluteOffset;
857 UINT8 *Array;
858
859
860 /* Main table */
861
862 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
863 if (ACPI_FAILURE (Status))
864 {
865 return;
866 }
867
868 /* Subtables */
869
870 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
871 while (Offset < Table->Length)
872 {
873 AcpiOsPrintf ("\n");
874 Status = AcpiDmDumpTable (Length, Offset, SubTable,
875 SubTable->Length, AcpiDmTableInfoDbg2Device);
876 if (ACPI_FAILURE (Status))
877 {
878 return;
879 }
880
881 /* Dump the BaseAddress array */
882
883 for (i = 0; i < SubTable->RegisterCount; i++)
884 {
885 ArrayOffset = SubTable->BaseAddressOffset +
886 (sizeof (ACPI_GENERIC_ADDRESS) * i);
887 AbsoluteOffset = Offset + ArrayOffset;
888 Array = (UINT8 *) SubTable + ArrayOffset;
889
890 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
891 SubTable->Length, AcpiDmTableInfoDbg2Addr);
892 if (ACPI_FAILURE (Status))
893 {
894 return;
895 }
896 }
897
898 /* Dump the AddressSize array */
899
900 for (i = 0; i < SubTable->RegisterCount; i++)
901 {
902 ArrayOffset = SubTable->AddressSizeOffset +
903 (sizeof (UINT32) * i);
904 AbsoluteOffset = Offset + ArrayOffset;
905 Array = (UINT8 *) SubTable + ArrayOffset;
906
907 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
908 SubTable->Length, AcpiDmTableInfoDbg2Size);
909 if (ACPI_FAILURE (Status))
910 {
911 return;
912 }
913 }
914
915 /* Dump the Namestring (required) */
916
917 AcpiOsPrintf ("\n");
918 ArrayOffset = SubTable->NamepathOffset;
919 AbsoluteOffset = Offset + ArrayOffset;
920 Array = (UINT8 *) SubTable + ArrayOffset;
921
922 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
923 SubTable->Length, AcpiDmTableInfoDbg2Name);
924 if (ACPI_FAILURE (Status))
925 {
926 return;
927 }
928
929 /* Dump the OemData (optional) */
930
931 if (SubTable->OemDataOffset)
932 {
933 Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset,
934 Table, SubTable->OemDataLength,
935 AcpiDmTableInfoDbg2OemData);
936 if (ACPI_FAILURE (Status))
937 {
938 return;
939 }
940 }
941
942 /* Point to next subtable */
943
944 Offset += SubTable->Length;
945 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
946 SubTable->Length);
947 }
948 }
949
950
951 /*******************************************************************************
952 *
953 * FUNCTION: AcpiDmDumpDmar
954 *
955 * PARAMETERS: Table - A DMAR table
956 *
957 * RETURN: None
958 *
959 * DESCRIPTION: Format the contents of a DMAR. This table type consists
960 * of an open-ended number of subtables.
961 *
962 ******************************************************************************/
963
964 void
965 AcpiDmDumpDmar (
966 ACPI_TABLE_HEADER *Table)
967 {
968 ACPI_STATUS Status;
969 ACPI_DMAR_HEADER *SubTable;
970 UINT32 Length = Table->Length;
971 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
972 ACPI_DMTABLE_INFO *InfoTable;
973 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
974 UINT32 ScopeOffset;
975 UINT8 *PciPath;
976 UINT32 PathOffset;
977
978
979 /* Main table */
980
981 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
982 if (ACPI_FAILURE (Status))
983 {
984 return;
985 }
986
987 /* Subtables */
988
989 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
990 while (Offset < Table->Length)
991 {
992 /* Common subtable header */
993
994 AcpiOsPrintf ("\n");
995 Status = AcpiDmDumpTable (Length, Offset, SubTable,
996 SubTable->Length, AcpiDmTableInfoDmarHdr);
997 if (ACPI_FAILURE (Status))
998 {
999 return;
1000 }
1001
1002 AcpiOsPrintf ("\n");
1003
1004 switch (SubTable->Type)
1005 {
1006 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
1007
1008 InfoTable = AcpiDmTableInfoDmar0;
1009 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
1010 break;
1011
1012 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
1013
1014 InfoTable = AcpiDmTableInfoDmar1;
1015 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
1016 break;
1017
1018 case ACPI_DMAR_TYPE_ROOT_ATS:
1019
1020 InfoTable = AcpiDmTableInfoDmar2;
1021 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
1022 break;
1023
1024 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
1025
1026 InfoTable = AcpiDmTableInfoDmar3;
1027 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
1028 break;
1029
1030 case ACPI_DMAR_TYPE_NAMESPACE:
1031
1032 InfoTable = AcpiDmTableInfoDmar4;
1033 ScopeOffset = sizeof (ACPI_DMAR_ANDD);
1034 break;
1035
1036 default:
1037
1038 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
1039 SubTable->Type);
1040 return;
1041 }
1042
1043 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1044 SubTable->Length, InfoTable);
1045 if (ACPI_FAILURE (Status))
1046 {
1047 return;
1048 }
1049
1050 /*
1051 * Dump the optional device scope entries
1052 */
1053 if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
1054 (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE))
1055 {
1056 /* These types do not support device scopes */
1057
1058 goto NextSubtable;
1059 }
1060
1061 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
1062 while (ScopeOffset < SubTable->Length)
1063 {
1064 AcpiOsPrintf ("\n");
1065 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
1066 ScopeTable->Length, AcpiDmTableInfoDmarScope);
1067 if (ACPI_FAILURE (Status))
1068 {
1069 return;
1070 }
1071 AcpiOsPrintf ("\n");
1072
1073 /* Dump the PCI Path entries for this device scope */
1074
1075 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
1076
1077 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
1078 sizeof (ACPI_DMAR_DEVICE_SCOPE));
1079
1080 while (PathOffset < ScopeTable->Length)
1081 {
1082 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
1083 "PCI Path");
1084 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
1085
1086 /* Point to next PCI Path entry */
1087
1088 PathOffset += 2;
1089 PciPath += 2;
1090 AcpiOsPrintf ("\n");
1091 }
1092
1093 /* Point to next device scope entry */
1094
1095 ScopeOffset += ScopeTable->Length;
1096 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
1097 ScopeTable, ScopeTable->Length);
1098 }
1099
1100 NextSubtable:
1101 /* Point to next subtable */
1102
1103 Offset += SubTable->Length;
1104 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable,
1105 SubTable->Length);
1106 }
1107 }
1108
1109
1110 /*******************************************************************************
1111 *
1112 * FUNCTION: AcpiDmDumpDrtm
1113 *
1114 * PARAMETERS: Table - A DRTM table
1115 *
1116 * RETURN: None
1117 *
1118 * DESCRIPTION: Format the contents of a DRTM.
1119 *
1120 ******************************************************************************/
1121
1122 void
1123 AcpiDmDumpDrtm (
1124 ACPI_TABLE_HEADER *Table)
1125 {
1126 ACPI_STATUS Status;
1127 UINT32 Offset;
1128 ACPI_DRTM_VTABLE_LIST *DrtmVtl;
1129 ACPI_DRTM_RESOURCE_LIST *DrtmRl;
1130 ACPI_DRTM_DPS_ID *DrtmDps;
1131 UINT32 Count;
1132
1133
1134 /* Main table */
1135
1136 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
1137 AcpiDmTableInfoDrtm);
1138 if (ACPI_FAILURE (Status))
1139 {
1140 return;
1141 }
1142
1143 Offset = sizeof (ACPI_TABLE_DRTM);
1144
1145 /* Sub-tables */
1146
1147 /* Dump ValidatedTable length */
1148
1149 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
1150 AcpiOsPrintf ("\n");
1151 Status = AcpiDmDumpTable (Table->Length, Offset,
1152 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
1153 AcpiDmTableInfoDrtm0);
1154 if (ACPI_FAILURE (Status))
1155 {
1156 return;
1157 }
1158
1159 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
1160
1161 /* Dump Validated table addresses */
1162
1163 Count = 0;
1164 while ((Offset < Table->Length) &&
1165 (DrtmVtl->ValidatedTableCount > Count))
1166 {
1167 Status = AcpiDmDumpTable (Table->Length, Offset,
1168 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
1169 AcpiDmTableInfoDrtm0a);
1170 if (ACPI_FAILURE (Status))
1171 {
1172 return;
1173 }
1174
1175 Offset += sizeof (UINT64);
1176 Count++;
1177 }
1178
1179 /* Dump ResourceList length */
1180
1181 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
1182 AcpiOsPrintf ("\n");
1183 Status = AcpiDmDumpTable (Table->Length, Offset,
1184 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
1185 AcpiDmTableInfoDrtm1);
1186 if (ACPI_FAILURE (Status))
1187 {
1188 return;
1189 }
1190
1191 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
1192
1193 /* Dump the Resource List */
1194
1195 Count = 0;
1196 while ((Offset < Table->Length) &&
1197 (DrtmRl->ResourceCount > Count))
1198 {
1199 Status = AcpiDmDumpTable (Table->Length, Offset,
1200 ACPI_ADD_PTR (void, Table, Offset),
1201 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
1202 if (ACPI_FAILURE (Status))
1203 {
1204 return;
1205 }
1206
1207 Offset += sizeof (ACPI_DRTM_RESOURCE);
1208 Count++;
1209 }
1210
1211 /* Dump DPS */
1212
1213 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
1214 AcpiOsPrintf ("\n");
1215 (void) AcpiDmDumpTable (Table->Length, Offset,
1216 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
1217 }
1218
1219
1220 /*******************************************************************************
1221 *
1222 * FUNCTION: AcpiDmDumpEinj
1223 *
1224 * PARAMETERS: Table - A EINJ table
1225 *
1226 * RETURN: None
1227 *
1228 * DESCRIPTION: Format the contents of a EINJ. This table type consists
1229 * of an open-ended number of subtables.
1230 *
1231 ******************************************************************************/
1232
1233 void
1234 AcpiDmDumpEinj (
1235 ACPI_TABLE_HEADER *Table)
1236 {
1237 ACPI_STATUS Status;
1238 ACPI_WHEA_HEADER *SubTable;
1239 UINT32 Length = Table->Length;
1240 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
1241
1242
1243 /* Main table */
1244
1245 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
1246 if (ACPI_FAILURE (Status))
1247 {
1248 return;
1249 }
1250
1251 /* Subtables */
1252
1253 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1254 while (Offset < Table->Length)
1255 {
1256 AcpiOsPrintf ("\n");
1257 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1258 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
1259 if (ACPI_FAILURE (Status))
1260 {
1261 return;
1262 }
1263
1264 /* Point to next subtable (each subtable is of fixed length) */
1265
1266 Offset += sizeof (ACPI_WHEA_HEADER);
1267 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1268 sizeof (ACPI_WHEA_HEADER));
1269 }
1270 }
1271
1272
1273 /*******************************************************************************
1274 *
1275 * FUNCTION: AcpiDmDumpErst
1276 *
1277 * PARAMETERS: Table - A ERST table
1278 *
1279 * RETURN: None
1280 *
1281 * DESCRIPTION: Format the contents of a ERST. This table type consists
1282 * of an open-ended number of subtables.
1283 *
1284 ******************************************************************************/
1285
1286 void
1287 AcpiDmDumpErst (
1288 ACPI_TABLE_HEADER *Table)
1289 {
1290 ACPI_STATUS Status;
1291 ACPI_WHEA_HEADER *SubTable;
1292 UINT32 Length = Table->Length;
1293 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
1294
1295
1296 /* Main table */
1297
1298 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1299 if (ACPI_FAILURE (Status))
1300 {
1301 return;
1302 }
1303
1304 /* Subtables */
1305
1306 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1307 while (Offset < Table->Length)
1308 {
1309 AcpiOsPrintf ("\n");
1310 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1311 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1312 if (ACPI_FAILURE (Status))
1313 {
1314 return;
1315 }
1316
1317 /* Point to next subtable (each subtable is of fixed length) */
1318
1319 Offset += sizeof (ACPI_WHEA_HEADER);
1320 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1321 sizeof (ACPI_WHEA_HEADER));
1322 }
1323 }
1324
1325
1326 /*******************************************************************************
1327 *
1328 * FUNCTION: AcpiDmDumpFpdt
1329 *
1330 * PARAMETERS: Table - A FPDT table
1331 *
1332 * RETURN: None
1333 *
1334 * DESCRIPTION: Format the contents of a FPDT. This table type consists
1335 * of an open-ended number of subtables.
1336 *
1337 ******************************************************************************/
1338
1339 void
1340 AcpiDmDumpFpdt (
1341 ACPI_TABLE_HEADER *Table)
1342 {
1343 ACPI_STATUS Status;
1344 ACPI_FPDT_HEADER *SubTable;
1345 UINT32 Length = Table->Length;
1346 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
1347 ACPI_DMTABLE_INFO *InfoTable;
1348
1349
1350 /* There is no main table (other than the standard ACPI header) */
1351
1352 /* Subtables */
1353
1354 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
1355 while (Offset < Table->Length)
1356 {
1357 /* Common subtable header */
1358
1359 AcpiOsPrintf ("\n");
1360 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1361 SubTable->Length, AcpiDmTableInfoFpdtHdr);
1362 if (ACPI_FAILURE (Status))
1363 {
1364 return;
1365 }
1366
1367 switch (SubTable->Type)
1368 {
1369 case ACPI_FPDT_TYPE_BOOT:
1370
1371 InfoTable = AcpiDmTableInfoFpdt0;
1372 break;
1373
1374 case ACPI_FPDT_TYPE_S3PERF:
1375
1376 InfoTable = AcpiDmTableInfoFpdt1;
1377 break;
1378
1379 default:
1380
1381 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
1382 SubTable->Type);
1383
1384 /* Attempt to continue */
1385
1386 if (!SubTable->Length)
1387 {
1388 AcpiOsPrintf ("Invalid zero length subtable\n");
1389 return;
1390 }
1391 goto NextSubTable;
1392 }
1393
1394 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1395 SubTable->Length, InfoTable);
1396 if (ACPI_FAILURE (Status))
1397 {
1398 return;
1399 }
1400
1401 NextSubTable:
1402 /* Point to next subtable */
1403
1404 Offset += SubTable->Length;
1405 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable,
1406 SubTable->Length);
1407 }
1408 }
1409
1410
1411 /*******************************************************************************
1412 *
1413 * FUNCTION: AcpiDmDumpGtdt
1414 *
1415 * PARAMETERS: Table - A GTDT table
1416 *
1417 * RETURN: None
1418 *
1419 * DESCRIPTION: Format the contents of a GTDT. This table type consists
1420 * of an open-ended number of subtables.
1421 *
1422 ******************************************************************************/
1423
1424 void
1425 AcpiDmDumpGtdt (
1426 ACPI_TABLE_HEADER *Table)
1427 {
1428 ACPI_STATUS Status;
1429 ACPI_GTDT_HEADER *SubTable;
1430 UINT32 Length = Table->Length;
1431 UINT32 Offset = sizeof (ACPI_TABLE_GTDT);
1432 ACPI_DMTABLE_INFO *InfoTable;
1433 UINT32 SubTableLength;
1434 UINT32 GtCount;
1435 ACPI_GTDT_TIMER_ENTRY *GtxTable;
1436
1437
1438 /* Main table */
1439
1440 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
1441 if (ACPI_FAILURE (Status))
1442 {
1443 return;
1444 }
1445
1446 /* Subtables */
1447
1448 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1449 while (Offset < Table->Length)
1450 {
1451 /* Common subtable header */
1452
1453 AcpiOsPrintf ("\n");
1454 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1455 SubTable->Length, AcpiDmTableInfoGtdtHdr);
1456 if (ACPI_FAILURE (Status))
1457 {
1458 return;
1459 }
1460
1461 GtCount = 0;
1462 switch (SubTable->Type)
1463 {
1464 case ACPI_GTDT_TYPE_TIMER_BLOCK:
1465
1466 SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
1467 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1468 SubTable))->TimerCount;
1469
1470 InfoTable = AcpiDmTableInfoGtdt0;
1471 break;
1472
1473 case ACPI_GTDT_TYPE_WATCHDOG:
1474
1475 SubTableLength = sizeof (ACPI_GTDT_WATCHDOG);
1476
1477 InfoTable = AcpiDmTableInfoGtdt1;
1478 break;
1479
1480 default:
1481
1482 /* Cannot continue on unknown type - no length */
1483
1484 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
1485 SubTable->Type);
1486 return;
1487 }
1488
1489 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1490 SubTable->Length, InfoTable);
1491 if (ACPI_FAILURE (Status))
1492 {
1493 return;
1494 }
1495
1496 /* Point to end of current subtable (each subtable above is of fixed length) */
1497
1498 Offset += SubTableLength;
1499
1500 /* If there are any Gt Timer Blocks from above, dump them now */
1501
1502 if (GtCount)
1503 {
1504 GtxTable = ACPI_ADD_PTR (
1505 ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength);
1506 SubTableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
1507
1508 while (GtCount)
1509 {
1510 AcpiOsPrintf ("\n");
1511 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
1512 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
1513 if (ACPI_FAILURE (Status))
1514 {
1515 return;
1516 }
1517 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
1518 GtxTable++;
1519 GtCount--;
1520 }
1521 }
1522
1523 /* Point to next subtable */
1524
1525 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, SubTable, SubTableLength);
1526 }
1527 }
1528
1529
1530 /*******************************************************************************
1531 *
1532 * FUNCTION: AcpiDmDumpHest
1533 *
1534 * PARAMETERS: Table - A HEST table
1535 *
1536 * RETURN: None
1537 *
1538 * DESCRIPTION: Format the contents of a HEST. This table type consists
1539 * of an open-ended number of subtables.
1540 *
1541 ******************************************************************************/
1542
1543 void
1544 AcpiDmDumpHest (
1545 ACPI_TABLE_HEADER *Table)
1546 {
1547 ACPI_STATUS Status;
1548 ACPI_HEST_HEADER *SubTable;
1549 UINT32 Length = Table->Length;
1550 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
1551 ACPI_DMTABLE_INFO *InfoTable;
1552 UINT32 SubTableLength;
1553 UINT32 BankCount;
1554 ACPI_HEST_IA_ERROR_BANK *BankTable;
1555
1556
1557 /* Main table */
1558
1559 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1560 if (ACPI_FAILURE (Status))
1561 {
1562 return;
1563 }
1564
1565 /* Subtables */
1566
1567 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1568 while (Offset < Table->Length)
1569 {
1570 BankCount = 0;
1571 switch (SubTable->Type)
1572 {
1573 case ACPI_HEST_TYPE_IA32_CHECK:
1574
1575 InfoTable = AcpiDmTableInfoHest0;
1576 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1577 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1578 SubTable))->NumHardwareBanks;
1579 break;
1580
1581 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1582
1583 InfoTable = AcpiDmTableInfoHest1;
1584 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1585 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1586 SubTable))->NumHardwareBanks;
1587 break;
1588
1589 case ACPI_HEST_TYPE_IA32_NMI:
1590
1591 InfoTable = AcpiDmTableInfoHest2;
1592 SubTableLength = sizeof (ACPI_HEST_IA_NMI);
1593 break;
1594
1595 case ACPI_HEST_TYPE_AER_ROOT_PORT:
1596
1597 InfoTable = AcpiDmTableInfoHest6;
1598 SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
1599 break;
1600
1601 case ACPI_HEST_TYPE_AER_ENDPOINT:
1602
1603 InfoTable = AcpiDmTableInfoHest7;
1604 SubTableLength = sizeof (ACPI_HEST_AER);
1605 break;
1606
1607 case ACPI_HEST_TYPE_AER_BRIDGE:
1608
1609 InfoTable = AcpiDmTableInfoHest8;
1610 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1611 break;
1612
1613 case ACPI_HEST_TYPE_GENERIC_ERROR:
1614
1615 InfoTable = AcpiDmTableInfoHest9;
1616 SubTableLength = sizeof (ACPI_HEST_GENERIC);
1617 break;
1618
1619 case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
1620
1621 InfoTable = AcpiDmTableInfoHest10;
1622 SubTableLength = sizeof (ACPI_HEST_GENERIC_V2);
1623 break;
1624
1625 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1626
1627 InfoTable = AcpiDmTableInfoHest11;
1628 SubTableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK);
1629 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
1630 SubTable))->NumHardwareBanks;
1631 break;
1632
1633 default:
1634
1635 /* Cannot continue on unknown type - no length */
1636
1637 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
1638 SubTable->Type);
1639 return;
1640 }
1641
1642 AcpiOsPrintf ("\n");
1643 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1644 SubTableLength, InfoTable);
1645 if (ACPI_FAILURE (Status))
1646 {
1647 return;
1648 }
1649
1650 /* Point to end of current subtable (each subtable above is of fixed length) */
1651
1652 Offset += SubTableLength;
1653
1654 /* If there are any (fixed-length) Error Banks from above, dump them now */
1655
1656 if (BankCount)
1657 {
1658 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable,
1659 SubTableLength);
1660 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1661
1662 while (BankCount)
1663 {
1664 AcpiOsPrintf ("\n");
1665 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1666 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1667 if (ACPI_FAILURE (Status))
1668 {
1669 return;
1670 }
1671
1672 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1673 BankTable++;
1674 BankCount--;
1675 }
1676 }
1677
1678 /* Point to next subtable */
1679
1680 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
1681 }
1682 }
1683
1684
1685 /*******************************************************************************
1686 *
1687 * FUNCTION: AcpiDmDumpHmat
1688 *
1689 * PARAMETERS: Table - A HMAT table
1690 *
1691 * RETURN: None
1692 *
1693 * DESCRIPTION: Format the contents of a HMAT.
1694 *
1695 ******************************************************************************/
1696
1697 void
1698 AcpiDmDumpHmat (
1699 ACPI_TABLE_HEADER *Table)
1700 {
1701 ACPI_STATUS Status;
1702 ACPI_HMAT_STRUCTURE *HmatStruct;
1703 ACPI_HMAT_LOCALITY *HmatLocality;
1704 ACPI_HMAT_CACHE *HmatCache;
1705 UINT32 Offset;
1706 UINT32 SubTableOffset;
1707 UINT32 Length;
1708 ACPI_DMTABLE_INFO *InfoTable;
1709 UINT32 i, j;
1710
1711
1712 /* Main table */
1713
1714 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat);
1715 if (ACPI_FAILURE (Status))
1716 {
1717 return;
1718 }
1719 Offset = sizeof (ACPI_TABLE_HMAT);
1720
1721 while (Offset < Table->Length)
1722 {
1723 AcpiOsPrintf ("\n");
1724 SubTableOffset = 0;
1725
1726 /* Dump HMAT structure header */
1727
1728 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset);
1729 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE))
1730 {
1731 AcpiOsPrintf ("Invalid HMAT structure length\n");
1732 return;
1733 }
1734 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1735 HmatStruct->Length, AcpiDmTableInfoHmatHdr);
1736 if (ACPI_FAILURE (Status))
1737 {
1738 return;
1739 }
1740
1741 switch (HmatStruct->Type)
1742 {
1743 case ACPI_HMAT_TYPE_ADDRESS_RANGE:
1744
1745 InfoTable = AcpiDmTableInfoHmat0;
1746 Length = sizeof (ACPI_HMAT_ADDRESS_RANGE);
1747 break;
1748
1749 case ACPI_HMAT_TYPE_LOCALITY:
1750
1751 InfoTable = AcpiDmTableInfoHmat1;
1752 Length = sizeof (ACPI_HMAT_LOCALITY);
1753 break;
1754
1755 case ACPI_HMAT_TYPE_CACHE:
1756
1757 InfoTable = AcpiDmTableInfoHmat2;
1758 Length = sizeof (ACPI_HMAT_CACHE);
1759 break;
1760
1761 default:
1762
1763 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n",
1764 HmatStruct->Type);
1765
1766 /* Attempt to continue */
1767
1768 goto NextSubTable;
1769 }
1770
1771 /* Dump HMAT structure body */
1772
1773 if (HmatStruct->Length < Length)
1774 {
1775 AcpiOsPrintf ("Invalid HMAT structure length\n");
1776 return;
1777 }
1778 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1779 HmatStruct->Length, InfoTable);
1780 if (ACPI_FAILURE (Status))
1781 {
1782 return;
1783 }
1784
1785 /* Dump HMAT structure additionals */
1786
1787 switch (HmatStruct->Type)
1788 {
1789 case ACPI_HMAT_TYPE_LOCALITY:
1790
1791 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct);
1792 SubTableOffset = sizeof (ACPI_HMAT_LOCALITY);
1793
1794 /* Dump initiator proximity domains */
1795
1796 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1797 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4))
1798 {
1799 AcpiOsPrintf ("Invalid initiator proximity domain number\n");
1800 return;
1801 }
1802 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1803 {
1804 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1805 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1806 4, AcpiDmTableInfoHmat1a);
1807 SubTableOffset += 4;
1808 }
1809
1810 /* Dump target proximity domains */
1811
1812 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1813 (UINT32)(HmatLocality->NumberOfTargetPDs * 4))
1814 {
1815 AcpiOsPrintf ("Invalid target proximity domain number\n");
1816 return;
1817 }
1818 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++)
1819 {
1820 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1821 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1822 4, AcpiDmTableInfoHmat1b);
1823 SubTableOffset += 4;
1824 }
1825
1826 /* Dump latency/bandwidth entris */
1827
1828 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1829 (UINT32)(HmatLocality->NumberOfInitiatorPDs *
1830 HmatLocality->NumberOfTargetPDs * 2))
1831 {
1832 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n");
1833 return;
1834 }
1835 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1836 {
1837 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++)
1838 {
1839 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1840 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1841 2, AcpiDmTableInfoHmat1c);
1842 SubTableOffset += 2;
1843 }
1844 }
1845 break;
1846
1847 case ACPI_HMAT_TYPE_CACHE:
1848
1849 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct);
1850 SubTableOffset = sizeof (ACPI_HMAT_CACHE);
1851
1852 /* Dump SMBIOS handles */
1853
1854 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1855 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2))
1856 {
1857 AcpiOsPrintf ("Invalid SMBIOS handle number\n");
1858 return;
1859 }
1860 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++)
1861 {
1862 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1863 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1864 2, AcpiDmTableInfoHmat2a);
1865 SubTableOffset += 2;
1866 }
1867 break;
1868
1869 default:
1870
1871 break;
1872 }
1873
1874 NextSubTable:
1875 /* Point to next HMAT structure subtable */
1876
1877 Offset += (HmatStruct->Length);
1878 }
1879 }
1880
1881
1882 /*******************************************************************************
1883 *
1884 * FUNCTION: AcpiDmDumpIort
1885 *
1886 * PARAMETERS: Table - A IORT table
1887 *
1888 * RETURN: None
1889 *
1890 * DESCRIPTION: Format the contents of a IORT
1891 *
1892 ******************************************************************************/
1893
1894 void
1895 AcpiDmDumpIort (
1896 ACPI_TABLE_HEADER *Table)
1897 {
1898 ACPI_STATUS Status;
1899 ACPI_TABLE_IORT *Iort;
1900 ACPI_IORT_NODE *IortNode;
1901 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL;
1902 ACPI_IORT_SMMU *IortSmmu = NULL;
1903 UINT32 Offset;
1904 UINT32 NodeOffset;
1905 UINT32 Length;
1906 ACPI_DMTABLE_INFO *InfoTable;
1907 char *String;
1908 UINT32 i;
1909
1910
1911 /* Main table */
1912
1913 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
1914 if (ACPI_FAILURE (Status))
1915 {
1916 return;
1917 }
1918
1919 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
1920 Offset = sizeof (ACPI_TABLE_IORT);
1921
1922 /* Dump the OptionalPadding (optional) */
1923
1924 if (Iort->NodeOffset > Offset)
1925 {
1926 Status = AcpiDmDumpTable (Table->Length, Offset, Table,
1927 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
1928 if (ACPI_FAILURE (Status))
1929 {
1930 return;
1931 }
1932 }
1933
1934 Offset = Iort->NodeOffset;
1935 while (Offset < Table->Length)
1936 {
1937 /* Common subtable header */
1938
1939 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
1940 AcpiOsPrintf ("\n");
1941 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
1942 Status = AcpiDmDumpTable (Table->Length, Offset,
1943 IortNode, Length, AcpiDmTableInfoIortHdr);
1944 if (ACPI_FAILURE (Status))
1945 {
1946 return;
1947 }
1948
1949 NodeOffset = Length;
1950
1951 switch (IortNode->Type)
1952 {
1953 case ACPI_IORT_NODE_ITS_GROUP:
1954
1955 InfoTable = AcpiDmTableInfoIort0;
1956 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
1957 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
1958 break;
1959
1960 case ACPI_IORT_NODE_NAMED_COMPONENT:
1961
1962 InfoTable = AcpiDmTableInfoIort1;
1963 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
1964 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
1965 Length += strlen (String) + 1;
1966 break;
1967
1968 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
1969
1970 InfoTable = AcpiDmTableInfoIort2;
1971 Length = IortNode->Length - NodeOffset;
1972 break;
1973
1974 case ACPI_IORT_NODE_SMMU:
1975
1976 InfoTable = AcpiDmTableInfoIort3;
1977 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
1978 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
1979 break;
1980
1981 case ACPI_IORT_NODE_SMMU_V3:
1982
1983 InfoTable = AcpiDmTableInfoIort4;
1984 Length = IortNode->Length - NodeOffset;
1985 break;
1986
1987 default:
1988
1989 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
1990 IortNode->Type);
1991
1992 /* Attempt to continue */
1993
1994 if (!IortNode->Length)
1995 {
1996 AcpiOsPrintf ("Invalid zero length IORT node\n");
1997 return;
1998 }
1999 goto NextSubTable;
2000 }
2001
2002 /* Dump the node subtable header */
2003
2004 AcpiOsPrintf ("\n");
2005 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2006 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2007 Length, InfoTable);
2008 if (ACPI_FAILURE (Status))
2009 {
2010 return;
2011 }
2012
2013 NodeOffset += Length;
2014
2015 /* Dump the node specific data */
2016
2017 switch (IortNode->Type)
2018 {
2019 case ACPI_IORT_NODE_ITS_GROUP:
2020
2021 /* Validate IortItsGroup to avoid compiler warnings */
2022
2023 if (IortItsGroup)
2024 {
2025 for (i = 0; i < IortItsGroup->ItsCount; i++)
2026 {
2027 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2028 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2029 4, AcpiDmTableInfoIort0a);
2030 NodeOffset += 4;
2031 }
2032 }
2033 break;
2034
2035 case ACPI_IORT_NODE_NAMED_COMPONENT:
2036
2037 /* Dump the Padding (optional) */
2038
2039 if (IortNode->Length > NodeOffset)
2040 {
2041 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2042 Table, IortNode->Length - NodeOffset,
2043 AcpiDmTableInfoIort1a);
2044 if (ACPI_FAILURE (Status))
2045 {
2046 return;
2047 }
2048 }
2049 break;
2050
2051 case ACPI_IORT_NODE_SMMU:
2052
2053 AcpiOsPrintf ("\n");
2054
2055 /* Validate IortSmmu to avoid compiler warnings */
2056
2057 if (IortSmmu)
2058 {
2059 Length = 2 * sizeof (UINT64);
2060 NodeOffset = IortSmmu->GlobalInterruptOffset;
2061 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2062 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2063 Length, AcpiDmTableInfoIort3a);
2064 if (ACPI_FAILURE (Status))
2065 {
2066 return;
2067 }
2068
2069 NodeOffset = IortSmmu->ContextInterruptOffset;
2070 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
2071 {
2072 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2073 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2074 8, AcpiDmTableInfoIort3b);
2075 if (ACPI_FAILURE (Status))
2076 {
2077 return;
2078 }
2079
2080 NodeOffset += 8;
2081 }
2082
2083 NodeOffset = IortSmmu->PmuInterruptOffset;
2084 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
2085 {
2086 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2087 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2088 8, AcpiDmTableInfoIort3c);
2089 if (ACPI_FAILURE (Status))
2090 {
2091 return;
2092 }
2093
2094 NodeOffset += 8;
2095 }
2096 }
2097 break;
2098
2099 default:
2100
2101 break;
2102 }
2103
2104 /* Dump the ID mappings */
2105
2106 NodeOffset = IortNode->MappingOffset;
2107 for (i = 0; i < IortNode->MappingCount; i++)
2108 {
2109 AcpiOsPrintf ("\n");
2110 Length = sizeof (ACPI_IORT_ID_MAPPING);
2111 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2112 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2113 Length, AcpiDmTableInfoIortMap);
2114 if (ACPI_FAILURE (Status))
2115 {
2116 return;
2117 }
2118
2119 NodeOffset += Length;
2120 }
2121
2122 NextSubTable:
2123 /* Point to next node subtable */
2124
2125 Offset += IortNode->Length;
2126 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length);
2127 }
2128 }
2129
2130
2131 /*******************************************************************************
2132 *
2133 * FUNCTION: AcpiDmDumpIvrs
2134 *
2135 * PARAMETERS: Table - A IVRS table
2136 *
2137 * RETURN: None
2138 *
2139 * DESCRIPTION: Format the contents of a IVRS
2140 *
2141 ******************************************************************************/
2142
2143 static UINT8 EntrySizes[] = {4,8,16,32};
2144
2145 void
2146 AcpiDmDumpIvrs (
2147 ACPI_TABLE_HEADER *Table)
2148 {
2149 ACPI_STATUS Status;
2150 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
2151 UINT32 EntryOffset;
2152 UINT32 EntryLength;
2153 UINT32 EntryType;
2154 ACPI_IVRS_DE_HEADER *DeviceEntry;
2155 ACPI_IVRS_HEADER *SubTable;
2156 ACPI_DMTABLE_INFO *InfoTable;
2157
2158
2159 /* Main table */
2160
2161 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
2162 if (ACPI_FAILURE (Status))
2163 {
2164 return;
2165 }
2166
2167 /* Subtables */
2168
2169 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
2170 while (Offset < Table->Length)
2171 {
2172 /* Common subtable header */
2173
2174 AcpiOsPrintf ("\n");
2175 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2176 SubTable->Length, AcpiDmTableInfoIvrsHdr);
2177 if (ACPI_FAILURE (Status))
2178 {
2179 return;
2180 }
2181
2182 switch (SubTable->Type)
2183 {
2184 case ACPI_IVRS_TYPE_HARDWARE:
2185
2186 InfoTable = AcpiDmTableInfoIvrs0;
2187 break;
2188
2189 case ACPI_IVRS_TYPE_MEMORY1:
2190 case ACPI_IVRS_TYPE_MEMORY2:
2191 case ACPI_IVRS_TYPE_MEMORY3:
2192
2193 InfoTable = AcpiDmTableInfoIvrs1;
2194 break;
2195
2196 default:
2197
2198 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
2199 SubTable->Type);
2200
2201 /* Attempt to continue */
2202
2203 if (!SubTable->Length)
2204 {
2205 AcpiOsPrintf ("Invalid zero length subtable\n");
2206 return;
2207 }
2208 goto NextSubTable;
2209 }
2210
2211 /* Dump the subtable */
2212
2213 AcpiOsPrintf ("\n");
2214 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2215 SubTable->Length, InfoTable);
2216 if (ACPI_FAILURE (Status))
2217 {
2218 return;
2219 }
2220
2221 /* The hardware subtable can contain multiple device entries */
2222
2223 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
2224 {
2225 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
2226 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
2227 sizeof (ACPI_IVRS_HARDWARE));
2228
2229 while (EntryOffset < (Offset + SubTable->Length))
2230 {
2231 AcpiOsPrintf ("\n");
2232 /*
2233 * Upper 2 bits of Type encode the length of the device entry
2234 *
2235 * 00 = 4 byte
2236 * 01 = 8 byte
2237 * 10 = 16 byte - currently no entries defined
2238 * 11 = 32 byte - currently no entries defined
2239 */
2240 EntryType = DeviceEntry->Type;
2241 EntryLength = EntrySizes [EntryType >> 6];
2242
2243 switch (EntryType)
2244 {
2245 /* 4-byte device entries */
2246
2247 case ACPI_IVRS_TYPE_PAD4:
2248 case ACPI_IVRS_TYPE_ALL:
2249 case ACPI_IVRS_TYPE_SELECT:
2250 case ACPI_IVRS_TYPE_START:
2251 case ACPI_IVRS_TYPE_END:
2252
2253 InfoTable = AcpiDmTableInfoIvrs4;
2254 break;
2255
2256 /* 8-byte entries, type A */
2257
2258 case ACPI_IVRS_TYPE_ALIAS_SELECT:
2259 case ACPI_IVRS_TYPE_ALIAS_START:
2260
2261 InfoTable = AcpiDmTableInfoIvrs8a;
2262 break;
2263
2264 /* 8-byte entries, type B */
2265
2266 case ACPI_IVRS_TYPE_PAD8:
2267 case ACPI_IVRS_TYPE_EXT_SELECT:
2268 case ACPI_IVRS_TYPE_EXT_START:
2269
2270 InfoTable = AcpiDmTableInfoIvrs8b;
2271 break;
2272
2273 /* 8-byte entries, type C */
2274
2275 case ACPI_IVRS_TYPE_SPECIAL:
2276
2277 InfoTable = AcpiDmTableInfoIvrs8c;
2278 break;
2279
2280 default:
2281 InfoTable = AcpiDmTableInfoIvrs4;
2282 AcpiOsPrintf (
2283 "\n**** Unknown IVRS device entry type/length: "
2284 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
2285 EntryType, EntryLength, EntryOffset);
2286 break;
2287 }
2288
2289 /* Dump the Device Entry */
2290
2291 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
2292 DeviceEntry, EntryLength, InfoTable);
2293 if (ACPI_FAILURE (Status))
2294 {
2295 return;
2296 }
2297
2298 EntryOffset += EntryLength;
2299 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
2300 EntryLength);
2301 }
2302 }
2303
2304 NextSubTable:
2305 /* Point to next subtable */
2306
2307 Offset += SubTable->Length;
2308 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
2309 }
2310 }
2311
2312
2313 /*******************************************************************************
2314 *
2315 * FUNCTION: AcpiDmDumpLpit
2316 *
2317 * PARAMETERS: Table - A LPIT table
2318 *
2319 * RETURN: None
2320 *
2321 * DESCRIPTION: Format the contents of a LPIT. This table type consists
2322 * of an open-ended number of subtables. Note: There are no
2323 * entries in the main table. An LPIT consists of the table
2324 * header and then subtables only.
2325 *
2326 ******************************************************************************/
2327
2328 void
2329 AcpiDmDumpLpit (
2330 ACPI_TABLE_HEADER *Table)
2331 {
2332 ACPI_STATUS Status;
2333 ACPI_LPIT_HEADER *SubTable;
2334 UINT32 Length = Table->Length;
2335 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
2336 ACPI_DMTABLE_INFO *InfoTable;
2337 UINT32 SubTableLength;
2338
2339
2340 /* Subtables */
2341
2342 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
2343 while (Offset < Table->Length)
2344 {
2345 /* Common subtable header */
2346
2347 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2348 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
2349 if (ACPI_FAILURE (Status))
2350 {
2351 return;
2352 }
2353
2354 switch (SubTable->Type)
2355 {
2356 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
2357
2358 InfoTable = AcpiDmTableInfoLpit0;
2359 SubTableLength = sizeof (ACPI_LPIT_NATIVE);
2360 break;
2361
2362 default:
2363
2364 /* Cannot continue on unknown type - no length */
2365
2366 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
2367 SubTable->Type);
2368 return;
2369 }
2370
2371 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2372 SubTableLength, InfoTable);
2373 if (ACPI_FAILURE (Status))
2374 {
2375 return;
2376 }
2377
2378 AcpiOsPrintf ("\n");
2379
2380 /* Point to next subtable */
2381
2382 Offset += SubTableLength;
2383 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength);
2384 }
2385 }
2386
2387
2388 /*******************************************************************************
2389 *
2390 * FUNCTION: AcpiDmDumpMadt
2391 *
2392 * PARAMETERS: Table - A MADT table
2393 *
2394 * RETURN: None
2395 *
2396 * DESCRIPTION: Format the contents of a MADT. This table type consists
2397 * of an open-ended number of subtables.
2398 *
2399 ******************************************************************************/
2400
2401 void
2402 AcpiDmDumpMadt (
2403 ACPI_TABLE_HEADER *Table)
2404 {
2405 ACPI_STATUS Status;
2406 ACPI_SUBTABLE_HEADER *SubTable;
2407 UINT32 Length = Table->Length;
2408 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
2409 ACPI_DMTABLE_INFO *InfoTable;
2410
2411
2412 /* Main table */
2413
2414 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
2415 if (ACPI_FAILURE (Status))
2416 {
2417 return;
2418 }
2419
2420 /* Subtables */
2421
2422 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2423 while (Offset < Table->Length)
2424 {
2425 /* Common subtable header */
2426
2427 AcpiOsPrintf ("\n");
2428 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2429 SubTable->Length, AcpiDmTableInfoMadtHdr);
2430 if (ACPI_FAILURE (Status))
2431 {
2432 return;
2433 }
2434
2435 switch (SubTable->Type)
2436 {
2437 case ACPI_MADT_TYPE_LOCAL_APIC:
2438
2439 InfoTable = AcpiDmTableInfoMadt0;
2440 break;
2441
2442 case ACPI_MADT_TYPE_IO_APIC:
2443
2444 InfoTable = AcpiDmTableInfoMadt1;
2445 break;
2446
2447 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
2448
2449 InfoTable = AcpiDmTableInfoMadt2;
2450 break;
2451
2452 case ACPI_MADT_TYPE_NMI_SOURCE:
2453
2454 InfoTable = AcpiDmTableInfoMadt3;
2455 break;
2456
2457 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
2458
2459 InfoTable = AcpiDmTableInfoMadt4;
2460 break;
2461
2462 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
2463
2464 InfoTable = AcpiDmTableInfoMadt5;
2465 break;
2466
2467 case ACPI_MADT_TYPE_IO_SAPIC:
2468
2469 InfoTable = AcpiDmTableInfoMadt6;
2470 break;
2471
2472 case ACPI_MADT_TYPE_LOCAL_SAPIC:
2473
2474 InfoTable = AcpiDmTableInfoMadt7;
2475 break;
2476
2477 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
2478
2479 InfoTable = AcpiDmTableInfoMadt8;
2480 break;
2481
2482 case ACPI_MADT_TYPE_LOCAL_X2APIC:
2483
2484 InfoTable = AcpiDmTableInfoMadt9;
2485 break;
2486
2487 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
2488
2489 InfoTable = AcpiDmTableInfoMadt10;
2490 break;
2491
2492 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
2493
2494 InfoTable = AcpiDmTableInfoMadt11;
2495 break;
2496
2497 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
2498
2499 InfoTable = AcpiDmTableInfoMadt12;
2500 break;
2501
2502 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
2503
2504 InfoTable = AcpiDmTableInfoMadt13;
2505 break;
2506
2507 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
2508
2509 InfoTable = AcpiDmTableInfoMadt14;
2510 break;
2511
2512 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
2513
2514 InfoTable = AcpiDmTableInfoMadt15;
2515 break;
2516
2517 default:
2518
2519 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
2520 SubTable->Type);
2521
2522 /* Attempt to continue */
2523
2524 if (!SubTable->Length)
2525 {
2526 AcpiOsPrintf ("Invalid zero length subtable\n");
2527 return;
2528 }
2529
2530 goto NextSubTable;
2531 }
2532
2533 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2534 SubTable->Length, InfoTable);
2535 if (ACPI_FAILURE (Status))
2536 {
2537 return;
2538 }
2539
2540 NextSubTable:
2541 /* Point to next subtable */
2542
2543 Offset += SubTable->Length;
2544 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
2545 SubTable->Length);
2546 }
2547 }
2548
2549
2550 /*******************************************************************************
2551 *
2552 * FUNCTION: AcpiDmDumpMcfg
2553 *
2554 * PARAMETERS: Table - A MCFG Table
2555 *
2556 * RETURN: None
2557 *
2558 * DESCRIPTION: Format the contents of a MCFG table
2559 *
2560 ******************************************************************************/
2561
2562 void
2563 AcpiDmDumpMcfg (
2564 ACPI_TABLE_HEADER *Table)
2565 {
2566 ACPI_STATUS Status;
2567 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
2568 ACPI_MCFG_ALLOCATION *SubTable;
2569
2570
2571 /* Main table */
2572
2573 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
2574 if (ACPI_FAILURE (Status))
2575 {
2576 return;
2577 }
2578
2579 /* Subtables */
2580
2581 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
2582 while (Offset < Table->Length)
2583 {
2584 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
2585 {
2586 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
2587 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
2588 return;
2589 }
2590
2591 AcpiOsPrintf ("\n");
2592 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2593 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
2594 if (ACPI_FAILURE (Status))
2595 {
2596 return;
2597 }
2598
2599 /* Point to next subtable (each subtable is of fixed length) */
2600
2601 Offset += sizeof (ACPI_MCFG_ALLOCATION);
2602 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
2603 sizeof (ACPI_MCFG_ALLOCATION));
2604 }
2605 }
2606
2607
2608 /*******************************************************************************
2609 *
2610 * FUNCTION: AcpiDmDumpMpst
2611 *
2612 * PARAMETERS: Table - A MPST Table
2613 *
2614 * RETURN: None
2615 *
2616 * DESCRIPTION: Format the contents of a MPST table
2617 *
2618 ******************************************************************************/
2619
2620 void
2621 AcpiDmDumpMpst (
2622 ACPI_TABLE_HEADER *Table)
2623 {
2624 ACPI_STATUS Status;
2625 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
2626 ACPI_MPST_POWER_NODE *SubTable0;
2627 ACPI_MPST_POWER_STATE *SubTable0A;
2628 ACPI_MPST_COMPONENT *SubTable0B;
2629 ACPI_MPST_DATA_HDR *SubTable1;
2630 ACPI_MPST_POWER_DATA *SubTable2;
2631 UINT16 SubtableCount;
2632 UINT32 PowerStateCount;
2633 UINT32 ComponentCount;
2634
2635
2636 /* Main table */
2637
2638 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
2639 if (ACPI_FAILURE (Status))
2640 {
2641 return;
2642 }
2643
2644 /* Subtable: Memory Power Node(s) */
2645
2646 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
2647 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
2648
2649 while ((Offset < Table->Length) && SubtableCount)
2650 {
2651 AcpiOsPrintf ("\n");
2652 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
2653 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
2654 if (ACPI_FAILURE (Status))
2655 {
2656 return;
2657 }
2658
2659 /* Extract the sub-subtable counts */
2660
2661 PowerStateCount = SubTable0->NumPowerStates;
2662 ComponentCount = SubTable0->NumPhysicalComponents;
2663 Offset += sizeof (ACPI_MPST_POWER_NODE);
2664
2665 /* Sub-subtables - Memory Power State Structure(s) */
2666
2667 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0,
2668 sizeof (ACPI_MPST_POWER_NODE));
2669
2670 while (PowerStateCount)
2671 {
2672 AcpiOsPrintf ("\n");
2673 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
2674 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
2675 if (ACPI_FAILURE (Status))
2676 {
2677 return;
2678 }
2679
2680 SubTable0A++;
2681 PowerStateCount--;
2682 Offset += sizeof (ACPI_MPST_POWER_STATE);
2683 }
2684
2685 /* Sub-subtables - Physical Component ID Structure(s) */
2686
2687 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A);
2688
2689 if (ComponentCount)
2690 {
2691 AcpiOsPrintf ("\n");
2692 }
2693
2694 while (ComponentCount)
2695 {
2696 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
2697 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
2698 if (ACPI_FAILURE (Status))
2699 {
2700 return;
2701 }
2702
2703 SubTable0B++;
2704 ComponentCount--;
2705 Offset += sizeof (ACPI_MPST_COMPONENT);
2706 }
2707
2708 /* Point to next Memory Power Node subtable */
2709
2710 SubtableCount--;
2711 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
2712 sizeof (ACPI_MPST_POWER_NODE) +
2713 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
2714 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
2715 }
2716
2717 /* Subtable: Count of Memory Power State Characteristic structures */
2718
2719 AcpiOsPrintf ("\n");
2720 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
2721 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
2722 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
2723 if (ACPI_FAILURE (Status))
2724 {
2725 return;
2726 }
2727
2728 SubtableCount = SubTable1->CharacteristicsCount;
2729 Offset += sizeof (ACPI_MPST_DATA_HDR);
2730
2731 /* Subtable: Memory Power State Characteristics structure(s) */
2732
2733 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1,
2734 sizeof (ACPI_MPST_DATA_HDR));
2735
2736 while ((Offset < Table->Length) && SubtableCount)
2737 {
2738 AcpiOsPrintf ("\n");
2739 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
2740 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
2741 if (ACPI_FAILURE (Status))
2742 {
2743 return;
2744 }
2745
2746 SubTable2++;
2747 SubtableCount--;
2748 Offset += sizeof (ACPI_MPST_POWER_DATA);
2749 }
2750 }
2751
2752
2753 /*******************************************************************************
2754 *
2755 * FUNCTION: AcpiDmDumpMsct
2756 *
2757 * PARAMETERS: Table - A MSCT table
2758 *
2759 * RETURN: None
2760 *
2761 * DESCRIPTION: Format the contents of a MSCT
2762 *
2763 ******************************************************************************/
2764
2765 void
2766 AcpiDmDumpMsct (
2767 ACPI_TABLE_HEADER *Table)
2768 {
2769 ACPI_STATUS Status;
2770 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
2771 ACPI_MSCT_PROXIMITY *SubTable;
2772
2773
2774 /* Main table */
2775
2776 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
2777 if (ACPI_FAILURE (Status))
2778 {
2779 return;
2780 }
2781
2782 /* Subtables */
2783
2784 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
2785 while (Offset < Table->Length)
2786 {
2787 /* Common subtable header */
2788
2789 AcpiOsPrintf ("\n");
2790 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2791 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
2792 if (ACPI_FAILURE (Status))
2793 {
2794 return;
2795 }
2796
2797 /* Point to next subtable */
2798
2799 Offset += sizeof (ACPI_MSCT_PROXIMITY);
2800 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable,
2801 sizeof (ACPI_MSCT_PROXIMITY));
2802 }
2803 }
2804
2805
2806 /*******************************************************************************
2807 *
2808 * FUNCTION: AcpiDmDumpMtmr
2809 *
2810 * PARAMETERS: Table - A MTMR table
2811 *
2812 * RETURN: None
2813 *
2814 * DESCRIPTION: Format the contents of a MTMR
2815 *
2816 ******************************************************************************/
2817
2818 void
2819 AcpiDmDumpMtmr (
2820 ACPI_TABLE_HEADER *Table)
2821 {
2822 ACPI_STATUS Status;
2823 UINT32 Offset = sizeof (ACPI_TABLE_MTMR);
2824 ACPI_MTMR_ENTRY *SubTable;
2825
2826
2827 /* Main table */
2828
2829 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
2830 if (ACPI_FAILURE (Status))
2831 {
2832 return;
2833 }
2834
2835 /* Subtables */
2836
2837 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
2838 while (Offset < Table->Length)
2839 {
2840 /* Common subtable header */
2841
2842 AcpiOsPrintf ("\n");
2843 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2844 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
2845 if (ACPI_FAILURE (Status))
2846 {
2847 return;
2848 }
2849
2850 /* Point to next subtable */
2851
2852 Offset += sizeof (ACPI_MTMR_ENTRY);
2853 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable,
2854 sizeof (ACPI_MTMR_ENTRY));
2855 }
2856 }
2857
2858
2859 /*******************************************************************************
2860 *
2861 * FUNCTION: AcpiDmDumpNfit
2862 *
2863 * PARAMETERS: Table - A NFIT table
2864 *
2865 * RETURN: None
2866 *
2867 * DESCRIPTION: Format the contents of an NFIT.
2868 *
2869 ******************************************************************************/
2870
2871 void
2872 AcpiDmDumpNfit (
2873 ACPI_TABLE_HEADER *Table)
2874 {
2875 ACPI_STATUS Status;
2876 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
2877 UINT32 FieldOffset = 0;
2878 UINT32 Length;
2879 ACPI_NFIT_HEADER *SubTable;
2880 ACPI_DMTABLE_INFO *InfoTable;
2881 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
2882 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
2883 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
2884 UINT32 i;
2885
2886
2887 /* Main table */
2888
2889 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
2890 if (ACPI_FAILURE (Status))
2891 {
2892 return;
2893 }
2894
2895 /* Subtables */
2896
2897 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
2898 while (Offset < Table->Length)
2899 {
2900 /* NFIT subtable header */
2901
2902 AcpiOsPrintf ("\n");
2903 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2904 SubTable->Length, AcpiDmTableInfoNfitHdr);
2905 if (ACPI_FAILURE (Status))
2906 {
2907 return;
2908 }
2909
2910 switch (SubTable->Type)
2911 {
2912 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
2913
2914 InfoTable = AcpiDmTableInfoNfit0;
2915 break;
2916
2917 case ACPI_NFIT_TYPE_MEMORY_MAP:
2918
2919 InfoTable = AcpiDmTableInfoNfit1;
2920 break;
2921
2922 case ACPI_NFIT_TYPE_INTERLEAVE:
2923
2924 /* Has a variable number of 32-bit values at the end */
2925
2926 InfoTable = AcpiDmTableInfoNfit2;
2927 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, SubTable);
2928 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
2929 break;
2930
2931 case ACPI_NFIT_TYPE_SMBIOS:
2932
2933 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, SubTable);
2934 InfoTable = AcpiDmTableInfoNfit3;
2935 break;
2936
2937 case ACPI_NFIT_TYPE_CONTROL_REGION:
2938
2939 InfoTable = AcpiDmTableInfoNfit4;
2940 break;
2941
2942 case ACPI_NFIT_TYPE_DATA_REGION:
2943
2944 InfoTable = AcpiDmTableInfoNfit5;
2945 break;
2946
2947 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
2948
2949 /* Has a variable number of 64-bit addresses at the end */
2950
2951 InfoTable = AcpiDmTableInfoNfit6;
2952 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, SubTable);
2953 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64);
2954 break;
2955
2956 default:
2957 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
2958 SubTable->Type);
2959
2960 /* Attempt to continue */
2961
2962 if (!SubTable->Length)
2963 {
2964 AcpiOsPrintf ("Invalid zero length subtable\n");
2965 return;
2966 }
2967 goto NextSubTable;
2968 }
2969
2970 AcpiOsPrintf ("\n");
2971 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2972 SubTable->Length, InfoTable);
2973 if (ACPI_FAILURE (Status))
2974 {
2975 return;
2976 }
2977
2978 /* Per-subtable variable-length fields */
2979
2980 switch (SubTable->Type)
2981 {
2982 case ACPI_NFIT_TYPE_INTERLEAVE:
2983
2984 for (i = 0; i < Interleave->LineCount; i++)
2985 {
2986 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
2987 &Interleave->LineOffset[i],
2988 sizeof (UINT32), AcpiDmTableInfoNfit2a);
2989 if (ACPI_FAILURE (Status))
2990 {
2991 return;
2992 }
2993
2994 FieldOffset += sizeof (UINT32);
2995 }
2996 break;
2997
2998 case ACPI_NFIT_TYPE_SMBIOS:
2999
3000 Length = SubTable->Length -
3001 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
3002
3003 if (Length)
3004 {
3005 Status = AcpiDmDumpTable (Table->Length,
3006 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
3007 SmbiosInfo,
3008 Length, AcpiDmTableInfoNfit3a);
3009 if (ACPI_FAILURE (Status))
3010 {
3011 return;
3012 }
3013 }
3014
3015 break;
3016
3017 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
3018
3019 for (i = 0; i < Hint->HintCount; i++)
3020 {
3021 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
3022 &Hint->HintAddress[i],
3023 sizeof (UINT64), AcpiDmTableInfoNfit6a);
3024 if (ACPI_FAILURE (Status))
3025 {
3026 return;
3027 }
3028
3029 FieldOffset += sizeof (UINT64);
3030 }
3031 break;
3032
3033 default:
3034 break;
3035 }
3036
3037 NextSubTable:
3038 /* Point to next subtable */
3039
3040 Offset += SubTable->Length;
3041 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length);
3042 }
3043 }
3044
3045
3046 /*******************************************************************************
3047 *
3048 * FUNCTION: AcpiDmDumpPcct
3049 *
3050 * PARAMETERS: Table - A PCCT table
3051 *
3052 * RETURN: None
3053 *
3054 * DESCRIPTION: Format the contents of a PCCT. This table type consists
3055 * of an open-ended number of subtables.
3056 *
3057 ******************************************************************************/
3058
3059 void
3060 AcpiDmDumpPcct (
3061 ACPI_TABLE_HEADER *Table)
3062 {
3063 ACPI_STATUS Status;
3064 ACPI_PCCT_SUBSPACE *SubTable;
3065 ACPI_DMTABLE_INFO *InfoTable;
3066 UINT32 Length = Table->Length;
3067 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
3068
3069
3070 /* Main table */
3071
3072 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
3073 if (ACPI_FAILURE (Status))
3074 {
3075 return;
3076 }
3077
3078 /* Subtables */
3079
3080 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
3081 while (Offset < Table->Length)
3082 {
3083 /* Common subtable header */
3084
3085 AcpiOsPrintf ("\n");
3086 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3087 SubTable->Header.Length, AcpiDmTableInfoPcctHdr);
3088 if (ACPI_FAILURE (Status))
3089 {
3090 return;
3091 }
3092
3093 switch (SubTable->Header.Type)
3094 {
3095 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
3096
3097 InfoTable = AcpiDmTableInfoPcct0;
3098 break;
3099
3100 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
3101
3102 InfoTable = AcpiDmTableInfoPcct1;
3103 break;
3104
3105 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
3106
3107 InfoTable = AcpiDmTableInfoPcct2;
3108 break;
3109
3110 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
3111
3112 InfoTable = AcpiDmTableInfoPcct3;
3113 break;
3114
3115 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
3116
3117 InfoTable = AcpiDmTableInfoPcct4;
3118 break;
3119
3120 default:
3121
3122 AcpiOsPrintf (
3123 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
3124 SubTable->Header.Type);
3125 return;
3126 }
3127
3128 AcpiOsPrintf ("\n");
3129 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3130 SubTable->Header.Length, InfoTable);
3131 if (ACPI_FAILURE (Status))
3132 {
3133 return;
3134 }
3135
3136 /* Point to next subtable */
3137
3138 Offset += SubTable->Header.Length;
3139 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
3140 SubTable->Header.Length);
3141 }
3142 }
3143
3144
3145 /*******************************************************************************
3146 *
3147 * FUNCTION: AcpiDmDumpPmtt
3148 *
3149 * PARAMETERS: Table - A PMTT table
3150 *
3151 * RETURN: None
3152 *
3153 * DESCRIPTION: Format the contents of a PMTT. This table type consists
3154 * of an open-ended number of subtables.
3155 *
3156 ******************************************************************************/
3157
3158 void
3159 AcpiDmDumpPmtt (
3160 ACPI_TABLE_HEADER *Table)
3161 {
3162 ACPI_STATUS Status;
3163 ACPI_PMTT_HEADER *SubTable;
3164 ACPI_PMTT_HEADER *MemSubTable;
3165 ACPI_PMTT_HEADER *DimmSubTable;
3166 ACPI_PMTT_DOMAIN *DomainArray;
3167 UINT32 Length = Table->Length;
3168 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
3169 UINT32 MemOffset;
3170 UINT32 DimmOffset;
3171 UINT32 DomainOffset;
3172 UINT32 DomainCount;
3173
3174
3175 /* Main table */
3176
3177 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
3178 if (ACPI_FAILURE (Status))
3179 {
3180 return;
3181 }
3182
3183 /* Subtables */
3184
3185 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
3186 while (Offset < Table->Length)
3187 {
3188 /* Common subtable header */
3189
3190 AcpiOsPrintf ("\n");
3191 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3192 SubTable->Length, AcpiDmTableInfoPmttHdr);
3193 if (ACPI_FAILURE (Status))
3194 {
3195 return;
3196 }
3197
3198 /* Only Socket subtables are expected at this level */
3199
3200 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET)
3201 {
3202 AcpiOsPrintf (
3203 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3204 SubTable->Type);
3205 return;
3206 }
3207
3208 /* Dump the fixed-length portion of the subtable */
3209
3210 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3211 SubTable->Length, AcpiDmTableInfoPmtt0);
3212 if (ACPI_FAILURE (Status))
3213 {
3214 return;
3215 }
3216
3217 /* Walk the memory controller subtables */
3218
3219 MemOffset = sizeof (ACPI_PMTT_SOCKET);
3220 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
3221 sizeof (ACPI_PMTT_SOCKET));
3222
3223 while (((Offset + MemOffset) < Table->Length) &&
3224 (MemOffset < SubTable->Length))
3225 {
3226 /* Common subtable header */
3227
3228 AcpiOsPrintf ("\n");
3229 Status = AcpiDmDumpTable (Length,
3230 Offset + MemOffset, MemSubTable,
3231 MemSubTable->Length, AcpiDmTableInfoPmttHdr);
3232 if (ACPI_FAILURE (Status))
3233 {
3234 return;
3235 }
3236
3237 /* Only memory controller subtables are expected at this level */
3238
3239 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER)
3240 {
3241 AcpiOsPrintf (
3242 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3243 MemSubTable->Type);
3244 return;
3245 }
3246
3247 /* Dump the fixed-length portion of the controller subtable */
3248
3249 Status = AcpiDmDumpTable (Length,
3250 Offset + MemOffset, MemSubTable,
3251 MemSubTable->Length, AcpiDmTableInfoPmtt1);
3252 if (ACPI_FAILURE (Status))
3253 {
3254 return;
3255 }
3256
3257 /* Walk the variable count of proximity domains */
3258
3259 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
3260 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
3261 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
3262 sizeof (ACPI_PMTT_CONTROLLER));
3263
3264 while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
3265 ((MemOffset + DomainOffset) < SubTable->Length) &&
3266 DomainCount)
3267 {
3268 Status = AcpiDmDumpTable (Length,
3269 Offset + MemOffset + DomainOffset, DomainArray,
3270 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
3271 if (ACPI_FAILURE (Status))
3272 {
3273 return;
3274 }
3275
3276 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
3277 DomainArray++;
3278 DomainCount--;
3279 }
3280
3281 if (DomainCount)
3282 {
3283 AcpiOsPrintf (
3284 "\n**** DomainCount exceeds subtable length\n\n");
3285 }
3286
3287 /* Walk the physical component (DIMM) subtables */
3288
3289 DimmOffset = DomainOffset;
3290 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
3291 DomainOffset);
3292
3293 while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
3294 (DimmOffset < MemSubTable->Length))
3295 {
3296 /* Common subtable header */
3297
3298 AcpiOsPrintf ("\n");
3299 Status = AcpiDmDumpTable (Length,
3300 Offset + MemOffset + DimmOffset, DimmSubTable,
3301 DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
3302 if (ACPI_FAILURE (Status))
3303 {
3304 return;
3305 }
3306
3307 /* Only DIMM subtables are expected at this level */
3308
3309 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM)
3310 {
3311 AcpiOsPrintf (
3312 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3313 DimmSubTable->Type);
3314 return;
3315 }
3316
3317 /* Dump the fixed-length DIMM subtable */
3318
3319 Status = AcpiDmDumpTable (Length,
3320 Offset + MemOffset + DimmOffset, DimmSubTable,
3321 DimmSubTable->Length, AcpiDmTableInfoPmtt2);
3322 if (ACPI_FAILURE (Status))
3323 {
3324 return;
3325 }
3326
3327 /* Point to next DIMM subtable */
3328
3329 DimmOffset += DimmSubTable->Length;
3330 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3331 DimmSubTable, DimmSubTable->Length);
3332 }
3333
3334 /* Point to next Controller subtable */
3335
3336 MemOffset += MemSubTable->Length;
3337 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3338 MemSubTable, MemSubTable->Length);
3339 }
3340
3341 /* Point to next Socket subtable */
3342
3343 Offset += SubTable->Length;
3344 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3345 SubTable, SubTable->Length);
3346 }
3347 }
3348
3349
3350 /*******************************************************************************
3351 *
3352 * FUNCTION: AcpiDmDumpPptt
3353 *
3354 * PARAMETERS: Table - A PMTT table
3355 *
3356 * RETURN: None
3357 *
3358 * DESCRIPTION: Format the contents of a PPTT. This table type consists
3359 * of an open-ended number of subtables.
3360 *
3361 ******************************************************************************/
3362
3363 void
3364 AcpiDmDumpPptt (
3365 ACPI_TABLE_HEADER *Table)
3366 {
3367 ACPI_STATUS Status;
3368 ACPI_SUBTABLE_HEADER *SubTable;
3369 ACPI_PPTT_PROCESSOR *PpttProcessor;
3370 UINT8 Length;
3371 UINT8 SubTableOffset;
3372 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
3373 ACPI_DMTABLE_INFO *InfoTable;
3374 UINT32 i;
3375
3376
3377 /* There is no main table (other than the standard ACPI header) */
3378
3379 /* Subtables */
3380
3381 Offset = sizeof (ACPI_TABLE_HEADER);
3382 while (Offset < Table->Length)
3383 {
3384 AcpiOsPrintf ("\n");
3385
3386 /* Common subtable header */
3387
3388 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
3389 if (SubTable->Length < sizeof (ACPI_SUBTABLE_HEADER))
3390 {
3391 AcpiOsPrintf ("Invalid subtable length\n");
3392 return;
3393 }
3394 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3395 SubTable->Length, AcpiDmTableInfoPpttHdr);
3396 if (ACPI_FAILURE (Status))
3397 {
3398 return;
3399 }
3400
3401 switch (SubTable->Type)
3402 {
3403 case ACPI_PPTT_TYPE_PROCESSOR:
3404
3405 InfoTable = AcpiDmTableInfoPptt0;
3406 Length = sizeof (ACPI_PPTT_PROCESSOR);
3407 break;
3408
3409 case ACPI_PPTT_TYPE_CACHE:
3410
3411 InfoTable = AcpiDmTableInfoPptt1;
3412 Length = sizeof (ACPI_PPTT_CACHE);
3413 break;
3414
3415 case ACPI_PPTT_TYPE_ID:
3416
3417 InfoTable = AcpiDmTableInfoPptt2;
3418 Length = sizeof (ACPI_PPTT_ID);
3419 break;
3420
3421 default:
3422
3423 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
3424 SubTable->Type);
3425
3426 /* Attempt to continue */
3427
3428 goto NextSubTable;
3429 }
3430
3431 if (SubTable->Length < Length)
3432 {
3433 AcpiOsPrintf ("Invalid subtable length\n");
3434 return;
3435 }
3436 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3437 SubTable->Length, InfoTable);
3438 if (ACPI_FAILURE (Status))
3439 {
3440 return;
3441 }
3442 SubTableOffset = Length;
3443
3444 switch (SubTable->Type)
3445 {
3446 case ACPI_PPTT_TYPE_PROCESSOR:
3447
3448 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, SubTable);
3449
3450 /* Dump SMBIOS handles */
3451
3452 if ((UINT8)(SubTable->Length - SubTableOffset) <
3453 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
3454 {
3455 AcpiOsPrintf ("Invalid private resource number\n");
3456 return;
3457 }
3458 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
3459 {
3460 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
3461 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTableOffset),
3462 4, AcpiDmTableInfoPptt0a);
3463 SubTableOffset += 4;
3464 }
3465 break;
3466
3467 default:
3468
3469 break;
3470 }
3471
3472 NextSubTable:
3473 /* Point to next subtable */
3474
3475 Offset += SubTable->Length;
3476 }
3477 }
3478
3479
3480 /*******************************************************************************
3481 *
3482 * FUNCTION: AcpiDmDumpS3pt
3483 *
3484 * PARAMETERS: Table - A S3PT table
3485 *
3486 * RETURN: Length of the table
3487 *
3488 * DESCRIPTION: Format the contents of a S3PT
3489 *
3490 ******************************************************************************/
3491
3492 UINT32
3493 AcpiDmDumpS3pt (
3494 ACPI_TABLE_HEADER *Tables)
3495 {
3496 ACPI_STATUS Status;
3497 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
3498 ACPI_FPDT_HEADER *SubTable;
3499 ACPI_DMTABLE_INFO *InfoTable;
3500 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
3501
3502
3503 /* Main table */
3504
3505 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
3506 if (ACPI_FAILURE (Status))
3507 {
3508 return 0;
3509 }
3510
3511 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
3512 while (Offset < S3ptTable->Length)
3513 {
3514 /* Common subtable header */
3515
3516 AcpiOsPrintf ("\n");
3517 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
3518 SubTable->Length, AcpiDmTableInfoS3ptHdr);
3519 if (ACPI_FAILURE (Status))
3520 {
3521 return 0;
3522 }
3523
3524 switch (SubTable->Type)
3525 {
3526 case ACPI_S3PT_TYPE_RESUME:
3527
3528 InfoTable = AcpiDmTableInfoS3pt0;
3529 break;
3530
3531 case ACPI_S3PT_TYPE_SUSPEND:
3532
3533 InfoTable = AcpiDmTableInfoS3pt1;
3534 break;
3535
3536 default:
3537
3538 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
3539 SubTable->Type);
3540
3541 /* Attempt to continue */
3542
3543 if (!SubTable->Length)
3544 {
3545 AcpiOsPrintf ("Invalid zero length subtable\n");
3546 return 0;
3547 }
3548 goto NextSubTable;
3549 }
3550
3551 AcpiOsPrintf ("\n");
3552 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
3553 SubTable->Length, InfoTable);
3554 if (ACPI_FAILURE (Status))
3555 {
3556 return 0;
3557 }
3558
3559 NextSubTable:
3560 /* Point to next subtable */
3561
3562 Offset += SubTable->Length;
3563 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
3564 }
3565
3566 return (S3ptTable->Length);
3567 }
3568
3569
3570 /*******************************************************************************
3571 *
3572 * FUNCTION: AcpiDmDumpSlic
3573 *
3574 * PARAMETERS: Table - A SLIC table
3575 *
3576 * RETURN: None
3577 *
3578 * DESCRIPTION: Format the contents of a SLIC
3579 *
3580 ******************************************************************************/
3581
3582 void
3583 AcpiDmDumpSlic (
3584 ACPI_TABLE_HEADER *Table)
3585 {
3586
3587 (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
3588 Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
3589 }
3590
3591
3592 /*******************************************************************************
3593 *
3594 * FUNCTION: AcpiDmDumpSlit
3595 *
3596 * PARAMETERS: Table - An SLIT
3597 *
3598 * RETURN: None
3599 *
3600 * DESCRIPTION: Format the contents of a SLIT
3601 *
3602 ******************************************************************************/
3603
3604 void
3605 AcpiDmDumpSlit (
3606 ACPI_TABLE_HEADER *Table)
3607 {
3608 ACPI_STATUS Status;
3609 UINT32 Offset;
3610 UINT8 *Row;
3611 UINT32 Localities;
3612 UINT32 i;
3613 UINT32 j;
3614
3615
3616 /* Main table */
3617
3618 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
3619 if (ACPI_FAILURE (Status))
3620 {
3621 return;
3622 }
3623
3624 /* Display the Locality NxN Matrix */
3625
3626 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
3627 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
3628 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
3629
3630 for (i = 0; i < Localities; i++)
3631 {
3632 /* Display one row of the matrix */
3633
3634 AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
3635 for (j = 0; j < Localities; j++)
3636 {
3637 /* Check for beyond EOT */
3638
3639 if (Offset >= Table->Length)
3640 {
3641 AcpiOsPrintf (
3642 "\n**** Not enough room in table for all localities\n");
3643 return;
3644 }
3645
3646 AcpiOsPrintf ("%2.2X", Row[j]);
3647 Offset++;
3648
3649 /* Display up to 16 bytes per output row */
3650
3651 if ((j+1) < Localities)
3652 {
3653 AcpiOsPrintf (" ");
3654
3655 if (j && (((j+1) % 16) == 0))
3656 {
3657 AcpiOsPrintf ("\\\n"); /* With line continuation char */
3658 AcpiDmLineHeader (Offset, 0, NULL);
3659 }
3660 }
3661 }
3662
3663 /* Point to next row */
3664
3665 AcpiOsPrintf ("\n");
3666 Row += Localities;
3667 }
3668 }
3669
3670
3671 /*******************************************************************************
3672 *
3673 * FUNCTION: AcpiDmDumpSrat
3674 *
3675 * PARAMETERS: Table - A SRAT table
3676 *
3677 * RETURN: None
3678 *
3679 * DESCRIPTION: Format the contents of a SRAT
3680 *
3681 ******************************************************************************/
3682
3683 void
3684 AcpiDmDumpSrat (
3685 ACPI_TABLE_HEADER *Table)
3686 {
3687 ACPI_STATUS Status;
3688 UINT32 Offset = sizeof (ACPI_TABLE_SRAT);
3689 ACPI_SUBTABLE_HEADER *SubTable;
3690 ACPI_DMTABLE_INFO *InfoTable;
3691
3692
3693 /* Main table */
3694
3695 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
3696 if (ACPI_FAILURE (Status))
3697 {
3698 return;
3699 }
3700
3701 /* Subtables */
3702
3703 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
3704 while (Offset < Table->Length)
3705 {
3706 /* Common subtable header */
3707
3708 AcpiOsPrintf ("\n");
3709 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3710 SubTable->Length, AcpiDmTableInfoSratHdr);
3711 if (ACPI_FAILURE (Status))
3712 {
3713 return;
3714 }
3715
3716 switch (SubTable->Type)
3717 {
3718 case ACPI_SRAT_TYPE_CPU_AFFINITY:
3719
3720 InfoTable = AcpiDmTableInfoSrat0;
3721 break;
3722
3723 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
3724
3725 InfoTable = AcpiDmTableInfoSrat1;
3726 break;
3727
3728 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
3729
3730 InfoTable = AcpiDmTableInfoSrat2;
3731 break;
3732
3733 case ACPI_SRAT_TYPE_GICC_AFFINITY:
3734
3735 InfoTable = AcpiDmTableInfoSrat3;
3736 break;
3737
3738 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY:
3739
3740 InfoTable = AcpiDmTableInfoSrat4;
3741 break;
3742
3743 default:
3744 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n",
3745 SubTable->Type);
3746
3747 /* Attempt to continue */
3748
3749 if (!SubTable->Length)
3750 {
3751 AcpiOsPrintf ("Invalid zero length subtable\n");
3752 return;
3753 }
3754 goto NextSubTable;
3755 }
3756
3757 AcpiOsPrintf ("\n");
3758 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3759 SubTable->Length, InfoTable);
3760 if (ACPI_FAILURE (Status))
3761 {
3762 return;
3763 }
3764
3765 NextSubTable:
3766 /* Point to next subtable */
3767
3768 Offset += SubTable->Length;
3769 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
3770 SubTable->Length);
3771 }
3772 }
3773
3774
3775 /*******************************************************************************
3776 *
3777 * FUNCTION: AcpiDmDumpStao
3778 *
3779 * PARAMETERS: Table - A STAO table
3780 *
3781 * RETURN: None
3782 *
3783 * DESCRIPTION: Format the contents of a STAO. This is a variable-length
3784 * table that contains an open-ended number of ASCII strings
3785 * at the end of the table.
3786 *
3787 ******************************************************************************/
3788
3789 void
3790 AcpiDmDumpStao (
3791 ACPI_TABLE_HEADER *Table)
3792 {
3793 ACPI_STATUS Status;
3794 char *Namepath;
3795 UINT32 Length = Table->Length;
3796 UINT32 StringLength;
3797 UINT32 Offset = sizeof (ACPI_TABLE_STAO);
3798
3799
3800 /* Main table */
3801
3802 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao);
3803 if (ACPI_FAILURE (Status))
3804 {
3805 return;
3806 }
3807
3808 /* The rest of the table consists of Namepath strings */
3809
3810 while (Offset < Table->Length)
3811 {
3812 Namepath = ACPI_ADD_PTR (char, Table, Offset);
3813 StringLength = strlen (Namepath) + 1;
3814
3815 AcpiDmLineHeader (Offset, StringLength, "Namestring");
3816 AcpiOsPrintf ("\"%s\"\n", Namepath);
3817
3818 /* Point to next namepath */
3819
3820 Offset += StringLength;
3821 }
3822 }
3823
3824
3825 /*******************************************************************************
3826 *
3827 * FUNCTION: AcpiDmDumpTcpa
3828 *
3829 * PARAMETERS: Table - A TCPA table
3830 *
3831 * RETURN: None
3832 *
3833 * DESCRIPTION: Format the contents of a TCPA.
3834 *
3835 * NOTE: There are two versions of the table with the same signature:
3836 * the client version and the server version. The common
3837 * PlatformClass field is used to differentiate the two types of
3838 * tables.
3839 *
3840 ******************************************************************************/
3841
3842 void
3843 AcpiDmDumpTcpa (
3844 ACPI_TABLE_HEADER *Table)
3845 {
3846 UINT32 Offset = sizeof (ACPI_TABLE_TCPA_HDR);
3847 ACPI_TABLE_TCPA_HDR *CommonHeader = ACPI_CAST_PTR (
3848 ACPI_TABLE_TCPA_HDR, Table);
3849 ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR (
3850 ACPI_TABLE_TCPA_HDR, Table, Offset);
3851 ACPI_STATUS Status;
3852
3853
3854 /* Main table */
3855
3856 Status = AcpiDmDumpTable (Table->Length, 0, Table,
3857 0, AcpiDmTableInfoTcpaHdr);
3858 if (ACPI_FAILURE (Status))
3859 {
3860 return;
3861 }
3862
3863 /*
3864 * Examine the PlatformClass field to determine the table type.
3865 * Either a client or server table. Only one.
3866 */
3867 switch (CommonHeader->PlatformClass)
3868 {
3869 case ACPI_TCPA_CLIENT_TABLE:
3870
3871 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3872 Table->Length - Offset, AcpiDmTableInfoTcpaClient);
3873 break;
3874
3875 case ACPI_TCPA_SERVER_TABLE:
3876
3877 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3878 Table->Length - Offset, AcpiDmTableInfoTcpaServer);
3879 break;
3880
3881 default:
3882
3883 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
3884 CommonHeader->PlatformClass);
3885 Status = AE_ERROR;
3886 break;
3887 }
3888
3889 if (ACPI_FAILURE (Status))
3890 {
3891 AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n");
3892 }
3893 }
3894
3895
3896 /*******************************************************************************
3897 *
3898 * FUNCTION: AcpiDmDumpVrtc
3899 *
3900 * PARAMETERS: Table - A VRTC table
3901 *
3902 * RETURN: None
3903 *
3904 * DESCRIPTION: Format the contents of a VRTC
3905 *
3906 ******************************************************************************/
3907
3908 void
3909 AcpiDmDumpVrtc (
3910 ACPI_TABLE_HEADER *Table)
3911 {
3912 ACPI_STATUS Status;
3913 UINT32 Offset = sizeof (ACPI_TABLE_VRTC);
3914 ACPI_VRTC_ENTRY *SubTable;
3915
3916
3917 /* Main table */
3918
3919 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc);
3920 if (ACPI_FAILURE (Status))
3921 {
3922 return;
3923 }
3924
3925 /* Subtables */
3926
3927 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset);
3928 while (Offset < Table->Length)
3929 {
3930 /* Common subtable header */
3931
3932 AcpiOsPrintf ("\n");
3933 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3934 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
3935 if (ACPI_FAILURE (Status))
3936 {
3937 return;
3938 }
3939
3940 /* Point to next subtable */
3941
3942 Offset += sizeof (ACPI_VRTC_ENTRY);
3943 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable,
3944 sizeof (ACPI_VRTC_ENTRY));
3945 }
3946 }
3947
3948
3949 /*******************************************************************************
3950 *
3951 * FUNCTION: AcpiDmDumpWdat
3952 *
3953 * PARAMETERS: Table - A WDAT table
3954 *
3955 * RETURN: None
3956 *
3957 * DESCRIPTION: Format the contents of a WDAT
3958 *
3959 ******************************************************************************/
3960
3961 void
3962 AcpiDmDumpWdat (
3963 ACPI_TABLE_HEADER *Table)
3964 {
3965 ACPI_STATUS Status;
3966 UINT32 Offset = sizeof (ACPI_TABLE_WDAT);
3967 ACPI_WDAT_ENTRY *SubTable;
3968
3969
3970 /* Main table */
3971
3972 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
3973 if (ACPI_FAILURE (Status))
3974 {
3975 return;
3976 }
3977
3978 /* Subtables */
3979
3980 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
3981 while (Offset < Table->Length)
3982 {
3983 /* Common subtable header */
3984
3985 AcpiOsPrintf ("\n");
3986 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3987 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
3988 if (ACPI_FAILURE (Status))
3989 {
3990 return;
3991 }
3992
3993 /* Point to next subtable */
3994
3995 Offset += sizeof (ACPI_WDAT_ENTRY);
3996 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable,
3997 sizeof (ACPI_WDAT_ENTRY));
3998 }
3999 }
4000
4001
4002 /*******************************************************************************
4003 *
4004 * FUNCTION: AcpiDmDumpWpbt
4005 *
4006 * PARAMETERS: Table - A WPBT table
4007 *
4008 * RETURN: None
4009 *
4010 * DESCRIPTION: Format the contents of a WPBT. This table type consists
4011 * of an open-ended arguments buffer at the end of the table.
4012 *
4013 ******************************************************************************/
4014
4015 void
4016 AcpiDmDumpWpbt (
4017 ACPI_TABLE_HEADER *Table)
4018 {
4019 ACPI_STATUS Status;
4020 ACPI_TABLE_WPBT *SubTable;
4021 UINT32 Length = Table->Length;
4022 UINT16 ArgumentsLength;
4023
4024
4025 /* Dump the main table */
4026
4027 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt);
4028 if (ACPI_FAILURE (Status))
4029 {
4030 return;
4031 }
4032
4033 /* Extract the arguments buffer length from the main table */
4034
4035 SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table);
4036 ArgumentsLength = SubTable->ArgumentsLength;
4037
4038 /* Dump the arguments buffer */
4039
4040 (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
4041 AcpiDmTableInfoWpbt0);
4042 }
4043