?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
BPicture: Fix archive constructor.
[haiku.git] / src / add-ons / kernel / bus_managers / acpi / acpica / common / dmtbdump.c
blobb0ae9058a4ae941bdbba8483e9d0b06dbbf10c9c
1 /******************************************************************************
2 *
3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2014, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************/
115
116 #include "acpi.h"
117 #include "accommon.h"
118 #include "acdisasm.h"
119 #include "actables.h"
120
121 /* This module used for application-level code only */
122
123 #define _COMPONENT ACPI_CA_DISASSEMBLER
124 ACPI_MODULE_NAME ("dmtbdump")
125
126
127 /* Local prototypes */
128
129 static void
130 AcpiDmValidateFadtLength (
131 UINT32 Revision,
132 UINT32 Length);
133
134 static void
135 AcpiDmDumpBuffer (
136 void *Table,
137 UINT32 BufferOffset,
138 UINT32 Length,
139 UINT32 AbsoluteOffset,
140 char *Header);
141
142
143 /*******************************************************************************
144 *
145 * FUNCTION: AcpiDmDumpBuffer
146 *
147 * PARAMETERS: Table - ACPI Table or subtable
148 * BufferOffset - Offset of buffer from Table above
149 * Length - Length of the buffer
150 * AbsoluteOffset - Offset of buffer in the main ACPI table
151 * Header - Name of the buffer field (printed on the
152 * first line only.)
153 *
154 * RETURN: None
155 *
156 * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the
157 * disassembler output format.)
158 *
159 ******************************************************************************/
160
161 static void
162 AcpiDmDumpBuffer (
163 void *Table,
164 UINT32 BufferOffset,
165 UINT32 Length,
166 UINT32 AbsoluteOffset,
167 char *Header)
168 {
169 UINT8 *Buffer;
170 UINT32 i;
171
172
173 if (!Length)
174 {
175 return;
176 }
177
178 Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset;
179 i = 0;
180
181 while (i < Length)
182 {
183 if (!(i % 16))
184 {
185 AcpiOsPrintf ("\n");
186 AcpiDmLineHeader (AbsoluteOffset,
187 ((Length - i) > 16) ? 16 : (Length - i), Header);
188 Header = NULL;
189 }
190
191 AcpiOsPrintf ("%.02X ", *Buffer);
192 i++;
193 Buffer++;
194 AbsoluteOffset++;
195 }
196
197 AcpiOsPrintf ("\n");
198 }
199
200
201 /*******************************************************************************
202 *
203 * FUNCTION: AcpiDmDumpRsdp
204 *
205 * PARAMETERS: Table - A RSDP
206 *
207 * RETURN: Length of the table (there is not always a length field,
208 * use revision or length if available (ACPI 2.0+))
209 *
210 * DESCRIPTION: Format the contents of a RSDP
211 *
212 ******************************************************************************/
213
214 UINT32
215 AcpiDmDumpRsdp (
216 ACPI_TABLE_HEADER *Table)
217 {
218 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
219 UINT32 Length = sizeof (ACPI_RSDP_COMMON);
220 UINT8 Checksum;
221
222
223 /* Dump the common ACPI 1.0 portion */
224
225 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
226
227 /* Validate the first checksum */
228
229 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
230 Rsdp->Checksum);
231 if (Checksum != Rsdp->Checksum)
232 {
233 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
234 Checksum);
235 }
236
237 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
238
239 if (Rsdp->Revision > 0)
240 {
241 Length = Rsdp->Length;
242 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
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
361 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
362
363 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
364
365 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
366
367 if ((Table->Length > ACPI_FADT_V1_SIZE) &&
368 (Table->Length <= ACPI_FADT_V2_SIZE))
369 {
370 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
371 }
372
373 /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */
374
375 else if (Table->Length > ACPI_FADT_V2_SIZE)
376 {
377 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
378
379 /* Check for FADT revision 5 fields and up (ACPI 5.0+) */
380
381 if (Table->Length > ACPI_FADT_V3_SIZE)
382 {
383 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt5);
384 }
385 }
386
387 /* Validate various fields in the FADT, including length */
388
389 AcpiTbCreateLocalFadt (Table, Table->Length);
390
391 /* Validate FADT length against the revision */
392
393 AcpiDmValidateFadtLength (Table->Revision, Table->Length);
394 }
395
396
397 /*******************************************************************************
398 *
399 * FUNCTION: AcpiDmValidateFadtLength
400 *
401 * PARAMETERS: Revision - FADT revision (Header->Revision)
402 * Length - FADT length (Header->Length
403 *
404 * RETURN: None
405 *
406 * DESCRIPTION: Check the FADT revision against the expected table length for
407 * that revision. Issue a warning if the length is not what was
408 * expected. This seems to be such a common BIOS bug that the
409 * FADT revision has been rendered virtually meaningless.
410 *
411 ******************************************************************************/
412
413 static void
414 AcpiDmValidateFadtLength (
415 UINT32 Revision,
416 UINT32 Length)
417 {
418 UINT32 ExpectedLength;
419
420
421 switch (Revision)
422 {
423 case 0:
424
425 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
426 return;
427
428 case 1:
429
430 ExpectedLength = ACPI_FADT_V1_SIZE;
431 break;
432
433 case 2:
434
435 ExpectedLength = ACPI_FADT_V2_SIZE;
436 break;
437
438 case 3:
439 case 4:
440
441 ExpectedLength = ACPI_FADT_V3_SIZE;
442 break;
443
444 case 5:
445
446 ExpectedLength = ACPI_FADT_V5_SIZE;
447 break;
448
449 default:
450
451 return;
452 }
453
454 if (Length == ExpectedLength)
455 {
456 return;
457 }
458
459 AcpiOsPrintf (
460 "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n",
461 Revision, Length, ExpectedLength);
462 }
463
464
465 /*******************************************************************************
466 *
467 * FUNCTION: AcpiDmDumpAsf
468 *
469 * PARAMETERS: Table - A ASF table
470 *
471 * RETURN: None
472 *
473 * DESCRIPTION: Format the contents of a ASF table
474 *
475 ******************************************************************************/
476
477 void
478 AcpiDmDumpAsf (
479 ACPI_TABLE_HEADER *Table)
480 {
481 ACPI_STATUS Status;
482 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
483 ACPI_ASF_INFO *SubTable;
484 ACPI_DMTABLE_INFO *InfoTable;
485 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
486 UINT8 *DataTable = NULL;
487 UINT32 DataCount = 0;
488 UINT32 DataLength = 0;
489 UINT32 DataOffset = 0;
490 UINT32 i;
491 UINT8 Type;
492
493
494 /* No main table, only subtables */
495
496 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
497 while (Offset < Table->Length)
498 {
499 /* Common subtable header */
500
501 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
502 SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
503 if (ACPI_FAILURE (Status))
504 {
505 return;
506 }
507
508 /* The actual type is the lower 7 bits of Type */
509
510 Type = (UINT8) (SubTable->Header.Type & 0x7F);
511
512 switch (Type)
513 {
514 case ACPI_ASF_TYPE_INFO:
515
516 InfoTable = AcpiDmTableInfoAsf0;
517 break;
518
519 case ACPI_ASF_TYPE_ALERT:
520
521 InfoTable = AcpiDmTableInfoAsf1;
522 DataInfoTable = AcpiDmTableInfoAsf1a;
523 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
524 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
525 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
526 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
527 break;
528
529 case ACPI_ASF_TYPE_CONTROL:
530
531 InfoTable = AcpiDmTableInfoAsf2;
532 DataInfoTable = AcpiDmTableInfoAsf2a;
533 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
534 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
535 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
536 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
537 break;
538
539 case ACPI_ASF_TYPE_BOOT:
540
541 InfoTable = AcpiDmTableInfoAsf3;
542 break;
543
544 case ACPI_ASF_TYPE_ADDRESS:
545
546 InfoTable = AcpiDmTableInfoAsf4;
547 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
548 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
549 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
550 break;
551
552 default:
553
554 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n", SubTable->Header.Type);
555 return;
556 }
557
558 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
559 SubTable->Header.Length, InfoTable);
560 if (ACPI_FAILURE (Status))
561 {
562 return;
563 }
564
565 /* Dump variable-length extra data */
566
567 switch (Type)
568 {
569 case ACPI_ASF_TYPE_ALERT:
570 case ACPI_ASF_TYPE_CONTROL:
571
572 for (i = 0; i < DataCount; i++)
573 {
574 AcpiOsPrintf ("\n");
575 Status = AcpiDmDumpTable (Table->Length, DataOffset,
576 DataTable, DataLength, DataInfoTable);
577 if (ACPI_FAILURE (Status))
578 {
579 return;
580 }
581
582 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
583 DataOffset += DataLength;
584 }
585 break;
586
587 case ACPI_ASF_TYPE_ADDRESS:
588
589 for (i = 0; i < DataLength; i++)
590 {
591 if (!(i % 16))
592 {
593 AcpiDmLineHeader (DataOffset, 1, "Addresses");
594 }
595
596 AcpiOsPrintf ("%2.2X ", *DataTable);
597 DataTable++;
598 DataOffset++;
599 if (DataOffset > Table->Length)
600 {
601 AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
602 return;
603 }
604 }
605
606 AcpiOsPrintf ("\n");
607 break;
608
609 default:
610
611 break;
612 }
613
614 AcpiOsPrintf ("\n");
615
616 /* Point to next subtable */
617
618 if (!SubTable->Header.Length)
619 {
620 AcpiOsPrintf ("Invalid zero subtable header length\n");
621 return;
622 }
623
624 Offset += SubTable->Header.Length;
625 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
626 }
627 }
628
629
630 /*******************************************************************************
631 *
632 * FUNCTION: AcpiDmDumpCpep
633 *
634 * PARAMETERS: Table - A CPEP table
635 *
636 * RETURN: None
637 *
638 * DESCRIPTION: Format the contents of a CPEP. This table type consists
639 * of an open-ended number of subtables.
640 *
641 ******************************************************************************/
642
643 void
644 AcpiDmDumpCpep (
645 ACPI_TABLE_HEADER *Table)
646 {
647 ACPI_STATUS Status;
648 ACPI_CPEP_POLLING *SubTable;
649 UINT32 Length = Table->Length;
650 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
651
652
653 /* Main table */
654
655 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
656 if (ACPI_FAILURE (Status))
657 {
658 return;
659 }
660
661 /* Subtables */
662
663 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
664 while (Offset < Table->Length)
665 {
666 AcpiOsPrintf ("\n");
667 Status = AcpiDmDumpTable (Length, Offset, SubTable,
668 SubTable->Header.Length, AcpiDmTableInfoCpep0);
669 if (ACPI_FAILURE (Status))
670 {
671 return;
672 }
673
674 /* Point to next subtable */
675
676 Offset += SubTable->Header.Length;
677 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
678 SubTable->Header.Length);
679 }
680 }
681
682
683 /*******************************************************************************
684 *
685 * FUNCTION: AcpiDmDumpCsrt
686 *
687 * PARAMETERS: Table - A CSRT table
688 *
689 * RETURN: None
690 *
691 * DESCRIPTION: Format the contents of a CSRT. This table type consists
692 * of an open-ended number of subtables.
693 *
694 ******************************************************************************/
695
696 void
697 AcpiDmDumpCsrt (
698 ACPI_TABLE_HEADER *Table)
699 {
700 ACPI_STATUS Status;
701 ACPI_CSRT_GROUP *SubTable;
702 ACPI_CSRT_SHARED_INFO *SharedInfoTable;
703 ACPI_CSRT_DESCRIPTOR *SubSubTable;
704 UINT32 Length = Table->Length;
705 UINT32 Offset = sizeof (ACPI_TABLE_CSRT);
706 UINT32 SubOffset;
707 UINT32 SubSubOffset;
708 UINT32 InfoLength;
709
710
711 /* The main table only contains the ACPI header, thus already handled */
712
713 /* Subtables (Resource Groups) */
714
715 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
716 while (Offset < Table->Length)
717 {
718 /* Resource group subtable */
719
720 AcpiOsPrintf ("\n");
721 Status = AcpiDmDumpTable (Length, Offset, SubTable,
722 SubTable->Length, AcpiDmTableInfoCsrt0);
723 if (ACPI_FAILURE (Status))
724 {
725 return;
726 }
727
728 /* Shared info subtable (One per resource group) */
729
730 SubOffset = sizeof (ACPI_CSRT_GROUP);
731 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
732 Offset + SubOffset);
733
734 AcpiOsPrintf ("\n");
735 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
736 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
737 if (ACPI_FAILURE (Status))
738 {
739 return;
740 }
741
742 SubOffset += SubTable->SharedInfoLength;
743
744 /* Sub-Subtables (Resource Descriptors) */
745
746 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
747 Offset + SubOffset);
748
749 while ((SubOffset < SubTable->Length) &&
750 ((Offset + SubOffset) < Table->Length))
751 {
752 AcpiOsPrintf ("\n");
753 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
754 SubSubTable->Length, AcpiDmTableInfoCsrt2);
755 if (ACPI_FAILURE (Status))
756 {
757 return;
758 }
759
760 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
761
762 /* Resource-specific info buffer */
763
764 InfoLength = SubSubTable->Length - SubSubOffset;
765
766 AcpiDmDumpBuffer (SubSubTable, SubSubOffset, InfoLength,
767 Offset + SubOffset + SubSubOffset, "ResourceInfo");
768 SubSubOffset += InfoLength;
769
770 /* Point to next sub-subtable */
771
772 SubOffset += SubSubTable->Length;
773 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
774 SubSubTable->Length);
775 }
776
777 /* Point to next subtable */
778
779 Offset += SubTable->Length;
780 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
781 SubTable->Length);
782 }
783 }
784
785
786 /*******************************************************************************
787 *
788 * FUNCTION: AcpiDmDumpDbg2
789 *
790 * PARAMETERS: Table - A DBG2 table
791 *
792 * RETURN: None
793 *
794 * DESCRIPTION: Format the contents of a DBG2. This table type consists
795 * of an open-ended number of subtables.
796 *
797 ******************************************************************************/
798
799 void
800 AcpiDmDumpDbg2 (
801 ACPI_TABLE_HEADER *Table)
802 {
803 ACPI_STATUS Status;
804 ACPI_DBG2_DEVICE *SubTable;
805 UINT32 Length = Table->Length;
806 UINT32 Offset = sizeof (ACPI_TABLE_DBG2);
807 UINT32 i;
808 UINT32 ArrayOffset;
809 UINT32 AbsoluteOffset;
810 UINT8 *Array;
811
812
813 /* Main table */
814
815 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
816 if (ACPI_FAILURE (Status))
817 {
818 return;
819 }
820
821 /* Subtables */
822
823 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
824 while (Offset < Table->Length)
825 {
826 AcpiOsPrintf ("\n");
827 Status = AcpiDmDumpTable (Length, Offset, SubTable,
828 SubTable->Length, AcpiDmTableInfoDbg2Device);
829 if (ACPI_FAILURE (Status))
830 {
831 return;
832 }
833
834 /* Dump the BaseAddress array */
835
836 for (i = 0; i < SubTable->RegisterCount; i++)
837 {
838 ArrayOffset = SubTable->BaseAddressOffset +
839 (sizeof (ACPI_GENERIC_ADDRESS) * i);
840 AbsoluteOffset = Offset + ArrayOffset;
841 Array = (UINT8 *) SubTable + ArrayOffset;
842
843 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
844 SubTable->Length, AcpiDmTableInfoDbg2Addr);
845 if (ACPI_FAILURE (Status))
846 {
847 return;
848 }
849 }
850
851 /* Dump the AddressSize array */
852
853 for (i = 0; i < SubTable->RegisterCount; i++)
854 {
855 ArrayOffset = SubTable->AddressSizeOffset +
856 (sizeof (UINT32) * i);
857 AbsoluteOffset = Offset + ArrayOffset;
858 Array = (UINT8 *) SubTable + ArrayOffset;
859
860 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
861 SubTable->Length, AcpiDmTableInfoDbg2Size);
862 if (ACPI_FAILURE (Status))
863 {
864 return;
865 }
866 }
867
868 /* Dump the Namestring (required) */
869
870 AcpiOsPrintf ("\n");
871 ArrayOffset = SubTable->NamepathOffset;
872 AbsoluteOffset = Offset + ArrayOffset;
873 Array = (UINT8 *) SubTable + ArrayOffset;
874
875 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
876 SubTable->Length, AcpiDmTableInfoDbg2Name);
877 if (ACPI_FAILURE (Status))
878 {
879 return;
880 }
881
882 /* Dump the OemData (optional) */
883
884 if (SubTable->OemDataOffset)
885 {
886 AcpiDmDumpBuffer (SubTable, SubTable->OemDataOffset, SubTable->OemDataLength,
887 Offset + SubTable->OemDataOffset, "OEM Data");
888 }
889
890 /* Point to next subtable */
891
892 Offset += SubTable->Length;
893 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
894 SubTable->Length);
895 }
896 }
897
898
899 /*******************************************************************************
900 *
901 * FUNCTION: AcpiDmDumpDmar
902 *
903 * PARAMETERS: Table - A DMAR table
904 *
905 * RETURN: None
906 *
907 * DESCRIPTION: Format the contents of a DMAR. This table type consists
908 * of an open-ended number of subtables.
909 *
910 ******************************************************************************/
911
912
913 void
914 AcpiDmDumpDmar (
915 ACPI_TABLE_HEADER *Table)
916 {
917 ACPI_STATUS Status;
918 ACPI_DMAR_HEADER *SubTable;
919 UINT32 Length = Table->Length;
920 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
921 ACPI_DMTABLE_INFO *InfoTable;
922 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
923 UINT32 ScopeOffset;
924 UINT8 *PciPath;
925 UINT32 PathOffset;
926
927
928 /* Main table */
929
930 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
931 if (ACPI_FAILURE (Status))
932 {
933 return;
934 }
935
936 /* Subtables */
937
938 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
939 while (Offset < Table->Length)
940 {
941 /* Common subtable header */
942
943 AcpiOsPrintf ("\n");
944 Status = AcpiDmDumpTable (Length, Offset, SubTable,
945 SubTable->Length, AcpiDmTableInfoDmarHdr);
946 if (ACPI_FAILURE (Status))
947 {
948 return;
949 }
950 AcpiOsPrintf ("\n");
951
952 switch (SubTable->Type)
953 {
954 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
955
956 InfoTable = AcpiDmTableInfoDmar0;
957 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
958 break;
959
960 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
961
962 InfoTable = AcpiDmTableInfoDmar1;
963 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
964 break;
965
966 case ACPI_DMAR_TYPE_ROOT_ATS:
967
968 InfoTable = AcpiDmTableInfoDmar2;
969 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
970 break;
971
972 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
973
974 InfoTable = AcpiDmTableInfoDmar3;
975 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
976 break;
977
978 case ACPI_DMAR_TYPE_NAMESPACE:
979
980 InfoTable = AcpiDmTableInfoDmar4;
981 ScopeOffset = sizeof (ACPI_DMAR_ANDD);
982 break;
983
984 default:
985
986 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", SubTable->Type);
987 return;
988 }
989
990 Status = AcpiDmDumpTable (Length, Offset, SubTable,
991 SubTable->Length, InfoTable);
992 if (ACPI_FAILURE (Status))
993 {
994 return;
995 }
996
997 /*
998 * Dump the optional device scope entries
999 */
1000 if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
1001 (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE))
1002 {
1003 /* These types do not support device scopes */
1004
1005 goto NextSubtable;
1006 }
1007
1008 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
1009 while (ScopeOffset < SubTable->Length)
1010 {
1011 AcpiOsPrintf ("\n");
1012 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
1013 ScopeTable->Length, AcpiDmTableInfoDmarScope);
1014 if (ACPI_FAILURE (Status))
1015 {
1016 return;
1017 }
1018 AcpiOsPrintf ("\n");
1019
1020 /* Dump the PCI Path entries for this device scope */
1021
1022 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
1023
1024 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
1025 sizeof (ACPI_DMAR_DEVICE_SCOPE));
1026
1027 while (PathOffset < ScopeTable->Length)
1028 {
1029 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
1030 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
1031
1032 /* Point to next PCI Path entry */
1033
1034 PathOffset += 2;
1035 PciPath += 2;
1036 AcpiOsPrintf ("\n");
1037 }
1038
1039 /* Point to next device scope entry */
1040
1041 ScopeOffset += ScopeTable->Length;
1042 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
1043 ScopeTable, ScopeTable->Length);
1044 }
1045
1046 NextSubtable:
1047 /* Point to next subtable */
1048
1049 Offset += SubTable->Length;
1050 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
1051 }
1052 }
1053
1054
1055 /*******************************************************************************
1056 *
1057 * FUNCTION: AcpiDmDumpEinj
1058 *
1059 * PARAMETERS: Table - A EINJ table
1060 *
1061 * RETURN: None
1062 *
1063 * DESCRIPTION: Format the contents of a EINJ. This table type consists
1064 * of an open-ended number of subtables.
1065 *
1066 ******************************************************************************/
1067
1068 void
1069 AcpiDmDumpEinj (
1070 ACPI_TABLE_HEADER *Table)
1071 {
1072 ACPI_STATUS Status;
1073 ACPI_WHEA_HEADER *SubTable;
1074 UINT32 Length = Table->Length;
1075 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
1076
1077
1078 /* Main table */
1079
1080 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
1081 if (ACPI_FAILURE (Status))
1082 {
1083 return;
1084 }
1085
1086 /* Subtables */
1087
1088 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1089 while (Offset < Table->Length)
1090 {
1091 AcpiOsPrintf ("\n");
1092 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1093 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
1094 if (ACPI_FAILURE (Status))
1095 {
1096 return;
1097 }
1098
1099 /* Point to next subtable (each subtable is of fixed length) */
1100
1101 Offset += sizeof (ACPI_WHEA_HEADER);
1102 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1103 sizeof (ACPI_WHEA_HEADER));
1104 }
1105 }
1106
1107
1108 /*******************************************************************************
1109 *
1110 * FUNCTION: AcpiDmDumpErst
1111 *
1112 * PARAMETERS: Table - A ERST table
1113 *
1114 * RETURN: None
1115 *
1116 * DESCRIPTION: Format the contents of a ERST. This table type consists
1117 * of an open-ended number of subtables.
1118 *
1119 ******************************************************************************/
1120
1121 void
1122 AcpiDmDumpErst (
1123 ACPI_TABLE_HEADER *Table)
1124 {
1125 ACPI_STATUS Status;
1126 ACPI_WHEA_HEADER *SubTable;
1127 UINT32 Length = Table->Length;
1128 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
1129
1130
1131 /* Main table */
1132
1133 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1134 if (ACPI_FAILURE (Status))
1135 {
1136 return;
1137 }
1138
1139 /* Subtables */
1140
1141 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1142 while (Offset < Table->Length)
1143 {
1144 AcpiOsPrintf ("\n");
1145 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1146 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1147 if (ACPI_FAILURE (Status))
1148 {
1149 return;
1150 }
1151
1152 /* Point to next subtable (each subtable is of fixed length) */
1153
1154 Offset += sizeof (ACPI_WHEA_HEADER);
1155 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1156 sizeof (ACPI_WHEA_HEADER));
1157 }
1158 }
1159
1160
1161 /*******************************************************************************
1162 *
1163 * FUNCTION: AcpiDmDumpFpdt
1164 *
1165 * PARAMETERS: Table - A FPDT table
1166 *
1167 * RETURN: None
1168 *
1169 * DESCRIPTION: Format the contents of a FPDT. This table type consists
1170 * of an open-ended number of subtables.
1171 *
1172 ******************************************************************************/
1173
1174 void
1175 AcpiDmDumpFpdt (
1176 ACPI_TABLE_HEADER *Table)
1177 {
1178 ACPI_STATUS Status;
1179 ACPI_FPDT_HEADER *SubTable;
1180 UINT32 Length = Table->Length;
1181 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
1182 ACPI_DMTABLE_INFO *InfoTable;
1183
1184
1185 /* There is no main table (other than the standard ACPI header) */
1186
1187 /* Subtables */
1188
1189 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
1190 while (Offset < Table->Length)
1191 {
1192 /* Common subtable header */
1193
1194 AcpiOsPrintf ("\n");
1195 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1196 SubTable->Length, AcpiDmTableInfoFpdtHdr);
1197 if (ACPI_FAILURE (Status))
1198 {
1199 return;
1200 }
1201
1202 switch (SubTable->Type)
1203 {
1204 case ACPI_FPDT_TYPE_BOOT:
1205
1206 InfoTable = AcpiDmTableInfoFpdt0;
1207 break;
1208
1209 case ACPI_FPDT_TYPE_S3PERF:
1210
1211 InfoTable = AcpiDmTableInfoFpdt1;
1212 break;
1213
1214 default:
1215
1216 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", SubTable->Type);
1217
1218 /* Attempt to continue */
1219
1220 if (!SubTable->Length)
1221 {
1222 AcpiOsPrintf ("Invalid zero length subtable\n");
1223 return;
1224 }
1225 goto NextSubTable;
1226 }
1227
1228 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1229 SubTable->Length, InfoTable);
1230 if (ACPI_FAILURE (Status))
1231 {
1232 return;
1233 }
1234
1235 NextSubTable:
1236 /* Point to next subtable */
1237
1238 Offset += SubTable->Length;
1239 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
1240 }
1241 }
1242
1243
1244 /*******************************************************************************
1245 *
1246 * FUNCTION: AcpiDmDumpGtdt
1247 *
1248 * PARAMETERS: Table - A GTDT table
1249 *
1250 * RETURN: None
1251 *
1252 * DESCRIPTION: Format the contents of a GTDT. This table type consists
1253 * of an open-ended number of subtables.
1254 *
1255 ******************************************************************************/
1256
1257 void
1258 AcpiDmDumpGtdt (
1259 ACPI_TABLE_HEADER *Table)
1260 {
1261 ACPI_STATUS Status;
1262 ACPI_GTDT_HEADER *SubTable;
1263 UINT32 Length = Table->Length;
1264 UINT32 Offset = sizeof (ACPI_TABLE_GTDT);
1265 ACPI_DMTABLE_INFO *InfoTable;
1266 UINT32 SubTableLength;
1267 UINT32 GtCount;
1268 ACPI_GTDT_TIMER_ENTRY *GtxTable;
1269
1270
1271 /* Main table */
1272
1273 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
1274 if (ACPI_FAILURE (Status))
1275 {
1276 return;
1277 }
1278
1279 /* Subtables */
1280
1281 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1282 while (Offset < Table->Length)
1283 {
1284 /* Common subtable header */
1285
1286 AcpiOsPrintf ("\n");
1287 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1288 SubTable->Length, AcpiDmTableInfoGtdtHdr);
1289 if (ACPI_FAILURE (Status))
1290 {
1291 return;
1292 }
1293
1294 GtCount = 0;
1295 switch (SubTable->Type)
1296 {
1297 case ACPI_GTDT_TYPE_TIMER_BLOCK:
1298
1299 SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
1300 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1301 SubTable))->TimerCount;
1302
1303 InfoTable = AcpiDmTableInfoGtdt0;
1304 break;
1305
1306 case ACPI_GTDT_TYPE_WATCHDOG:
1307
1308 SubTableLength = sizeof (ACPI_GTDT_WATCHDOG);
1309
1310 InfoTable = AcpiDmTableInfoGtdt1;
1311 break;
1312
1313 default:
1314
1315 /* Cannot continue on unknown type - no length */
1316
1317 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", SubTable->Type);
1318 return;
1319 }
1320
1321 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1322 SubTable->Length, InfoTable);
1323 if (ACPI_FAILURE (Status))
1324 {
1325 return;
1326 }
1327
1328 /* Point to end of current subtable (each subtable above is of fixed length) */
1329
1330 Offset += SubTableLength;
1331
1332 /* If there are any Gt Timer Blocks from above, dump them now */
1333
1334 if (GtCount)
1335 {
1336 GtxTable = ACPI_ADD_PTR (ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength);
1337 SubTableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
1338
1339 while (GtCount)
1340 {
1341 AcpiOsPrintf ("\n");
1342 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
1343 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
1344 if (ACPI_FAILURE (Status))
1345 {
1346 return;
1347 }
1348 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
1349 GtxTable++;
1350 GtCount--;
1351 }
1352 }
1353
1354 /* Point to next subtable */
1355
1356 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, SubTable, SubTableLength);
1357 }
1358 }
1359
1360
1361 /*******************************************************************************
1362 *
1363 * FUNCTION: AcpiDmDumpHest
1364 *
1365 * PARAMETERS: Table - A HEST table
1366 *
1367 * RETURN: None
1368 *
1369 * DESCRIPTION: Format the contents of a HEST. This table type consists
1370 * of an open-ended number of subtables.
1371 *
1372 ******************************************************************************/
1373
1374 void
1375 AcpiDmDumpHest (
1376 ACPI_TABLE_HEADER *Table)
1377 {
1378 ACPI_STATUS Status;
1379 ACPI_HEST_HEADER *SubTable;
1380 UINT32 Length = Table->Length;
1381 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
1382 ACPI_DMTABLE_INFO *InfoTable;
1383 UINT32 SubTableLength;
1384 UINT32 BankCount;
1385 ACPI_HEST_IA_ERROR_BANK *BankTable;
1386
1387
1388 /* Main table */
1389
1390 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1391 if (ACPI_FAILURE (Status))
1392 {
1393 return;
1394 }
1395
1396 /* Subtables */
1397
1398 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1399 while (Offset < Table->Length)
1400 {
1401 BankCount = 0;
1402 switch (SubTable->Type)
1403 {
1404 case ACPI_HEST_TYPE_IA32_CHECK:
1405
1406 InfoTable = AcpiDmTableInfoHest0;
1407 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1408 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1409 SubTable))->NumHardwareBanks;
1410 break;
1411
1412 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1413
1414 InfoTable = AcpiDmTableInfoHest1;
1415 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1416 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1417 SubTable))->NumHardwareBanks;
1418 break;
1419
1420 case ACPI_HEST_TYPE_IA32_NMI:
1421
1422 InfoTable = AcpiDmTableInfoHest2;
1423 SubTableLength = sizeof (ACPI_HEST_IA_NMI);
1424 break;
1425
1426 case ACPI_HEST_TYPE_AER_ROOT_PORT:
1427
1428 InfoTable = AcpiDmTableInfoHest6;
1429 SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
1430 break;
1431
1432 case ACPI_HEST_TYPE_AER_ENDPOINT:
1433
1434 InfoTable = AcpiDmTableInfoHest7;
1435 SubTableLength = sizeof (ACPI_HEST_AER);
1436 break;
1437
1438 case ACPI_HEST_TYPE_AER_BRIDGE:
1439
1440 InfoTable = AcpiDmTableInfoHest8;
1441 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1442 break;
1443
1444 case ACPI_HEST_TYPE_GENERIC_ERROR:
1445
1446 InfoTable = AcpiDmTableInfoHest9;
1447 SubTableLength = sizeof (ACPI_HEST_GENERIC);
1448 break;
1449
1450 default:
1451
1452 /* Cannot continue on unknown type - no length */
1453
1454 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", SubTable->Type);
1455 return;
1456 }
1457
1458 AcpiOsPrintf ("\n");
1459 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1460 SubTableLength, InfoTable);
1461 if (ACPI_FAILURE (Status))
1462 {
1463 return;
1464 }
1465
1466 /* Point to end of current subtable (each subtable above is of fixed length) */
1467
1468 Offset += SubTableLength;
1469
1470 /* If there are any (fixed-length) Error Banks from above, dump them now */
1471
1472 if (BankCount)
1473 {
1474 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
1475 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1476
1477 while (BankCount)
1478 {
1479 AcpiOsPrintf ("\n");
1480 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1481 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1482 if (ACPI_FAILURE (Status))
1483 {
1484 return;
1485 }
1486 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1487 BankTable++;
1488 BankCount--;
1489 }
1490 }
1491
1492 /* Point to next subtable */
1493
1494 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
1495 }
1496 }
1497
1498
1499 /*******************************************************************************
1500 *
1501 * FUNCTION: AcpiDmDumpIvrs
1502 *
1503 * PARAMETERS: Table - A IVRS table
1504 *
1505 * RETURN: None
1506 *
1507 * DESCRIPTION: Format the contents of a IVRS
1508 *
1509 ******************************************************************************/
1510
1511 static UINT8 EntrySizes[] = {4,8,16,32};
1512
1513 void
1514 AcpiDmDumpIvrs (
1515 ACPI_TABLE_HEADER *Table)
1516 {
1517 ACPI_STATUS Status;
1518 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
1519 UINT32 EntryOffset;
1520 UINT32 EntryLength;
1521 UINT32 EntryType;
1522 ACPI_IVRS_DE_HEADER *DeviceEntry;
1523 ACPI_IVRS_HEADER *SubTable;
1524 ACPI_DMTABLE_INFO *InfoTable;
1525
1526
1527 /* Main table */
1528
1529 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
1530 if (ACPI_FAILURE (Status))
1531 {
1532 return;
1533 }
1534
1535 /* Subtables */
1536
1537 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
1538 while (Offset < Table->Length)
1539 {
1540 /* Common subtable header */
1541
1542 AcpiOsPrintf ("\n");
1543 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1544 SubTable->Length, AcpiDmTableInfoIvrsHdr);
1545 if (ACPI_FAILURE (Status))
1546 {
1547 return;
1548 }
1549
1550 switch (SubTable->Type)
1551 {
1552 case ACPI_IVRS_TYPE_HARDWARE:
1553
1554 InfoTable = AcpiDmTableInfoIvrs0;
1555 break;
1556
1557 case ACPI_IVRS_TYPE_MEMORY1:
1558 case ACPI_IVRS_TYPE_MEMORY2:
1559 case ACPI_IVRS_TYPE_MEMORY3:
1560
1561 InfoTable = AcpiDmTableInfoIvrs1;
1562 break;
1563
1564 default:
1565
1566 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
1567 SubTable->Type);
1568
1569 /* Attempt to continue */
1570
1571 if (!SubTable->Length)
1572 {
1573 AcpiOsPrintf ("Invalid zero length subtable\n");
1574 return;
1575 }
1576 goto NextSubTable;
1577 }
1578
1579 /* Dump the subtable */
1580
1581 AcpiOsPrintf ("\n");
1582 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1583 SubTable->Length, InfoTable);
1584 if (ACPI_FAILURE (Status))
1585 {
1586 return;
1587 }
1588
1589 /* The hardware subtable can contain multiple device entries */
1590
1591 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
1592 {
1593 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
1594 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
1595 sizeof (ACPI_IVRS_HARDWARE));
1596
1597 while (EntryOffset < (Offset + SubTable->Length))
1598 {
1599 AcpiOsPrintf ("\n");
1600 /*
1601 * Upper 2 bits of Type encode the length of the device entry
1602 *
1603 * 00 = 4 byte
1604 * 01 = 8 byte
1605 * 10 = 16 byte - currently no entries defined
1606 * 11 = 32 byte - currently no entries defined
1607 */
1608 EntryType = DeviceEntry->Type;
1609 EntryLength = EntrySizes [EntryType >> 6];
1610
1611 switch (EntryType)
1612 {
1613 /* 4-byte device entries */
1614
1615 case ACPI_IVRS_TYPE_PAD4:
1616 case ACPI_IVRS_TYPE_ALL:
1617 case ACPI_IVRS_TYPE_SELECT:
1618 case ACPI_IVRS_TYPE_START:
1619 case ACPI_IVRS_TYPE_END:
1620
1621 InfoTable = AcpiDmTableInfoIvrs4;
1622 break;
1623
1624 /* 8-byte entries, type A */
1625
1626 case ACPI_IVRS_TYPE_ALIAS_SELECT:
1627 case ACPI_IVRS_TYPE_ALIAS_START:
1628
1629 InfoTable = AcpiDmTableInfoIvrs8a;
1630 break;
1631
1632 /* 8-byte entries, type B */
1633
1634 case ACPI_IVRS_TYPE_PAD8:
1635 case ACPI_IVRS_TYPE_EXT_SELECT:
1636 case ACPI_IVRS_TYPE_EXT_START:
1637
1638 InfoTable = AcpiDmTableInfoIvrs8b;
1639 break;
1640
1641 /* 8-byte entries, type C */
1642
1643 case ACPI_IVRS_TYPE_SPECIAL:
1644
1645 InfoTable = AcpiDmTableInfoIvrs8c;
1646 break;
1647
1648 default:
1649 InfoTable = AcpiDmTableInfoIvrs4;
1650 AcpiOsPrintf (
1651 "\n**** Unknown IVRS device entry type/length: "
1652 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
1653 EntryType, EntryLength, EntryOffset);
1654 break;
1655 }
1656
1657 /* Dump the Device Entry */
1658
1659 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
1660 DeviceEntry, EntryLength, InfoTable);
1661
1662 EntryOffset += EntryLength;
1663 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
1664 EntryLength);
1665 }
1666 }
1667
1668 NextSubTable:
1669 /* Point to next subtable */
1670
1671 Offset += SubTable->Length;
1672 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
1673 }
1674 }
1675
1676
1677 /*******************************************************************************
1678 *
1679 * FUNCTION: AcpiDmDumpLpit
1680 *
1681 * PARAMETERS: Table - A LPIT table
1682 *
1683 * RETURN: None
1684 *
1685 * DESCRIPTION: Format the contents of a LPIT. This table type consists
1686 * of an open-ended number of subtables. Note: There are no
1687 * entries in the main table. An LPIT consists of the table
1688 * header and then subtables only.
1689 *
1690 ******************************************************************************/
1691
1692 void
1693 AcpiDmDumpLpit (
1694 ACPI_TABLE_HEADER *Table)
1695 {
1696 ACPI_STATUS Status;
1697 ACPI_LPIT_HEADER *SubTable;
1698 UINT32 Length = Table->Length;
1699 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
1700 ACPI_DMTABLE_INFO *InfoTable;
1701 UINT32 SubTableLength;
1702
1703
1704 /* Subtables */
1705
1706 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
1707 while (Offset < Table->Length)
1708 {
1709 /* Common subtable header */
1710
1711 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1712 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
1713 if (ACPI_FAILURE (Status))
1714 {
1715 return;
1716 }
1717
1718 switch (SubTable->Type)
1719 {
1720 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
1721
1722 InfoTable = AcpiDmTableInfoLpit0;
1723 SubTableLength = sizeof (ACPI_LPIT_NATIVE);
1724 break;
1725
1726 case ACPI_LPIT_TYPE_SIMPLE_IO:
1727
1728 InfoTable = AcpiDmTableInfoLpit1;
1729 SubTableLength = sizeof (ACPI_LPIT_IO);
1730 break;
1731
1732 default:
1733
1734 /* Cannot continue on unknown type - no length */
1735
1736 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", SubTable->Type);
1737 return;
1738 }
1739
1740 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1741 SubTableLength, InfoTable);
1742 if (ACPI_FAILURE (Status))
1743 {
1744 return;
1745 }
1746 AcpiOsPrintf ("\n");
1747
1748 /* Point to next subtable */
1749
1750 Offset += SubTableLength;
1751 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength);
1752 }
1753 }
1754
1755
1756 /*******************************************************************************
1757 *
1758 * FUNCTION: AcpiDmDumpMadt
1759 *
1760 * PARAMETERS: Table - A MADT table
1761 *
1762 * RETURN: None
1763 *
1764 * DESCRIPTION: Format the contents of a MADT. This table type consists
1765 * of an open-ended number of subtables.
1766 *
1767 ******************************************************************************/
1768
1769 void
1770 AcpiDmDumpMadt (
1771 ACPI_TABLE_HEADER *Table)
1772 {
1773 ACPI_STATUS Status;
1774 ACPI_SUBTABLE_HEADER *SubTable;
1775 UINT32 Length = Table->Length;
1776 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
1777 ACPI_DMTABLE_INFO *InfoTable;
1778
1779
1780 /* Main table */
1781
1782 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1783 if (ACPI_FAILURE (Status))
1784 {
1785 return;
1786 }
1787
1788 /* Subtables */
1789
1790 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1791 while (Offset < Table->Length)
1792 {
1793 /* Common subtable header */
1794
1795 AcpiOsPrintf ("\n");
1796 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1797 SubTable->Length, AcpiDmTableInfoMadtHdr);
1798 if (ACPI_FAILURE (Status))
1799 {
1800 return;
1801 }
1802
1803 switch (SubTable->Type)
1804 {
1805 case ACPI_MADT_TYPE_LOCAL_APIC:
1806
1807 InfoTable = AcpiDmTableInfoMadt0;
1808 break;
1809
1810 case ACPI_MADT_TYPE_IO_APIC:
1811
1812 InfoTable = AcpiDmTableInfoMadt1;
1813 break;
1814
1815 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
1816
1817 InfoTable = AcpiDmTableInfoMadt2;
1818 break;
1819
1820 case ACPI_MADT_TYPE_NMI_SOURCE:
1821
1822 InfoTable = AcpiDmTableInfoMadt3;
1823 break;
1824
1825 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
1826
1827 InfoTable = AcpiDmTableInfoMadt4;
1828 break;
1829
1830 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
1831
1832 InfoTable = AcpiDmTableInfoMadt5;
1833 break;
1834
1835 case ACPI_MADT_TYPE_IO_SAPIC:
1836
1837 InfoTable = AcpiDmTableInfoMadt6;
1838 break;
1839
1840 case ACPI_MADT_TYPE_LOCAL_SAPIC:
1841
1842 InfoTable = AcpiDmTableInfoMadt7;
1843 break;
1844
1845 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
1846
1847 InfoTable = AcpiDmTableInfoMadt8;
1848 break;
1849
1850 case ACPI_MADT_TYPE_LOCAL_X2APIC:
1851
1852 InfoTable = AcpiDmTableInfoMadt9;
1853 break;
1854
1855 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
1856
1857 InfoTable = AcpiDmTableInfoMadt10;
1858 break;
1859
1860 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
1861
1862 InfoTable = AcpiDmTableInfoMadt11;
1863 break;
1864
1865 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
1866
1867 InfoTable = AcpiDmTableInfoMadt12;
1868 break;
1869
1870 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
1871
1872 InfoTable = AcpiDmTableInfoMadt13;
1873 break;
1874
1875 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
1876
1877 InfoTable = AcpiDmTableInfoMadt14;
1878 break;
1879
1880 default:
1881
1882 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", SubTable->Type);
1883
1884 /* Attempt to continue */
1885
1886 if (!SubTable->Length)
1887 {
1888 AcpiOsPrintf ("Invalid zero length subtable\n");
1889 return;
1890 }
1891 goto NextSubTable;
1892 }
1893
1894 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1895 SubTable->Length, InfoTable);
1896 if (ACPI_FAILURE (Status))
1897 {
1898 return;
1899 }
1900
1901 NextSubTable:
1902 /* Point to next subtable */
1903
1904 Offset += SubTable->Length;
1905 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1906 }
1907 }
1908
1909
1910 /*******************************************************************************
1911 *
1912 * FUNCTION: AcpiDmDumpMcfg
1913 *
1914 * PARAMETERS: Table - A MCFG Table
1915 *
1916 * RETURN: None
1917 *
1918 * DESCRIPTION: Format the contents of a MCFG table
1919 *
1920 ******************************************************************************/
1921
1922 void
1923 AcpiDmDumpMcfg (
1924 ACPI_TABLE_HEADER *Table)
1925 {
1926 ACPI_STATUS Status;
1927 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
1928 ACPI_MCFG_ALLOCATION *SubTable;
1929
1930
1931 /* Main table */
1932
1933 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1934 if (ACPI_FAILURE (Status))
1935 {
1936 return;
1937 }
1938
1939 /* Subtables */
1940
1941 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1942 while (Offset < Table->Length)
1943 {
1944 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1945 {
1946 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1947 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1948 return;
1949 }
1950
1951 AcpiOsPrintf ("\n");
1952 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1953 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1954 if (ACPI_FAILURE (Status))
1955 {
1956 return;
1957 }
1958
1959 /* Point to next subtable (each subtable is of fixed length) */
1960
1961 Offset += sizeof (ACPI_MCFG_ALLOCATION);
1962 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
1963 sizeof (ACPI_MCFG_ALLOCATION));
1964 }
1965 }
1966
1967
1968 /*******************************************************************************
1969 *
1970 * FUNCTION: AcpiDmDumpMpst
1971 *
1972 * PARAMETERS: Table - A MPST Table
1973 *
1974 * RETURN: None
1975 *
1976 * DESCRIPTION: Format the contents of a MPST table
1977 *
1978 ******************************************************************************/
1979
1980 void
1981 AcpiDmDumpMpst (
1982 ACPI_TABLE_HEADER *Table)
1983 {
1984 ACPI_STATUS Status;
1985 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
1986 ACPI_MPST_POWER_NODE *SubTable0;
1987 ACPI_MPST_POWER_STATE *SubTable0A;
1988 ACPI_MPST_COMPONENT *SubTable0B;
1989 ACPI_MPST_DATA_HDR *SubTable1;
1990 ACPI_MPST_POWER_DATA *SubTable2;
1991 UINT16 SubtableCount;
1992 UINT32 PowerStateCount;
1993 UINT32 ComponentCount;
1994
1995
1996 /* Main table */
1997
1998 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
1999 if (ACPI_FAILURE (Status))
2000 {
2001 return;
2002 }
2003
2004 /* Subtable: Memory Power Node(s) */
2005
2006 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
2007 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
2008
2009 while ((Offset < Table->Length) && SubtableCount)
2010 {
2011 AcpiOsPrintf ("\n");
2012 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
2013 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
2014 if (ACPI_FAILURE (Status))
2015 {
2016 return;
2017 }
2018
2019 /* Extract the sub-subtable counts */
2020
2021 PowerStateCount = SubTable0->NumPowerStates;
2022 ComponentCount = SubTable0->NumPhysicalComponents;
2023 Offset += sizeof (ACPI_MPST_POWER_NODE);
2024
2025 /* Sub-subtables - Memory Power State Structure(s) */
2026
2027 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0,
2028 sizeof (ACPI_MPST_POWER_NODE));
2029
2030 while (PowerStateCount)
2031 {
2032 AcpiOsPrintf ("\n");
2033 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
2034 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
2035 if (ACPI_FAILURE (Status))
2036 {
2037 return;
2038 }
2039
2040 SubTable0A++;
2041 PowerStateCount--;
2042 Offset += sizeof (ACPI_MPST_POWER_STATE);
2043 }
2044
2045 /* Sub-subtables - Physical Component ID Structure(s) */
2046
2047 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A);
2048
2049 if (ComponentCount)
2050 {
2051 AcpiOsPrintf ("\n");
2052 }
2053
2054 while (ComponentCount)
2055 {
2056 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
2057 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
2058 if (ACPI_FAILURE (Status))
2059 {
2060 return;
2061 }
2062
2063 SubTable0B++;
2064 ComponentCount--;
2065 Offset += sizeof (ACPI_MPST_COMPONENT);
2066 }
2067
2068 /* Point to next Memory Power Node subtable */
2069
2070 SubtableCount--;
2071 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
2072 sizeof (ACPI_MPST_POWER_NODE) +
2073 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
2074 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
2075 }
2076
2077 /* Subtable: Count of Memory Power State Characteristic structures */
2078
2079 AcpiOsPrintf ("\n");
2080 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
2081 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
2082 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
2083 if (ACPI_FAILURE (Status))
2084 {
2085 return;
2086 }
2087
2088 SubtableCount = SubTable1->CharacteristicsCount;
2089 Offset += sizeof (ACPI_MPST_DATA_HDR);
2090
2091 /* Subtable: Memory Power State Characteristics structure(s) */
2092
2093 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR));
2094
2095 while ((Offset < Table->Length) && SubtableCount)
2096 {
2097 AcpiOsPrintf ("\n");
2098 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
2099 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
2100 if (ACPI_FAILURE (Status))
2101 {
2102 return;
2103 }
2104
2105 SubTable2++;
2106 SubtableCount--;
2107 Offset += sizeof (ACPI_MPST_POWER_DATA);
2108 }
2109 }
2110
2111
2112 /*******************************************************************************
2113 *
2114 * FUNCTION: AcpiDmDumpMsct
2115 *
2116 * PARAMETERS: Table - A MSCT table
2117 *
2118 * RETURN: None
2119 *
2120 * DESCRIPTION: Format the contents of a MSCT
2121 *
2122 ******************************************************************************/
2123
2124 void
2125 AcpiDmDumpMsct (
2126 ACPI_TABLE_HEADER *Table)
2127 {
2128 ACPI_STATUS Status;
2129 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
2130 ACPI_MSCT_PROXIMITY *SubTable;
2131
2132
2133 /* Main table */
2134
2135 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
2136 if (ACPI_FAILURE (Status))
2137 {
2138 return;
2139 }
2140
2141 /* Subtables */
2142
2143 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
2144 while (Offset < Table->Length)
2145 {
2146 /* Common subtable header */
2147
2148 AcpiOsPrintf ("\n");
2149 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2150 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
2151 if (ACPI_FAILURE (Status))
2152 {
2153 return;
2154 }
2155
2156 /* Point to next subtable */
2157
2158 Offset += sizeof (ACPI_MSCT_PROXIMITY);
2159 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
2160 }
2161 }
2162
2163
2164 /*******************************************************************************
2165 *
2166 * FUNCTION: AcpiDmDumpMtmr
2167 *
2168 * PARAMETERS: Table - A MTMR table
2169 *
2170 * RETURN: None
2171 *
2172 * DESCRIPTION: Format the contents of a MTMR
2173 *
2174 ******************************************************************************/
2175
2176 void
2177 AcpiDmDumpMtmr (
2178 ACPI_TABLE_HEADER *Table)
2179 {
2180 ACPI_STATUS Status;
2181 UINT32 Offset = sizeof (ACPI_TABLE_MTMR);
2182 ACPI_MTMR_ENTRY *SubTable;
2183
2184
2185 /* Main table */
2186
2187 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
2188 if (ACPI_FAILURE (Status))
2189 {
2190 return;
2191 }
2192
2193 /* Subtables */
2194
2195 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
2196 while (Offset < Table->Length)
2197 {
2198 /* Common subtable header */
2199
2200 AcpiOsPrintf ("\n");
2201 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2202 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
2203 if (ACPI_FAILURE (Status))
2204 {
2205 return;
2206 }
2207
2208 /* Point to next subtable */
2209
2210 Offset += sizeof (ACPI_MTMR_ENTRY);
2211 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, sizeof (ACPI_MTMR_ENTRY));
2212 }
2213 }
2214
2215
2216 /*******************************************************************************
2217 *
2218 * FUNCTION: AcpiDmDumpPcct
2219 *
2220 * PARAMETERS: Table - A PCCT table
2221 *
2222 * RETURN: None
2223 *
2224 * DESCRIPTION: Format the contents of a PCCT. This table type consists
2225 * of an open-ended number of subtables.
2226 *
2227 ******************************************************************************/
2228
2229 void
2230 AcpiDmDumpPcct (
2231 ACPI_TABLE_HEADER *Table)
2232 {
2233 ACPI_STATUS Status;
2234 ACPI_PCCT_SUBSPACE *SubTable;
2235 ACPI_DMTABLE_INFO *InfoTable;
2236 UINT32 Length = Table->Length;
2237 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
2238
2239
2240 /* Main table */
2241
2242 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
2243 if (ACPI_FAILURE (Status))
2244 {
2245 return;
2246 }
2247
2248 /* Subtables */
2249
2250 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
2251 while (Offset < Table->Length)
2252 {
2253 /* Common subtable header */
2254
2255 AcpiOsPrintf ("\n");
2256 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2257 SubTable->Header.Length, AcpiDmTableInfoPcctHdr);
2258 if (ACPI_FAILURE (Status))
2259 {
2260 return;
2261 }
2262
2263 switch (SubTable->Header.Type)
2264 {
2265 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
2266
2267 InfoTable = AcpiDmTableInfoPcct0;
2268 break;
2269
2270 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
2271
2272 InfoTable = AcpiDmTableInfoPcct1;
2273 break;
2274
2275 default:
2276
2277 AcpiOsPrintf (
2278 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
2279 SubTable->Header.Type);
2280 return;
2281 }
2282
2283 AcpiOsPrintf ("\n");
2284 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2285 SubTable->Header.Length, InfoTable);
2286 if (ACPI_FAILURE (Status))
2287 {
2288 return;
2289 }
2290
2291 /* Point to next subtable */
2292
2293 Offset += SubTable->Header.Length;
2294 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
2295 SubTable->Header.Length);
2296 }
2297 }
2298
2299
2300 /*******************************************************************************
2301 *
2302 * FUNCTION: AcpiDmDumpPmtt
2303 *
2304 * PARAMETERS: Table - A PMTT table
2305 *
2306 * RETURN: None
2307 *
2308 * DESCRIPTION: Format the contents of a PMTT. This table type consists
2309 * of an open-ended number of subtables.
2310 *
2311 ******************************************************************************/
2312
2313 void
2314 AcpiDmDumpPmtt (
2315 ACPI_TABLE_HEADER *Table)
2316 {
2317 ACPI_STATUS Status;
2318 ACPI_PMTT_HEADER *SubTable;
2319 ACPI_PMTT_HEADER *MemSubTable;
2320 ACPI_PMTT_HEADER *DimmSubTable;
2321 ACPI_PMTT_DOMAIN *DomainArray;
2322 UINT32 Length = Table->Length;
2323 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
2324 UINT32 MemOffset;
2325 UINT32 DimmOffset;
2326 UINT32 DomainOffset;
2327 UINT32 DomainCount;
2328
2329
2330 /* Main table */
2331
2332 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
2333 if (ACPI_FAILURE (Status))
2334 {
2335 return;
2336 }
2337
2338 /* Subtables */
2339
2340 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
2341 while (Offset < Table->Length)
2342 {
2343 /* Common subtable header */
2344
2345 AcpiOsPrintf ("\n");
2346 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2347 SubTable->Length, AcpiDmTableInfoPmttHdr);
2348 if (ACPI_FAILURE (Status))
2349 {
2350 return;
2351 }
2352
2353 /* Only Socket subtables are expected at this level */
2354
2355 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET)
2356 {
2357 AcpiOsPrintf (
2358 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2359 SubTable->Type);
2360 return;
2361 }
2362
2363 /* Dump the fixed-length portion of the subtable */
2364
2365 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2366 SubTable->Length, AcpiDmTableInfoPmtt0);
2367 if (ACPI_FAILURE (Status))
2368 {
2369 return;
2370 }
2371
2372 /* Walk the memory controller subtables */
2373
2374 MemOffset = sizeof (ACPI_PMTT_SOCKET);
2375 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
2376 sizeof (ACPI_PMTT_SOCKET));
2377
2378 while (((Offset + MemOffset) < Table->Length) &&
2379 (MemOffset < SubTable->Length))
2380 {
2381 /* Common subtable header */
2382
2383 AcpiOsPrintf ("\n");
2384 Status = AcpiDmDumpTable (Length,
2385 Offset + MemOffset, MemSubTable,
2386 MemSubTable->Length, AcpiDmTableInfoPmttHdr);
2387 if (ACPI_FAILURE (Status))
2388 {
2389 return;
2390 }
2391
2392 /* Only memory controller subtables are expected at this level */
2393
2394 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER)
2395 {
2396 AcpiOsPrintf (
2397 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2398 MemSubTable->Type);
2399 return;
2400 }
2401
2402 /* Dump the fixed-length portion of the controller subtable */
2403
2404 Status = AcpiDmDumpTable (Length,
2405 Offset + MemOffset, MemSubTable,
2406 MemSubTable->Length, AcpiDmTableInfoPmtt1);
2407 if (ACPI_FAILURE (Status))
2408 {
2409 return;
2410 }
2411
2412 /* Walk the variable count of proximity domains */
2413
2414 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
2415 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
2416 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
2417 sizeof (ACPI_PMTT_CONTROLLER));
2418
2419 while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
2420 ((MemOffset + DomainOffset) < SubTable->Length) &&
2421 DomainCount)
2422 {
2423 Status = AcpiDmDumpTable (Length,
2424 Offset + MemOffset + DomainOffset, DomainArray,
2425 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
2426 if (ACPI_FAILURE (Status))
2427 {
2428 return;
2429 }
2430
2431 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
2432 DomainArray++;
2433 DomainCount--;
2434 }
2435
2436 if (DomainCount)
2437 {
2438 AcpiOsPrintf (
2439 "\n**** DomainCount exceeds subtable length\n\n");
2440 }
2441
2442 /* Walk the physical component (DIMM) subtables */
2443
2444 DimmOffset = DomainOffset;
2445 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
2446 DomainOffset);
2447
2448 while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
2449 (DimmOffset < MemSubTable->Length))
2450 {
2451 /* Common subtable header */
2452
2453 AcpiOsPrintf ("\n");
2454 Status = AcpiDmDumpTable (Length,
2455 Offset + MemOffset + DimmOffset, DimmSubTable,
2456 DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
2457 if (ACPI_FAILURE (Status))
2458 {
2459 return;
2460 }
2461
2462 /* Only DIMM subtables are expected at this level */
2463
2464 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM)
2465 {
2466 AcpiOsPrintf (
2467 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2468 DimmSubTable->Type);
2469 return;
2470 }
2471
2472 /* Dump the fixed-length DIMM subtable */
2473
2474 Status = AcpiDmDumpTable (Length,
2475 Offset + MemOffset + DimmOffset, DimmSubTable,
2476 DimmSubTable->Length, AcpiDmTableInfoPmtt2);
2477 if (ACPI_FAILURE (Status))
2478 {
2479 return;
2480 }
2481
2482 /* Point to next DIMM subtable */
2483
2484 DimmOffset += DimmSubTable->Length;
2485 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2486 DimmSubTable, DimmSubTable->Length);
2487 }
2488
2489 /* Point to next Controller subtable */
2490
2491 MemOffset += MemSubTable->Length;
2492 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2493 MemSubTable, MemSubTable->Length);
2494 }
2495
2496 /* Point to next Socket subtable */
2497
2498 Offset += SubTable->Length;
2499 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2500 SubTable, SubTable->Length);
2501 }
2502 }
2503
2504
2505 /*******************************************************************************
2506 *
2507 * FUNCTION: AcpiDmDumpS3pt
2508 *
2509 * PARAMETERS: Table - A S3PT table
2510 *
2511 * RETURN: Length of the table
2512 *
2513 * DESCRIPTION: Format the contents of a S3PT
2514 *
2515 ******************************************************************************/
2516
2517 UINT32
2518 AcpiDmDumpS3pt (
2519 ACPI_TABLE_HEADER *Tables)
2520 {
2521 ACPI_STATUS Status;
2522 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
2523 ACPI_S3PT_HEADER *SubTable;
2524 ACPI_DMTABLE_INFO *InfoTable;
2525 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
2526
2527
2528 /* Main table */
2529
2530 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
2531 if (ACPI_FAILURE (Status))
2532 {
2533 return 0;
2534 }
2535
2536 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, S3ptTable, Offset);
2537 while (Offset < S3ptTable->Length)
2538 {
2539 /* Common subtable header */
2540
2541 AcpiOsPrintf ("\n");
2542 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
2543 SubTable->Length, AcpiDmTableInfoS3ptHdr);
2544 if (ACPI_FAILURE (Status))
2545 {
2546 return 0;
2547 }
2548
2549 switch (SubTable->Type)
2550 {
2551 case ACPI_S3PT_TYPE_RESUME:
2552
2553 InfoTable = AcpiDmTableInfoS3pt0;
2554 break;
2555
2556 case ACPI_S3PT_TYPE_SUSPEND:
2557
2558 InfoTable = AcpiDmTableInfoS3pt1;
2559 break;
2560
2561 default:
2562
2563 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", SubTable->Type);
2564
2565 /* Attempt to continue */
2566
2567 if (!SubTable->Length)
2568 {
2569 AcpiOsPrintf ("Invalid zero length subtable\n");
2570 return 0;
2571 }
2572 goto NextSubTable;
2573 }
2574
2575 AcpiOsPrintf ("\n");
2576 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
2577 SubTable->Length, InfoTable);
2578 if (ACPI_FAILURE (Status))
2579 {
2580 return 0;
2581 }
2582
2583 NextSubTable:
2584 /* Point to next subtable */
2585
2586 Offset += SubTable->Length;
2587 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, SubTable, SubTable->Length);
2588 }
2589
2590 return (S3ptTable->Length);
2591 }
2592
2593
2594 /*******************************************************************************
2595 *
2596 * FUNCTION: AcpiDmDumpSlic
2597 *
2598 * PARAMETERS: Table - A SLIC table
2599 *
2600 * RETURN: None
2601 *
2602 * DESCRIPTION: Format the contents of a SLIC
2603 *
2604 ******************************************************************************/
2605
2606 void
2607 AcpiDmDumpSlic (
2608 ACPI_TABLE_HEADER *Table)
2609 {
2610 ACPI_STATUS Status;
2611 UINT32 Offset = sizeof (ACPI_TABLE_SLIC);
2612 ACPI_SLIC_HEADER *SubTable;
2613 ACPI_DMTABLE_INFO *InfoTable;
2614
2615
2616 /* There is no main SLIC table, only subtables */
2617
2618 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset);
2619 while (Offset < Table->Length)
2620 {
2621 /* Common subtable header */
2622
2623 AcpiOsPrintf ("\n");
2624 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2625 SubTable->Length, AcpiDmTableInfoSlicHdr);
2626 if (ACPI_FAILURE (Status))
2627 {
2628 return;
2629 }
2630
2631 switch (SubTable->Type)
2632 {
2633 case ACPI_SLIC_TYPE_PUBLIC_KEY:
2634
2635 InfoTable = AcpiDmTableInfoSlic0;
2636 break;
2637
2638 case ACPI_SLIC_TYPE_WINDOWS_MARKER:
2639
2640 InfoTable = AcpiDmTableInfoSlic1;
2641 break;
2642
2643 default:
2644
2645 AcpiOsPrintf ("\n**** Unknown SLIC subtable type 0x%X\n", SubTable->Type);
2646
2647 /* Attempt to continue */
2648
2649 if (!SubTable->Length)
2650 {
2651 AcpiOsPrintf ("Invalid zero length subtable\n");
2652 return;
2653 }
2654 goto NextSubTable;
2655 }
2656
2657 AcpiOsPrintf ("\n");
2658 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2659 SubTable->Length, InfoTable);
2660 if (ACPI_FAILURE (Status))
2661 {
2662 return;
2663 }
2664
2665 NextSubTable:
2666 /* Point to next subtable */
2667
2668 Offset += SubTable->Length;
2669 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length);
2670 }
2671 }
2672
2673
2674 /*******************************************************************************
2675 *
2676 * FUNCTION: AcpiDmDumpSlit
2677 *
2678 * PARAMETERS: Table - An SLIT
2679 *
2680 * RETURN: None
2681 *
2682 * DESCRIPTION: Format the contents of a SLIT
2683 *
2684 ******************************************************************************/
2685
2686 void
2687 AcpiDmDumpSlit (
2688 ACPI_TABLE_HEADER *Table)
2689 {
2690 ACPI_STATUS Status;
2691 UINT32 Offset;
2692 UINT8 *Row;
2693 UINT32 Localities;
2694 UINT32 i;
2695 UINT32 j;
2696
2697
2698 /* Main table */
2699
2700 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
2701 if (ACPI_FAILURE (Status))
2702 {
2703 return;
2704 }
2705
2706 /* Display the Locality NxN Matrix */
2707
2708 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
2709 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
2710 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
2711
2712 for (i = 0; i < Localities; i++)
2713 {
2714 /* Display one row of the matrix */
2715
2716 AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
2717 for (j = 0; j < Localities; j++)
2718 {
2719 /* Check for beyond EOT */
2720
2721 if (Offset >= Table->Length)
2722 {
2723 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
2724 return;
2725 }
2726
2727 AcpiOsPrintf ("%2.2X", Row[j]);
2728 Offset++;
2729
2730 /* Display up to 16 bytes per output row */
2731
2732 if ((j+1) < Localities)
2733 {
2734 AcpiOsPrintf (" ");
2735
2736 if (j && (((j+1) % 16) == 0))
2737 {
2738 AcpiOsPrintf ("\\\n"); /* With line continuation char */
2739 AcpiDmLineHeader (Offset, 0, NULL);
2740 }
2741 }
2742 }
2743
2744 /* Point to next row */
2745
2746 AcpiOsPrintf ("\n");
2747 Row += Localities;
2748 }
2749 }
2750
2751
2752 /*******************************************************************************
2753 *
2754 * FUNCTION: AcpiDmDumpSrat
2755 *
2756 * PARAMETERS: Table - A SRAT table
2757 *
2758 * RETURN: None
2759 *
2760 * DESCRIPTION: Format the contents of a SRAT
2761 *
2762 ******************************************************************************/
2763
2764 void
2765 AcpiDmDumpSrat (
2766 ACPI_TABLE_HEADER *Table)
2767 {
2768 ACPI_STATUS Status;
2769 UINT32 Offset = sizeof (ACPI_TABLE_SRAT);
2770 ACPI_SUBTABLE_HEADER *SubTable;
2771 ACPI_DMTABLE_INFO *InfoTable;
2772
2773
2774 /* Main table */
2775
2776 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
2777 if (ACPI_FAILURE (Status))
2778 {
2779 return;
2780 }
2781
2782 /* Subtables */
2783
2784 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2785 while (Offset < Table->Length)
2786 {
2787 /* Common subtable header */
2788
2789 AcpiOsPrintf ("\n");
2790 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2791 SubTable->Length, AcpiDmTableInfoSratHdr);
2792 if (ACPI_FAILURE (Status))
2793 {
2794 return;
2795 }
2796
2797 switch (SubTable->Type)
2798 {
2799 case ACPI_SRAT_TYPE_CPU_AFFINITY:
2800
2801 InfoTable = AcpiDmTableInfoSrat0;
2802 break;
2803
2804 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
2805
2806 InfoTable = AcpiDmTableInfoSrat1;
2807 break;
2808
2809 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
2810
2811 InfoTable = AcpiDmTableInfoSrat2;
2812 break;
2813
2814 default:
2815 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n", SubTable->Type);
2816
2817 /* Attempt to continue */
2818
2819 if (!SubTable->Length)
2820 {
2821 AcpiOsPrintf ("Invalid zero length subtable\n");
2822 return;
2823 }
2824 goto NextSubTable;
2825 }
2826
2827 AcpiOsPrintf ("\n");
2828 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2829 SubTable->Length, InfoTable);
2830 if (ACPI_FAILURE (Status))
2831 {
2832 return;
2833 }
2834
2835 NextSubTable:
2836 /* Point to next subtable */
2837
2838 Offset += SubTable->Length;
2839 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
2840 }
2841 }
2842
2843
2844 /*******************************************************************************
2845 *
2846 * FUNCTION: AcpiDmDumpVrtc
2847 *
2848 * PARAMETERS: Table - A VRTC table
2849 *
2850 * RETURN: None
2851 *
2852 * DESCRIPTION: Format the contents of a VRTC
2853 *
2854 ******************************************************************************/
2855
2856 void
2857 AcpiDmDumpVrtc (
2858 ACPI_TABLE_HEADER *Table)
2859 {
2860 ACPI_STATUS Status;
2861 UINT32 Offset = sizeof (ACPI_TABLE_VRTC);
2862 ACPI_VRTC_ENTRY *SubTable;
2863
2864
2865 /* Main table */
2866
2867 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc);
2868 if (ACPI_FAILURE (Status))
2869 {
2870 return;
2871 }
2872
2873 /* Subtables */
2874
2875 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset);
2876 while (Offset < Table->Length)
2877 {
2878 /* Common subtable header */
2879
2880 AcpiOsPrintf ("\n");
2881 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2882 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
2883 if (ACPI_FAILURE (Status))
2884 {
2885 return;
2886 }
2887
2888 /* Point to next subtable */
2889
2890 Offset += sizeof (ACPI_VRTC_ENTRY);
2891 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, sizeof (ACPI_VRTC_ENTRY));
2892 }
2893 }
2894
2895
2896 /*******************************************************************************
2897 *
2898 * FUNCTION: AcpiDmDumpWdat
2899 *
2900 * PARAMETERS: Table - A WDAT table
2901 *
2902 * RETURN: None
2903 *
2904 * DESCRIPTION: Format the contents of a WDAT
2905 *
2906 ******************************************************************************/
2907
2908 void
2909 AcpiDmDumpWdat (
2910 ACPI_TABLE_HEADER *Table)
2911 {
2912 ACPI_STATUS Status;
2913 UINT32 Offset = sizeof (ACPI_TABLE_WDAT);
2914 ACPI_WDAT_ENTRY *SubTable;
2915
2916
2917 /* Main table */
2918
2919 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
2920 if (ACPI_FAILURE (Status))
2921 {
2922 return;
2923 }
2924
2925 /* Subtables */
2926
2927 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
2928 while (Offset < Table->Length)
2929 {
2930 /* Common subtable header */
2931
2932 AcpiOsPrintf ("\n");
2933 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2934 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
2935 if (ACPI_FAILURE (Status))
2936 {
2937 return;
2938 }
2939
2940 /* Point to next subtable */
2941
2942 Offset += sizeof (ACPI_WDAT_ENTRY);
2943 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));
2944 }
2945 }
Clone of Haiku svn repository