1 /******************************************************************************
2 *
3 * Module Name: dmtbdump1 - Dump ACPI data tables that contain no AML code
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2022, 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 MERCHANTABILITY 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 #include "aslcompiler.h"
49
50 /* This module used for application-level code only */
51
52 #define _COMPONENT ACPI_CA_DISASSEMBLER
53 ACPI_MODULE_NAME ("dmtbdump1")
54
55
56 /*******************************************************************************
57 *
58 * FUNCTION: AcpiDmDumpAest
59 *
60 * PARAMETERS: Table - A AEST table
61 *
62 * RETURN: None
63 *
64 * DESCRIPTION: Format the contents of a AEST table
65 *
66 * NOTE: Assumes the following table structure:
67 * For all AEST Error Nodes:
68 * 1) An AEST Error Node, followed immediately by:
69 * 2) Any node-specific data
70 * 3) An Interface Structure (one)
71 * 4) A list (array) of Interrupt Structures
72 *
73 * AEST - ARM Error Source table. Conforms to:
74 * ACPI for the Armv8 RAS Extensions 1.1 Platform Design Document Sep 2020
75 *
76 ******************************************************************************/
77
78 void
AcpiDmDumpAest(ACPI_TABLE_HEADER * Table)79 AcpiDmDumpAest (
80 ACPI_TABLE_HEADER *Table)
81 {
82 ACPI_STATUS Status;
83 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
84 ACPI_AEST_HEADER *Subtable;
85 ACPI_AEST_HEADER *NodeHeader;
86 ACPI_AEST_PROCESSOR *ProcessorSubtable;
87 ACPI_DMTABLE_INFO *InfoTable;
88 ACPI_SIZE Length;
89 UINT8 Type;
90
91
92 /* Very small, generic main table. AEST consists of mostly subtables */
93
94 while (Offset < Table->Length)
95 {
96 NodeHeader = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
97
98 /* Dump the common error node (subtable) header */
99
100 Status = AcpiDmDumpTable (Table->Length, Offset, NodeHeader,
101 NodeHeader->Length, AcpiDmTableInfoAestHdr);
102 if (ACPI_FAILURE (Status))
103 {
104 return;
105 }
106
107 Type = NodeHeader->Type;
108
109 /* Setup the node-specific subtable based on the header Type field */
110
111 switch (Type)
112 {
113 case ACPI_AEST_PROCESSOR_ERROR_NODE:
114 InfoTable = AcpiDmTableInfoAestProcError;
115 Length = sizeof (ACPI_AEST_PROCESSOR);
116 break;
117
118 case ACPI_AEST_MEMORY_ERROR_NODE:
119 InfoTable = AcpiDmTableInfoAestMemError;
120 Length = sizeof (ACPI_AEST_MEMORY);
121 break;
122
123 case ACPI_AEST_SMMU_ERROR_NODE:
124 InfoTable = AcpiDmTableInfoAestSmmuError;
125 Length = sizeof (ACPI_AEST_SMMU);
126 break;
127
128 case ACPI_AEST_VENDOR_ERROR_NODE:
129 InfoTable = AcpiDmTableInfoAestVendorError;
130 Length = sizeof (ACPI_AEST_VENDOR);
131 break;
132
133 case ACPI_AEST_GIC_ERROR_NODE:
134 InfoTable = AcpiDmTableInfoAestGicError;
135 Length = sizeof (ACPI_AEST_GIC);
136 break;
137
138 /* Error case below */
139 default:
140
141 AcpiOsPrintf ("\n**** Unknown AEST Error Subtable type 0x%X\n",
142 Type);
143 return;
144 }
145
146 /* Point past the common header (to the node-specific data) */
147
148 Offset += sizeof (ACPI_AEST_HEADER);
149 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
150 AcpiOsPrintf ("\n");
151
152 /* Dump the node-specific subtable */
153
154 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length,
155 InfoTable);
156 if (ACPI_FAILURE (Status))
157 {
158 return;
159 }
160 AcpiOsPrintf ("\n");
161
162 if (Type == ACPI_AEST_PROCESSOR_ERROR_NODE)
163 {
164 /*
165 * Special handling for PROCESSOR_ERROR_NODE subtables
166 * (to handle the Resource Substructure via the ResourceType
167 * field).
168 */
169
170 /* Point past the node-specific data */
171
172 Offset += Length;
173 ProcessorSubtable = ACPI_CAST_PTR (ACPI_AEST_PROCESSOR, Subtable);
174
175 switch (ProcessorSubtable->ResourceType)
176 {
177 /* Setup the Resource Substructure subtable */
178
179 case ACPI_AEST_CACHE_RESOURCE:
180 InfoTable = AcpiDmTableInfoAestCacheRsrc;
181 Length = sizeof (ACPI_AEST_PROCESSOR_CACHE);
182 break;
183
184 case ACPI_AEST_TLB_RESOURCE:
185 InfoTable = AcpiDmTableInfoAestTlbRsrc;
186 Length = sizeof (ACPI_AEST_PROCESSOR_TLB);
187 break;
188
189 case ACPI_AEST_GENERIC_RESOURCE:
190 InfoTable = AcpiDmTableInfoAestGenRsrc;
191 Length = sizeof (ACPI_AEST_PROCESSOR_GENERIC);
192 break;
193
194 /* Error case below */
195 default:
196 AcpiOsPrintf ("\n**** Unknown AEST Processor Resource type 0x%X\n",
197 ProcessorSubtable->ResourceType);
198 return;
199 }
200
201 ProcessorSubtable = ACPI_ADD_PTR (ACPI_AEST_PROCESSOR, Table,
202 Offset);
203
204 /* Dump the resource substructure subtable */
205
206 Status = AcpiDmDumpTable (Table->Length, Offset, ProcessorSubtable,
207 Length, InfoTable);
208 if (ACPI_FAILURE (Status))
209 {
210 return;
211 }
212
213 AcpiOsPrintf ("\n");
214 }
215
216 /* Point past the resource substructure or the node-specific data */
217
218 Offset += Length;
219
220 /* Dump the interface structure, required to be present */
221
222 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
223 if (Subtable->Type >= ACPI_AEST_XFACE_RESERVED)
224 {
225 AcpiOsPrintf ("\n**** Unknown AEST Node Interface type 0x%X\n",
226 Subtable->Type);
227 return;
228 }
229
230 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
231 sizeof (ACPI_AEST_NODE_INTERFACE), AcpiDmTableInfoAestXface);
232 if (ACPI_FAILURE (Status))
233 {
234 return;
235 }
236
237 /* Point past the interface structure */
238
239 AcpiOsPrintf ("\n");
240 Offset += sizeof (ACPI_AEST_NODE_INTERFACE);
241
242 /* Dump the entire interrupt structure array, if present */
243
244 if (NodeHeader->NodeInterruptOffset)
245 {
246 Length = NodeHeader->NodeInterruptCount;
247 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
248
249 while (Length)
250 {
251 /* Dump the interrupt structure */
252
253 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
254 sizeof (ACPI_AEST_NODE_INTERRUPT),
255 AcpiDmTableInfoAestXrupt);
256 if (ACPI_FAILURE (Status))
257 {
258 return;
259 }
260
261 /* Point to the next interrupt structure */
262
263 Offset += sizeof (ACPI_AEST_NODE_INTERRUPT);
264 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
265 Length--;
266 AcpiOsPrintf ("\n");
267 }
268 }
269 }
270 }
271
272 /*******************************************************************************
273 *
274 * FUNCTION: AcpiDmDumpApmt
275 *
276 * PARAMETERS: Table - A APMT table
277 *
278 * RETURN: None
279 *
280 * DESCRIPTION: Format the contents of a APMT. This table type consists
281 * of an open-ended number of subtables.
282 *
283 *
284 * APMT - ARM Performance Monitoring Unit table. Conforms to:
285 * ARM Performance Monitoring Unit Architecture 1.0 Platform Design Document
286 * ARM DEN0117 v1.0 November 25, 2021
287 *
288 ******************************************************************************/
289
290 void
AcpiDmDumpApmt(ACPI_TABLE_HEADER * Table)291 AcpiDmDumpApmt (
292 ACPI_TABLE_HEADER *Table)
293 {
294 ACPI_STATUS Status;
295 ACPI_APMT_NODE *Subtable;
296 UINT32 Length = Table->Length;
297 UINT32 Offset = sizeof (ACPI_TABLE_APMT);
298 UINT32 NodeNum = 0;
299
300 /* There is no main table (other than the standard ACPI header) */
301
302 /* Subtables */
303
304 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Table, Offset);
305 while (Offset < Table->Length)
306 {
307 AcpiOsPrintf ("\n");
308
309 if (Subtable->Type >= ACPI_APMT_NODE_TYPE_COUNT)
310 {
311 AcpiOsPrintf ("\n**** Unknown APMT subtable type 0x%X\n",
312 Subtable->Type);
313 return;
314 }
315
316 AcpiOsPrintf ("/* APMT Node-%u */\n", NodeNum++);
317
318 Status = AcpiDmDumpTable (Length, Offset, Subtable,
319 Subtable->Length, AcpiDmTableInfoApmtNode);
320 if (ACPI_FAILURE (Status))
321 {
322 return;
323 }
324
325 /* Point to next subtable */
326
327 Offset += Subtable->Length;
328 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Subtable,
329 Subtable->Length);
330 AcpiOsPrintf ("\n");
331 }
332 }
333
334
335 /*******************************************************************************
336 *
337 * FUNCTION: AcpiDmDumpAsf
338 *
339 * PARAMETERS: Table - A ASF table
340 *
341 * RETURN: None
342 *
343 * DESCRIPTION: Format the contents of a ASF table
344 *
345 ******************************************************************************/
346
347 void
AcpiDmDumpAsf(ACPI_TABLE_HEADER * Table)348 AcpiDmDumpAsf (
349 ACPI_TABLE_HEADER *Table)
350 {
351 ACPI_STATUS Status;
352 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
353 ACPI_ASF_INFO *Subtable;
354 ACPI_DMTABLE_INFO *InfoTable;
355 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
356 UINT8 *DataTable = NULL;
357 UINT32 DataCount = 0;
358 UINT32 DataLength = 0;
359 UINT32 DataOffset = 0;
360 UINT32 i;
361 UINT8 Type;
362
363
364 /* No main table, only subtables */
365
366 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
367 while (Offset < Table->Length)
368 {
369 /* Common subtable header */
370
371 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
372 Subtable->Header.Length, AcpiDmTableInfoAsfHdr);
373 if (ACPI_FAILURE (Status))
374 {
375 return;
376 }
377
378 /* The actual type is the lower 7 bits of Type */
379
380 Type = (UINT8) (Subtable->Header.Type & 0x7F);
381
382 switch (Type)
383 {
384 case ACPI_ASF_TYPE_INFO:
385
386 InfoTable = AcpiDmTableInfoAsf0;
387 break;
388
389 case ACPI_ASF_TYPE_ALERT:
390
391 InfoTable = AcpiDmTableInfoAsf1;
392 DataInfoTable = AcpiDmTableInfoAsf1a;
393 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT));
394 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts;
395 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength;
396 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
397 break;
398
399 case ACPI_ASF_TYPE_CONTROL:
400
401 InfoTable = AcpiDmTableInfoAsf2;
402 DataInfoTable = AcpiDmTableInfoAsf2a;
403 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE));
404 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls;
405 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength;
406 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
407 break;
408
409 case ACPI_ASF_TYPE_BOOT:
410
411 InfoTable = AcpiDmTableInfoAsf3;
412 break;
413
414 case ACPI_ASF_TYPE_ADDRESS:
415
416 InfoTable = AcpiDmTableInfoAsf4;
417 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS));
418 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices;
419 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
420 break;
421
422 default:
423
424 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
425 Subtable->Header.Type);
426 return;
427 }
428
429 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
430 Subtable->Header.Length, InfoTable);
431 if (ACPI_FAILURE (Status))
432 {
433 return;
434 }
435
436 /* Dump variable-length extra data */
437
438 switch (Type)
439 {
440 case ACPI_ASF_TYPE_ALERT:
441 case ACPI_ASF_TYPE_CONTROL:
442
443 for (i = 0; i < DataCount; i++)
444 {
445 AcpiOsPrintf ("\n");
446 Status = AcpiDmDumpTable (Table->Length, DataOffset,
447 DataTable, DataLength, DataInfoTable);
448 if (ACPI_FAILURE (Status))
449 {
450 return;
451 }
452
453 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
454 DataOffset += DataLength;
455 }
456 break;
457
458 case ACPI_ASF_TYPE_ADDRESS:
459
460 for (i = 0; i < DataLength; i++)
461 {
462 if (!(i % 16))
463 {
464 AcpiDmLineHeader (DataOffset, 1, "Addresses");
465 }
466
467 AcpiOsPrintf ("%2.2X ", *DataTable);
468 DataTable++;
469 DataOffset++;
470
471 if (DataOffset > Table->Length)
472 {
473 AcpiOsPrintf (
474 "**** ACPI table terminates in the middle of a "
475 "data structure! (ASF! table)\n");
476 return;
477 }
478 }
479
480 AcpiOsPrintf ("\n");
481 break;
482
483 default:
484
485 break;
486 }
487
488 AcpiOsPrintf ("\n");
489
490 /* Point to next subtable */
491
492 if (!Subtable->Header.Length)
493 {
494 AcpiOsPrintf ("Invalid zero subtable header length\n");
495 return;
496 }
497
498 Offset += Subtable->Header.Length;
499 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable,
500 Subtable->Header.Length);
501 }
502 }
503
504
505 /*******************************************************************************
506 *
507 * FUNCTION: AcpiDmDumpCdat
508 *
509 * PARAMETERS: InTable - A CDAT table
510 *
511 * RETURN: None
512 *
513 * DESCRIPTION: Format the contents of a CDAT. This table type consists
514 * of an open-ended number of subtables.
515 *
516 ******************************************************************************/
517
518 void
AcpiDmDumpCdat(ACPI_TABLE_HEADER * InTable)519 AcpiDmDumpCdat (
520 ACPI_TABLE_HEADER *InTable)
521 {
522 ACPI_TABLE_CDAT *Table = ACPI_CAST_PTR (ACPI_TABLE_CDAT, InTable);
523 ACPI_STATUS Status;
524 ACPI_CDAT_HEADER *Subtable;
525 ACPI_TABLE_CDAT *CdatTable = ACPI_CAST_PTR (ACPI_TABLE_CDAT, Table);
526 ACPI_DMTABLE_INFO *InfoTable;
527 UINT32 Length = CdatTable->Length;
528 UINT32 Offset = sizeof (ACPI_TABLE_CDAT);
529 UINT32 SubtableLength;
530 UINT32 SubtableType;
531 INT32 EntriesLength;
532
533
534 /* Main table */
535
536 Status = AcpiDmDumpTable (Offset, 0, CdatTable, 0,
537 AcpiDmTableInfoCdatTableHdr);
538 if (ACPI_FAILURE (Status))
539 {
540 return;
541 }
542
543 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, sizeof (ACPI_TABLE_CDAT));
544 while (Offset < Table->Length)
545 {
546 /* Dump the common subtable header */
547
548 DbgPrint (ASL_DEBUG_OUTPUT, "0) HeaderOffset: %X\n", Offset);
549 AcpiOsPrintf ("\n");
550 Status = AcpiDmDumpTable (Length, Offset, Subtable,
551 sizeof (ACPI_CDAT_HEADER), AcpiDmTableInfoCdatHeader);
552 if (ACPI_FAILURE (Status))
553 {
554 return;
555 }
556
557 /* Point past the common subtable header, decode the subtable type */
558
559 Offset += sizeof (ACPI_CDAT_HEADER);
560 SubtableType = Subtable->Type;
561
562 switch (Subtable->Type)
563 {
564 case ACPI_CDAT_TYPE_DSMAS:
565 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
566 SubtableLength = sizeof (ACPI_CDAT_DSMAS);
567
568 InfoTable = AcpiDmTableInfoCdat0;
569 break;
570
571 case ACPI_CDAT_TYPE_DSLBIS:
572 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
573 SubtableLength = sizeof (ACPI_CDAT_DSLBIS);
574 DbgPrint (ASL_DEBUG_OUTPUT, "1) Offset: %X\n", Offset);
575
576 InfoTable = AcpiDmTableInfoCdat1;
577 break;
578
579 case ACPI_CDAT_TYPE_DSMSCIS:
580 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
581 SubtableLength = sizeof (ACPI_CDAT_DSMSCIS);
582
583 InfoTable = AcpiDmTableInfoCdat2;
584 break;
585
586 case ACPI_CDAT_TYPE_DSIS:
587 DbgPrint (ASL_DEBUG_OUTPUT, "2) Offset: %X ", Offset);
588 SubtableLength = sizeof (ACPI_CDAT_DSIS);
589 DbgPrint (ASL_DEBUG_OUTPUT, "1) input pointer: %p\n", Table);
590 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
591 DbgPrint (ASL_DEBUG_OUTPUT, "1) output pointers: %p, %p, Offset: %X\n",
592 Table, Subtable, Offset);
593 DbgPrint (ASL_DEBUG_OUTPUT, "3) Offset: %X\n", Offset);
594
595 InfoTable = AcpiDmTableInfoCdat3;
596 break;
597
598 case ACPI_CDAT_TYPE_DSEMTS:
599 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
600 SubtableLength = sizeof (ACPI_CDAT_DSEMTS);
601
602 InfoTable = AcpiDmTableInfoCdat4;
603 break;
604
605 case ACPI_CDAT_TYPE_SSLBIS:
606 SubtableLength = Subtable->Length;
607
608 InfoTable = AcpiDmTableInfoCdat5;
609 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
610 break;
611
612 default:
613 fprintf (stderr, "ERROR: Unknown SubtableType: %X\n", Subtable->Type);
614 return;
615 }
616
617 DbgPrint (ASL_DEBUG_OUTPUT, "SubtableType: %X, Length: %X Actual "
618 "Length: %X Offset: %X tableptr: %p\n", SubtableType,
619 Subtable->Length, SubtableLength, Offset, Table);
620
621 /*
622 * Do the subtable-specific fields
623 */
624 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset, InfoTable);
625 if (ACPI_FAILURE (Status))
626 {
627 return;
628 }
629
630 DbgPrint (ASL_DEBUG_OUTPUT, "Subtable Type: %X, Offset: %X, SubtableLength: %X\n",
631 SubtableType, Offset, SubtableLength);
632
633 /* Additional sub-subtables, dependent on the main subtable type */
634
635 switch (SubtableType)
636 {
637 case ACPI_CDAT_TYPE_SSLBIS:
638 Offset += sizeof (ACPI_CDAT_SSLBIS);
639 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table,
640 Offset);
641
642 DbgPrint (ASL_DEBUG_OUTPUT, "Case SSLBIS, Offset: %X, SubtableLength: %X "
643 "Subtable->Length %X\n", Offset, SubtableLength, Subtable->Length);
644
645 /* Generate the total length of all the SSLBE entries */
646
647 EntriesLength = SubtableLength - sizeof (ACPI_CDAT_HEADER) -
648 sizeof (ACPI_CDAT_SSLBIS);
649 DbgPrint (ASL_DEBUG_OUTPUT, "EntriesLength: %X, Offset: %X, Table->Length: %X\n",
650 EntriesLength, Offset, Table->Length);
651
652 /* Do each of the SSLBE Entries */
653
654 while ((EntriesLength > 0) && (Offset < Table->Length))
655 {
656 AcpiOsPrintf ("\n");
657
658 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset,
659 AcpiDmTableInfoCdatEntries);
660 if (ACPI_FAILURE (Status))
661 {
662 return;
663 }
664
665 EntriesLength -= sizeof (ACPI_CDAT_SSLBE);
666 Offset += sizeof (ACPI_CDAT_SSLBE);
667 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
668 }
669
670 SubtableLength = 0;
671 break;
672
673 default:
674 break;
675 }
676
677 DbgPrint (ASL_DEBUG_OUTPUT, "Offset: %X, Subtable Length: %X\n",
678 Offset, SubtableLength);
679
680 /* Point to next subtable */
681
682 Offset += SubtableLength;
683 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
684 }
685
686 return;
687 }
688
689
690 /*******************************************************************************
691 *
692 * FUNCTION: AcpiDmDumpCedt
693 *
694 * PARAMETERS: Table - A CEDT table
695 *
696 * RETURN: None
697 *
698 * DESCRIPTION: Format the contents of a CEDT. This table type consists
699 * of an open-ended number of subtables.
700 *
701 ******************************************************************************/
702
703 void
AcpiDmDumpCedt(ACPI_TABLE_HEADER * Table)704 AcpiDmDumpCedt (
705 ACPI_TABLE_HEADER *Table)
706 {
707 ACPI_STATUS Status;
708 ACPI_CEDT_HEADER *Subtable;
709 UINT32 Length = Table->Length;
710 UINT32 Offset = sizeof (ACPI_TABLE_CEDT);
711
712
713 /* There is no main table (other than the standard ACPI header) */
714
715 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset);
716 while (Offset < Table->Length)
717 {
718 /* Common subtable header */
719
720 AcpiOsPrintf ("\n");
721 Status = AcpiDmDumpTable (Length, Offset, Subtable,
722 Subtable->Length, AcpiDmTableInfoCedtHdr);
723 if (ACPI_FAILURE (Status))
724 {
725 return;
726 }
727
728 switch (Subtable->Type)
729 {
730 case ACPI_CEDT_TYPE_CHBS:
731 Status = AcpiDmDumpTable (Length, Offset, Subtable,
732 Subtable->Length, AcpiDmTableInfoCedt0);
733 if (ACPI_FAILURE (Status))
734 {
735 return;
736 }
737 break;
738
739 case ACPI_CEDT_TYPE_CFMWS:
740 {
741 ACPI_CEDT_CFMWS *ptr = (ACPI_CEDT_CFMWS *) Subtable;
742 unsigned int i, max = 0x01 << (ptr->InterleaveWays);
743
744 /* print out table with first "Interleave target" */
745
746 Status = AcpiDmDumpTable (Length, Offset, Subtable,
747 Subtable->Length, AcpiDmTableInfoCedt1);
748 if (ACPI_FAILURE (Status))
749 {
750 return;
751 }
752
753 /* Now, print out any interleave targets beyond the first. */
754
755 for (i = 1; i < max; i++)
756 {
757 unsigned int loc_offset = Offset + (i * 4) + ACPI_OFFSET (ACPI_CEDT_CFMWS, InterleaveTargets);
758 unsigned int *trg = &(ptr->InterleaveTargets[i]);
759
760 Status = AcpiDmDumpTable (Length, loc_offset, trg,
761 Subtable->Length, AcpiDmTableInfoCedt1_te);
762 if (ACPI_FAILURE (Status))
763 {
764 return;
765 }
766 }
767 break;
768 }
769
770 default:
771 AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n",
772 Subtable->Type);
773
774 /* Attempt to continue */
775 if (!Subtable->Length)
776 {
777 AcpiOsPrintf ("Invalid zero length subtable\n");
778 return;
779 }
780 }
781
782 /* Point to next subtable */
783 Offset += Subtable->Length;
784 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable,
785 Subtable->Length);
786 }
787 }
788
789 /*******************************************************************************
790 *
791 * FUNCTION: AcpiDmDumpCpep
792 *
793 * PARAMETERS: Table - A CPEP table
794 *
795 * RETURN: None
796 *
797 * DESCRIPTION: Format the contents of a CPEP. This table type consists
798 * of an open-ended number of subtables.
799 *
800 ******************************************************************************/
801
802 void
AcpiDmDumpCpep(ACPI_TABLE_HEADER * Table)803 AcpiDmDumpCpep (
804 ACPI_TABLE_HEADER *Table)
805 {
806 ACPI_STATUS Status;
807 ACPI_CPEP_POLLING *Subtable;
808 UINT32 Length = Table->Length;
809 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
810
811
812 /* Main table */
813
814 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
815 if (ACPI_FAILURE (Status))
816 {
817 return;
818 }
819
820 /* Subtables */
821
822 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
823 while (Offset < Table->Length)
824 {
825 AcpiOsPrintf ("\n");
826 Status = AcpiDmDumpTable (Length, Offset, Subtable,
827 Subtable->Header.Length, AcpiDmTableInfoCpep0);
828 if (ACPI_FAILURE (Status))
829 {
830 return;
831 }
832
833 /* Point to next subtable */
834
835 Offset += Subtable->Header.Length;
836 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable,
837 Subtable->Header.Length);
838 }
839 }
840
841
842 /*******************************************************************************
843 *
844 * FUNCTION: AcpiDmDumpCsrt
845 *
846 * PARAMETERS: Table - A CSRT table
847 *
848 * RETURN: None
849 *
850 * DESCRIPTION: Format the contents of a CSRT. This table type consists
851 * of an open-ended number of subtables.
852 *
853 ******************************************************************************/
854
855 void
AcpiDmDumpCsrt(ACPI_TABLE_HEADER * Table)856 AcpiDmDumpCsrt (
857 ACPI_TABLE_HEADER *Table)
858 {
859 ACPI_STATUS Status;
860 ACPI_CSRT_GROUP *Subtable;
861 ACPI_CSRT_SHARED_INFO *SharedInfoTable;
862 ACPI_CSRT_DESCRIPTOR *SubSubtable;
863 UINT32 Length = Table->Length;
864 UINT32 Offset = sizeof (ACPI_TABLE_CSRT);
865 UINT32 SubOffset;
866 UINT32 SubSubOffset;
867 UINT32 InfoLength;
868
869
870 /* The main table only contains the ACPI header, thus already handled */
871
872 /* Subtables (Resource Groups) */
873
874 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
875 while (Offset < Table->Length)
876 {
877 /* Resource group subtable */
878
879 AcpiOsPrintf ("\n");
880 Status = AcpiDmDumpTable (Length, Offset, Subtable,
881 Subtable->Length, AcpiDmTableInfoCsrt0);
882 if (ACPI_FAILURE (Status))
883 {
884 return;
885 }
886
887 /* Shared info subtable (One per resource group) */
888
889 SubOffset = sizeof (ACPI_CSRT_GROUP);
890 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
891 Offset + SubOffset);
892
893 AcpiOsPrintf ("\n");
894 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
895 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
896 if (ACPI_FAILURE (Status))
897 {
898 return;
899 }
900
901 SubOffset += Subtable->SharedInfoLength;
902
903 /* Sub-Subtables (Resource Descriptors) */
904
905 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
906 Offset + SubOffset);
907
908 while ((SubOffset < Subtable->Length) &&
909 ((Offset + SubOffset) < Table->Length))
910 {
911 AcpiOsPrintf ("\n");
912 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable,
913 SubSubtable->Length, AcpiDmTableInfoCsrt2);
914 if (ACPI_FAILURE (Status))
915 {
916 return;
917 }
918
919 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
920
921 /* Resource-specific info buffer */
922
923 InfoLength = SubSubtable->Length - SubSubOffset;
924 if (InfoLength)
925 {
926 Status = AcpiDmDumpTable (Length,
927 Offset + SubOffset + SubSubOffset, Table,
928 InfoLength, AcpiDmTableInfoCsrt2a);
929 if (ACPI_FAILURE (Status))
930 {
931 return;
932 }
933 }
934
935 /* Point to next sub-subtable */
936
937 SubOffset += SubSubtable->Length;
938 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable,
939 SubSubtable->Length);
940 }
941
942 /* Point to next subtable */
943
944 Offset += Subtable->Length;
945 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable,
946 Subtable->Length);
947 }
948 }
949
950
951 /*******************************************************************************
952 *
953 * FUNCTION: AcpiDmDumpDbg2
954 *
955 * PARAMETERS: Table - A DBG2 table
956 *
957 * RETURN: None
958 *
959 * DESCRIPTION: Format the contents of a DBG2. This table type consists
960 * of an open-ended number of subtables.
961 *
962 ******************************************************************************/
963
964 void
AcpiDmDumpDbg2(ACPI_TABLE_HEADER * Table)965 AcpiDmDumpDbg2 (
966 ACPI_TABLE_HEADER *Table)
967 {
968 ACPI_STATUS Status;
969 ACPI_DBG2_DEVICE *Subtable;
970 UINT32 Length = Table->Length;
971 UINT32 Offset = sizeof (ACPI_TABLE_DBG2);
972 UINT32 i;
973 UINT32 ArrayOffset;
974 UINT32 AbsoluteOffset;
975 UINT8 *Array;
976
977
978 /* Main table */
979
980 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
981 if (ACPI_FAILURE (Status))
982 {
983 return;
984 }
985
986 /* Subtables */
987
988 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
989 while (Offset < Table->Length)
990 {
991 AcpiOsPrintf ("\n");
992 Status = AcpiDmDumpTable (Length, Offset, Subtable,
993 Subtable->Length, AcpiDmTableInfoDbg2Device);
994 if (ACPI_FAILURE (Status))
995 {
996 return;
997 }
998
999 /* Dump the BaseAddress array */
1000
1001 for (i = 0; i < Subtable->RegisterCount; i++)
1002 {
1003 ArrayOffset = Subtable->BaseAddressOffset +
1004 (sizeof (ACPI_GENERIC_ADDRESS) * i);
1005 AbsoluteOffset = Offset + ArrayOffset;
1006 Array = (UINT8 *) Subtable + ArrayOffset;
1007
1008 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1009 Subtable->Length, AcpiDmTableInfoDbg2Addr);
1010 if (ACPI_FAILURE (Status))
1011 {
1012 return;
1013 }
1014 }
1015
1016 /* Dump the AddressSize array */
1017
1018 for (i = 0; i < Subtable->RegisterCount; i++)
1019 {
1020 ArrayOffset = Subtable->AddressSizeOffset +
1021 (sizeof (UINT32) * i);
1022 AbsoluteOffset = Offset + ArrayOffset;
1023 Array = (UINT8 *) Subtable + ArrayOffset;
1024
1025 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1026 Subtable->Length, AcpiDmTableInfoDbg2Size);
1027 if (ACPI_FAILURE (Status))
1028 {
1029 return;
1030 }
1031 }
1032
1033 /* Dump the Namestring (required) */
1034
1035 AcpiOsPrintf ("\n");
1036 ArrayOffset = Subtable->NamepathOffset;
1037 AbsoluteOffset = Offset + ArrayOffset;
1038 Array = (UINT8 *) Subtable + ArrayOffset;
1039
1040 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1041 Subtable->Length, AcpiDmTableInfoDbg2Name);
1042 if (ACPI_FAILURE (Status))
1043 {
1044 return;
1045 }
1046
1047 /* Dump the OemData (optional) */
1048
1049 if (Subtable->OemDataOffset)
1050 {
1051 Status = AcpiDmDumpTable (Length, Offset + Subtable->OemDataOffset,
1052 Table, Subtable->OemDataLength,
1053 AcpiDmTableInfoDbg2OemData);
1054 if (ACPI_FAILURE (Status))
1055 {
1056 return;
1057 }
1058 }
1059
1060 /* Point to next subtable */
1061
1062 Offset += Subtable->Length;
1063 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable,
1064 Subtable->Length);
1065 }
1066 }
1067
1068
1069 /*******************************************************************************
1070 *
1071 * FUNCTION: AcpiDmDumpDmar
1072 *
1073 * PARAMETERS: Table - A DMAR table
1074 *
1075 * RETURN: None
1076 *
1077 * DESCRIPTION: Format the contents of a DMAR. This table type consists
1078 * of an open-ended number of subtables.
1079 *
1080 ******************************************************************************/
1081
1082 void
AcpiDmDumpDmar(ACPI_TABLE_HEADER * Table)1083 AcpiDmDumpDmar (
1084 ACPI_TABLE_HEADER *Table)
1085 {
1086 ACPI_STATUS Status;
1087 ACPI_DMAR_HEADER *Subtable;
1088 UINT32 Length = Table->Length;
1089 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
1090 ACPI_DMTABLE_INFO *InfoTable;
1091 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
1092 UINT32 ScopeOffset;
1093 UINT8 *PciPath;
1094 UINT32 PathOffset;
1095
1096
1097 /* Main table */
1098
1099 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
1100 if (ACPI_FAILURE (Status))
1101 {
1102 return;
1103 }
1104
1105 /* Subtables */
1106
1107 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
1108 while (Offset < Table->Length)
1109 {
1110 /* Common subtable header */
1111
1112 AcpiOsPrintf ("\n");
1113 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1114 Subtable->Length, AcpiDmTableInfoDmarHdr);
1115 if (ACPI_FAILURE (Status))
1116 {
1117 return;
1118 }
1119
1120 AcpiOsPrintf ("\n");
1121
1122 switch (Subtable->Type)
1123 {
1124 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
1125
1126 InfoTable = AcpiDmTableInfoDmar0;
1127 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
1128 break;
1129
1130 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
1131
1132 InfoTable = AcpiDmTableInfoDmar1;
1133 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
1134 break;
1135
1136 case ACPI_DMAR_TYPE_ROOT_ATS:
1137
1138 InfoTable = AcpiDmTableInfoDmar2;
1139 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
1140 break;
1141
1142 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
1143
1144 InfoTable = AcpiDmTableInfoDmar3;
1145 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
1146 break;
1147
1148 case ACPI_DMAR_TYPE_NAMESPACE:
1149
1150 InfoTable = AcpiDmTableInfoDmar4;
1151 ScopeOffset = sizeof (ACPI_DMAR_ANDD);
1152 break;
1153
1154 case ACPI_DMAR_TYPE_SATC:
1155
1156 InfoTable = AcpiDmTableInfoDmar5;
1157 ScopeOffset = sizeof (ACPI_DMAR_SATC);
1158 break;
1159
1160 default:
1161
1162 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
1163 Subtable->Type);
1164 return;
1165 }
1166
1167 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1168 Subtable->Length, InfoTable);
1169 if (ACPI_FAILURE (Status))
1170 {
1171 return;
1172 }
1173
1174 /*
1175 * Dump the optional device scope entries
1176 */
1177 if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
1178 (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE))
1179 {
1180 /* These types do not support device scopes */
1181
1182 goto NextSubtable;
1183 }
1184
1185 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset);
1186 while (ScopeOffset < Subtable->Length)
1187 {
1188 AcpiOsPrintf ("\n");
1189 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
1190 ScopeTable->Length, AcpiDmTableInfoDmarScope);
1191 if (ACPI_FAILURE (Status))
1192 {
1193 return;
1194 }
1195 AcpiOsPrintf ("\n");
1196
1197 /* Dump the PCI Path entries for this device scope */
1198
1199 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
1200
1201 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
1202 sizeof (ACPI_DMAR_DEVICE_SCOPE));
1203
1204 while (PathOffset < ScopeTable->Length)
1205 {
1206 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
1207 "PCI Path");
1208 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
1209
1210 /* Point to next PCI Path entry */
1211
1212 PathOffset += 2;
1213 PciPath += 2;
1214 AcpiOsPrintf ("\n");
1215 }
1216
1217 /* Point to next device scope entry */
1218
1219 ScopeOffset += ScopeTable->Length;
1220 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
1221 ScopeTable, ScopeTable->Length);
1222 }
1223
1224 NextSubtable:
1225 /* Point to next subtable */
1226
1227 Offset += Subtable->Length;
1228 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable,
1229 Subtable->Length);
1230 }
1231 }
1232
1233
1234 /*******************************************************************************
1235 *
1236 * FUNCTION: AcpiDmDumpDrtm
1237 *
1238 * PARAMETERS: Table - A DRTM table
1239 *
1240 * RETURN: None
1241 *
1242 * DESCRIPTION: Format the contents of a DRTM.
1243 *
1244 ******************************************************************************/
1245
1246 void
AcpiDmDumpDrtm(ACPI_TABLE_HEADER * Table)1247 AcpiDmDumpDrtm (
1248 ACPI_TABLE_HEADER *Table)
1249 {
1250 ACPI_STATUS Status;
1251 UINT32 Offset;
1252 ACPI_DRTM_VTABLE_LIST *DrtmVtl;
1253 ACPI_DRTM_RESOURCE_LIST *DrtmRl;
1254 ACPI_DRTM_DPS_ID *DrtmDps;
1255 UINT32 Count;
1256
1257
1258 /* Main table */
1259
1260 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
1261 AcpiDmTableInfoDrtm);
1262 if (ACPI_FAILURE (Status))
1263 {
1264 return;
1265 }
1266
1267 Offset = sizeof (ACPI_TABLE_DRTM);
1268
1269 /* Sub-tables */
1270
1271 /* Dump ValidatedTable length */
1272
1273 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
1274 AcpiOsPrintf ("\n");
1275 Status = AcpiDmDumpTable (Table->Length, Offset,
1276 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
1277 AcpiDmTableInfoDrtm0);
1278 if (ACPI_FAILURE (Status))
1279 {
1280 return;
1281 }
1282
1283 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
1284
1285 /* Dump Validated table addresses */
1286
1287 Count = 0;
1288 while ((Offset < Table->Length) &&
1289 (DrtmVtl->ValidatedTableCount > Count))
1290 {
1291 Status = AcpiDmDumpTable (Table->Length, Offset,
1292 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
1293 AcpiDmTableInfoDrtm0a);
1294 if (ACPI_FAILURE (Status))
1295 {
1296 return;
1297 }
1298
1299 Offset += sizeof (UINT64);
1300 Count++;
1301 }
1302
1303 /* Dump ResourceList length */
1304
1305 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
1306 AcpiOsPrintf ("\n");
1307 Status = AcpiDmDumpTable (Table->Length, Offset,
1308 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
1309 AcpiDmTableInfoDrtm1);
1310 if (ACPI_FAILURE (Status))
1311 {
1312 return;
1313 }
1314
1315 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
1316
1317 /* Dump the Resource List */
1318
1319 Count = 0;
1320 while ((Offset < Table->Length) &&
1321 (DrtmRl->ResourceCount > Count))
1322 {
1323 Status = AcpiDmDumpTable (Table->Length, Offset,
1324 ACPI_ADD_PTR (void, Table, Offset),
1325 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
1326 if (ACPI_FAILURE (Status))
1327 {
1328 return;
1329 }
1330
1331 Offset += sizeof (ACPI_DRTM_RESOURCE);
1332 Count++;
1333 }
1334
1335 /* Dump DPS */
1336
1337 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
1338 AcpiOsPrintf ("\n");
1339 (void) AcpiDmDumpTable (Table->Length, Offset,
1340 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
1341 }
1342
1343
1344 /*******************************************************************************
1345 *
1346 * FUNCTION: AcpiDmDumpEinj
1347 *
1348 * PARAMETERS: Table - A EINJ table
1349 *
1350 * RETURN: None
1351 *
1352 * DESCRIPTION: Format the contents of a EINJ. This table type consists
1353 * of an open-ended number of subtables.
1354 *
1355 ******************************************************************************/
1356
1357 void
AcpiDmDumpEinj(ACPI_TABLE_HEADER * Table)1358 AcpiDmDumpEinj (
1359 ACPI_TABLE_HEADER *Table)
1360 {
1361 ACPI_STATUS Status;
1362 ACPI_WHEA_HEADER *Subtable;
1363 UINT32 Length = Table->Length;
1364 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
1365
1366
1367 /* Main table */
1368
1369 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
1370 if (ACPI_FAILURE (Status))
1371 {
1372 return;
1373 }
1374
1375 /* Subtables */
1376
1377 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1378 while (Offset < Table->Length)
1379 {
1380 AcpiOsPrintf ("\n");
1381 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1382 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
1383 if (ACPI_FAILURE (Status))
1384 {
1385 return;
1386 }
1387
1388 /* Point to next subtable (each subtable is of fixed length) */
1389
1390 Offset += sizeof (ACPI_WHEA_HEADER);
1391 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
1392 sizeof (ACPI_WHEA_HEADER));
1393 }
1394 }
1395
1396
1397 /*******************************************************************************
1398 *
1399 * FUNCTION: AcpiDmDumpErst
1400 *
1401 * PARAMETERS: Table - A ERST table
1402 *
1403 * RETURN: None
1404 *
1405 * DESCRIPTION: Format the contents of a ERST. This table type consists
1406 * of an open-ended number of subtables.
1407 *
1408 ******************************************************************************/
1409
1410 void
AcpiDmDumpErst(ACPI_TABLE_HEADER * Table)1411 AcpiDmDumpErst (
1412 ACPI_TABLE_HEADER *Table)
1413 {
1414 ACPI_STATUS Status;
1415 ACPI_WHEA_HEADER *Subtable;
1416 UINT32 Length = Table->Length;
1417 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
1418
1419
1420 /* Main table */
1421
1422 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1423 if (ACPI_FAILURE (Status))
1424 {
1425 return;
1426 }
1427
1428 /* Subtables */
1429
1430 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1431 while (Offset < Table->Length)
1432 {
1433 AcpiOsPrintf ("\n");
1434 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1435 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1436 if (ACPI_FAILURE (Status))
1437 {
1438 return;
1439 }
1440
1441 /* Point to next subtable (each subtable is of fixed length) */
1442
1443 Offset += sizeof (ACPI_WHEA_HEADER);
1444 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
1445 sizeof (ACPI_WHEA_HEADER));
1446 }
1447 }
1448
1449
1450 /*******************************************************************************
1451 *
1452 * FUNCTION: AcpiDmDumpFpdt
1453 *
1454 * PARAMETERS: Table - A FPDT table
1455 *
1456 * RETURN: None
1457 *
1458 * DESCRIPTION: Format the contents of a FPDT. This table type consists
1459 * of an open-ended number of subtables.
1460 *
1461 ******************************************************************************/
1462
1463 void
AcpiDmDumpFpdt(ACPI_TABLE_HEADER * Table)1464 AcpiDmDumpFpdt (
1465 ACPI_TABLE_HEADER *Table)
1466 {
1467 ACPI_STATUS Status;
1468 ACPI_FPDT_HEADER *Subtable;
1469 UINT32 Length = Table->Length;
1470 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
1471 ACPI_DMTABLE_INFO *InfoTable;
1472
1473
1474 /* There is no main table (other than the standard ACPI header) */
1475
1476 /* Subtables */
1477
1478 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
1479 while (Offset < Table->Length)
1480 {
1481 /* Common subtable header */
1482
1483 AcpiOsPrintf ("\n");
1484 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1485 Subtable->Length, AcpiDmTableInfoFpdtHdr);
1486 if (ACPI_FAILURE (Status))
1487 {
1488 return;
1489 }
1490
1491 switch (Subtable->Type)
1492 {
1493 case ACPI_FPDT_TYPE_BOOT:
1494
1495 InfoTable = AcpiDmTableInfoFpdt0;
1496 break;
1497
1498 case ACPI_FPDT_TYPE_S3PERF:
1499
1500 InfoTable = AcpiDmTableInfoFpdt1;
1501 break;
1502
1503 default:
1504
1505 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
1506 Subtable->Type);
1507
1508 /* Attempt to continue */
1509
1510 if (!Subtable->Length)
1511 {
1512 AcpiOsPrintf ("Invalid zero length subtable\n");
1513 return;
1514 }
1515 goto NextSubtable;
1516 }
1517
1518 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1519 Subtable->Length, InfoTable);
1520 if (ACPI_FAILURE (Status))
1521 {
1522 return;
1523 }
1524
1525 NextSubtable:
1526 /* Point to next subtable */
1527
1528 Offset += Subtable->Length;
1529 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable,
1530 Subtable->Length);
1531 }
1532 }
1533
1534
1535 /*******************************************************************************
1536 *
1537 * FUNCTION: AcpiDmDumpGtdt
1538 *
1539 * PARAMETERS: Table - A GTDT table
1540 *
1541 * RETURN: None
1542 *
1543 * DESCRIPTION: Format the contents of a GTDT. This table type consists
1544 * of an open-ended number of subtables.
1545 *
1546 ******************************************************************************/
1547
1548 void
AcpiDmDumpGtdt(ACPI_TABLE_HEADER * Table)1549 AcpiDmDumpGtdt (
1550 ACPI_TABLE_HEADER *Table)
1551 {
1552 ACPI_STATUS Status;
1553 ACPI_GTDT_HEADER *Subtable;
1554 UINT32 Length = Table->Length;
1555 UINT32 Offset = sizeof (ACPI_TABLE_GTDT);
1556 ACPI_DMTABLE_INFO *InfoTable;
1557 UINT32 SubtableLength;
1558 UINT32 GtCount;
1559 ACPI_GTDT_TIMER_ENTRY *GtxTable;
1560
1561
1562 /* Main table */
1563
1564 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
1565 if (ACPI_FAILURE (Status))
1566 {
1567 return;
1568 }
1569
1570 /* Rev 3 fields */
1571
1572 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1573
1574 if (Table->Revision > 2)
1575 {
1576 SubtableLength = sizeof (ACPI_GTDT_EL2);
1577 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1578 SubtableLength, AcpiDmTableInfoGtdtEl2);
1579 if (ACPI_FAILURE (Status))
1580 {
1581 return;
1582 }
1583 Offset += SubtableLength;
1584 }
1585
1586 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1587
1588 /* Subtables */
1589
1590 while (Offset < Table->Length)
1591 {
1592 /* Common subtable header */
1593
1594 AcpiOsPrintf ("\n");
1595 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1596 Subtable->Length, AcpiDmTableInfoGtdtHdr);
1597 if (ACPI_FAILURE (Status))
1598 {
1599 return;
1600 }
1601
1602 GtCount = 0;
1603 switch (Subtable->Type)
1604 {
1605 case ACPI_GTDT_TYPE_TIMER_BLOCK:
1606
1607 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
1608 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1609 Subtable))->TimerCount;
1610
1611 InfoTable = AcpiDmTableInfoGtdt0;
1612 break;
1613
1614 case ACPI_GTDT_TYPE_WATCHDOG:
1615
1616 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG);
1617
1618 InfoTable = AcpiDmTableInfoGtdt1;
1619 break;
1620
1621 default:
1622
1623 /* Cannot continue on unknown type - no length */
1624
1625 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
1626 Subtable->Type);
1627 return;
1628 }
1629
1630 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1631 Subtable->Length, InfoTable);
1632 if (ACPI_FAILURE (Status))
1633 {
1634 return;
1635 }
1636
1637 /* Point to end of current subtable (each subtable above is of fixed length) */
1638
1639 Offset += SubtableLength;
1640
1641 /* If there are any Gt Timer Blocks from above, dump them now */
1642
1643 if (GtCount)
1644 {
1645 GtxTable = ACPI_ADD_PTR (
1646 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength);
1647 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
1648
1649 while (GtCount)
1650 {
1651 AcpiOsPrintf ("\n");
1652 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
1653 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
1654 if (ACPI_FAILURE (Status))
1655 {
1656 return;
1657 }
1658 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
1659 GtxTable++;
1660 GtCount--;
1661 }
1662 }
1663
1664 /* Point to next subtable */
1665
1666 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength);
1667 }
1668 }
1669
1670
1671 /*******************************************************************************
1672 *
1673 * FUNCTION: AcpiDmDumpHest
1674 *
1675 * PARAMETERS: Table - A HEST table
1676 *
1677 * RETURN: None
1678 *
1679 * DESCRIPTION: Format the contents of a HEST. This table type consists
1680 * of an open-ended number of subtables.
1681 *
1682 ******************************************************************************/
1683
1684 void
AcpiDmDumpHest(ACPI_TABLE_HEADER * Table)1685 AcpiDmDumpHest (
1686 ACPI_TABLE_HEADER *Table)
1687 {
1688 ACPI_STATUS Status;
1689 ACPI_HEST_HEADER *Subtable;
1690 UINT32 Length = Table->Length;
1691 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
1692 ACPI_DMTABLE_INFO *InfoTable;
1693 UINT32 SubtableLength;
1694 UINT32 BankCount;
1695 ACPI_HEST_IA_ERROR_BANK *BankTable;
1696
1697
1698 /* Main table */
1699
1700 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1701 if (ACPI_FAILURE (Status))
1702 {
1703 return;
1704 }
1705
1706 /* Subtables */
1707
1708 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1709 while (Offset < Table->Length)
1710 {
1711 BankCount = 0;
1712 switch (Subtable->Type)
1713 {
1714 case ACPI_HEST_TYPE_IA32_CHECK:
1715
1716 InfoTable = AcpiDmTableInfoHest0;
1717 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1718 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1719 Subtable))->NumHardwareBanks;
1720 break;
1721
1722 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1723
1724 InfoTable = AcpiDmTableInfoHest1;
1725 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1726 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1727 Subtable))->NumHardwareBanks;
1728 break;
1729
1730 case ACPI_HEST_TYPE_IA32_NMI:
1731
1732 InfoTable = AcpiDmTableInfoHest2;
1733 SubtableLength = sizeof (ACPI_HEST_IA_NMI);
1734 break;
1735
1736 case ACPI_HEST_TYPE_AER_ROOT_PORT:
1737
1738 InfoTable = AcpiDmTableInfoHest6;
1739 SubtableLength = sizeof (ACPI_HEST_AER_ROOT);
1740 break;
1741
1742 case ACPI_HEST_TYPE_AER_ENDPOINT:
1743
1744 InfoTable = AcpiDmTableInfoHest7;
1745 SubtableLength = sizeof (ACPI_HEST_AER);
1746 break;
1747
1748 case ACPI_HEST_TYPE_AER_BRIDGE:
1749
1750 InfoTable = AcpiDmTableInfoHest8;
1751 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1752 break;
1753
1754 case ACPI_HEST_TYPE_GENERIC_ERROR:
1755
1756 InfoTable = AcpiDmTableInfoHest9;
1757 SubtableLength = sizeof (ACPI_HEST_GENERIC);
1758 break;
1759
1760 case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
1761
1762 InfoTable = AcpiDmTableInfoHest10;
1763 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2);
1764 break;
1765
1766 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1767
1768 InfoTable = AcpiDmTableInfoHest11;
1769 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK);
1770 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
1771 Subtable))->NumHardwareBanks;
1772 break;
1773
1774 default:
1775
1776 /* Cannot continue on unknown type - no length */
1777
1778 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
1779 Subtable->Type);
1780 return;
1781 }
1782
1783 AcpiOsPrintf ("\n");
1784 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1785 SubtableLength, InfoTable);
1786 if (ACPI_FAILURE (Status))
1787 {
1788 return;
1789 }
1790
1791 /* Point to end of current subtable (each subtable above is of fixed length) */
1792
1793 Offset += SubtableLength;
1794
1795 /* If there are any (fixed-length) Error Banks from above, dump them now */
1796
1797 if (BankCount)
1798 {
1799 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable,
1800 SubtableLength);
1801 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1802
1803 while (BankCount)
1804 {
1805 AcpiOsPrintf ("\n");
1806 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1807 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1808 if (ACPI_FAILURE (Status))
1809 {
1810 return;
1811 }
1812
1813 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1814 BankTable++;
1815 BankCount--;
1816 }
1817 }
1818
1819 /* Point to next subtable */
1820
1821 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength);
1822 }
1823 }
1824
1825
1826 /*******************************************************************************
1827 *
1828 * FUNCTION: AcpiDmDumpHmat
1829 *
1830 * PARAMETERS: Table - A HMAT table
1831 *
1832 * RETURN: None
1833 *
1834 * DESCRIPTION: Format the contents of a HMAT.
1835 *
1836 ******************************************************************************/
1837
1838 void
AcpiDmDumpHmat(ACPI_TABLE_HEADER * Table)1839 AcpiDmDumpHmat (
1840 ACPI_TABLE_HEADER *Table)
1841 {
1842 ACPI_STATUS Status;
1843 ACPI_HMAT_STRUCTURE *HmatStruct;
1844 ACPI_HMAT_LOCALITY *HmatLocality;
1845 ACPI_HMAT_CACHE *HmatCache;
1846 UINT32 Offset;
1847 UINT32 SubtableOffset;
1848 UINT32 Length;
1849 ACPI_DMTABLE_INFO *InfoTable;
1850 UINT32 i, j;
1851
1852
1853 /* Main table */
1854
1855 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat);
1856 if (ACPI_FAILURE (Status))
1857 {
1858 return;
1859 }
1860 Offset = sizeof (ACPI_TABLE_HMAT);
1861
1862 while (Offset < Table->Length)
1863 {
1864 AcpiOsPrintf ("\n");
1865
1866 /* Dump HMAT structure header */
1867
1868 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset);
1869 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE))
1870 {
1871 AcpiOsPrintf ("Invalid HMAT structure length\n");
1872 return;
1873 }
1874 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1875 HmatStruct->Length, AcpiDmTableInfoHmatHdr);
1876 if (ACPI_FAILURE (Status))
1877 {
1878 return;
1879 }
1880
1881 switch (HmatStruct->Type)
1882 {
1883 case ACPI_HMAT_TYPE_ADDRESS_RANGE:
1884
1885 InfoTable = AcpiDmTableInfoHmat0;
1886 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN);
1887 break;
1888
1889 case ACPI_HMAT_TYPE_LOCALITY:
1890
1891 InfoTable = AcpiDmTableInfoHmat1;
1892 Length = sizeof (ACPI_HMAT_LOCALITY);
1893 break;
1894
1895 case ACPI_HMAT_TYPE_CACHE:
1896
1897 InfoTable = AcpiDmTableInfoHmat2;
1898 Length = sizeof (ACPI_HMAT_CACHE);
1899 break;
1900
1901 default:
1902
1903 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n",
1904 HmatStruct->Type);
1905
1906 /* Attempt to continue */
1907
1908 goto NextSubtable;
1909 }
1910
1911 /* Dump HMAT structure body */
1912
1913 if (HmatStruct->Length < Length)
1914 {
1915 AcpiOsPrintf ("Invalid HMAT structure length\n");
1916 return;
1917 }
1918 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1919 HmatStruct->Length, InfoTable);
1920 if (ACPI_FAILURE (Status))
1921 {
1922 return;
1923 }
1924
1925 /* Dump HMAT structure additionals */
1926
1927 switch (HmatStruct->Type)
1928 {
1929 case ACPI_HMAT_TYPE_LOCALITY:
1930
1931 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct);
1932 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY);
1933
1934 /* Dump initiator proximity domains */
1935
1936 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
1937 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4))
1938 {
1939 AcpiOsPrintf ("Invalid initiator proximity domain number\n");
1940 return;
1941 }
1942 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1943 {
1944 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1945 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
1946 4, AcpiDmTableInfoHmat1a);
1947 if (ACPI_FAILURE (Status))
1948 {
1949 return;
1950 }
1951
1952 SubtableOffset += 4;
1953 }
1954
1955 /* Dump target proximity domains */
1956
1957 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
1958 (UINT32)(HmatLocality->NumberOfTargetPDs * 4))
1959 {
1960 AcpiOsPrintf ("Invalid target proximity domain number\n");
1961 return;
1962 }
1963 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++)
1964 {
1965 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1966 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
1967 4, AcpiDmTableInfoHmat1b);
1968 if (ACPI_FAILURE (Status))
1969 {
1970 return;
1971 }
1972
1973 SubtableOffset += 4;
1974 }
1975
1976 /* Dump latency/bandwidth entris */
1977
1978 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
1979 (UINT32)(HmatLocality->NumberOfInitiatorPDs *
1980 HmatLocality->NumberOfTargetPDs * 2))
1981 {
1982 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n");
1983 return;
1984 }
1985 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1986 {
1987 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++)
1988 {
1989 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1990 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
1991 2, AcpiDmTableInfoHmat1c);
1992 if (ACPI_FAILURE(Status))
1993 {
1994 return;
1995 }
1996
1997 SubtableOffset += 2;
1998 }
1999 }
2000 break;
2001
2002 case ACPI_HMAT_TYPE_CACHE:
2003
2004 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct);
2005 SubtableOffset = sizeof (ACPI_HMAT_CACHE);
2006
2007 /* Dump SMBIOS handles */
2008
2009 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2010 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2))
2011 {
2012 AcpiOsPrintf ("Invalid SMBIOS handle number\n");
2013 return;
2014 }
2015 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++)
2016 {
2017 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2018 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2019 2, AcpiDmTableInfoHmat2a);
2020 if (ACPI_FAILURE (Status))
2021 {
2022 return;
2023 }
2024
2025 SubtableOffset += 2;
2026 }
2027 break;
2028
2029 default:
2030
2031 break;
2032 }
2033
2034 NextSubtable:
2035 /* Point to next HMAT structure subtable */
2036
2037 Offset += (HmatStruct->Length);
2038 }
2039 }
2040