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