1 /******************************************************************************
2 *
3 * Module Name: dmtbdump1 - 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 - 2025, 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 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include <contrib/dev/acpica/include/acpi.h>
153 #include <contrib/dev/acpica/include/accommon.h>
154 #include <contrib/dev/acpica/include/acdisasm.h>
155 #include <contrib/dev/acpica/include/actables.h>
156 #include <contrib/dev/acpica/compiler/aslcompiler.h>
157
158 /* This module used for application-level code only */
159
160 #define _COMPONENT ACPI_CA_DISASSEMBLER
161 ACPI_MODULE_NAME ("dmtbdump1")
162
163
164 /*******************************************************************************
165 *
166 * FUNCTION: AcpiDmDumpAest
167 *
168 * PARAMETERS: Table - A AEST table
169 *
170 * RETURN: None
171 *
172 * DESCRIPTION: Format the contents of a AEST table
173 *
174 * NOTE: Assumes the following table structure:
175 * For all AEST Error Nodes:
176 * 1) An AEST Error Node, followed immediately by:
177 * 2) Any node-specific data
178 * 3) An Interface Structure (one)
179 * 4) A list (array) of Interrupt Structures
180 *
181 * AEST - ARM Error Source table. Conforms to:
182 * ACPI for the Armv8 RAS Extensions 1.1 Platform Design Document Sep 2020
183 *
184 ******************************************************************************/
185
186 void
AcpiDmDumpAest(ACPI_TABLE_HEADER * Table)187 AcpiDmDumpAest (
188 ACPI_TABLE_HEADER *Table)
189 {
190 ACPI_STATUS Status;
191 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
192 ACPI_AEST_HEADER *Subtable;
193 ACPI_AEST_HEADER *NodeHeader;
194 ACPI_AEST_PROCESSOR *ProcessorSubtable;
195 ACPI_DMTABLE_INFO *InfoTable;
196 ACPI_SIZE Length;
197 UINT8 Type;
198 UINT8 Revision = Table->Revision;
199 UINT32 Count;
200 ACPI_AEST_NODE_INTERFACE_HEADER *InterfaceHeader;
201
202
203 /* Very small, generic main table. AEST consists of mostly subtables */
204
205 while (Offset < Table->Length)
206 {
207 NodeHeader = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
208
209 /* Dump the common error node (subtable) header */
210
211 Status = AcpiDmDumpTable (Table->Length, Offset, NodeHeader,
212 NodeHeader->Length, AcpiDmTableInfoAestHdr);
213 if (ACPI_FAILURE (Status))
214 {
215 return;
216 }
217
218 Type = NodeHeader->Type;
219
220 /* Setup the node-specific subtable based on the header Type field */
221
222 switch (Type)
223 {
224 case ACPI_AEST_PROCESSOR_ERROR_NODE:
225 InfoTable = AcpiDmTableInfoAestProcError;
226 Length = sizeof (ACPI_AEST_PROCESSOR);
227 break;
228
229 case ACPI_AEST_MEMORY_ERROR_NODE:
230 InfoTable = AcpiDmTableInfoAestMemError;
231 Length = sizeof (ACPI_AEST_MEMORY);
232 break;
233
234 case ACPI_AEST_SMMU_ERROR_NODE:
235 InfoTable = AcpiDmTableInfoAestSmmuError;
236 Length = sizeof (ACPI_AEST_SMMU);
237 break;
238
239 case ACPI_AEST_VENDOR_ERROR_NODE:
240 switch (Revision)
241 {
242 case 1:
243 InfoTable = AcpiDmTableInfoAestVendorError;
244 Length = sizeof (ACPI_AEST_VENDOR);
245 break;
246
247 case 2:
248 InfoTable = AcpiDmTableInfoAestVendorV2Error;
249 Length = sizeof (ACPI_AEST_VENDOR_V2);
250 break;
251
252 default:
253 AcpiOsPrintf ("\n**** Unknown AEST revision 0x%X\n", Revision);
254 return;
255 }
256 break;
257
258 case ACPI_AEST_GIC_ERROR_NODE:
259 InfoTable = AcpiDmTableInfoAestGicError;
260 Length = sizeof (ACPI_AEST_GIC);
261 break;
262
263 case ACPI_AEST_PCIE_ERROR_NODE:
264 InfoTable = AcpiDmTableInfoAestPCIeError;
265 Length = sizeof (ACPI_AEST_PCIE);
266 break;
267
268 case ACPI_AEST_PROXY_ERROR_NODE:
269 InfoTable = AcpiDmTableInfoAestProxyError;
270 Length = sizeof (ACPI_AEST_PROXY);
271 break;
272
273 /* Error case below */
274 default:
275
276 AcpiOsPrintf ("\n**** Unknown AEST Error Subtable type 0x%X\n",
277 Type);
278 return;
279 }
280
281 /* Point past the common header (to the node-specific data) */
282
283 Offset += sizeof (ACPI_AEST_HEADER);
284 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
285 AcpiOsPrintf ("\n");
286
287 /* Dump the node-specific subtable */
288
289 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length,
290 InfoTable);
291 if (ACPI_FAILURE (Status))
292 {
293 return;
294 }
295 AcpiOsPrintf ("\n");
296
297 if (Type == ACPI_AEST_PROCESSOR_ERROR_NODE)
298 {
299 /*
300 * Special handling for PROCESSOR_ERROR_NODE subtables
301 * (to handle the Resource Substructure via the ResourceType
302 * field).
303 */
304
305 /* Point past the node-specific data */
306
307 Offset += Length;
308 ProcessorSubtable = ACPI_CAST_PTR (ACPI_AEST_PROCESSOR, Subtable);
309
310 switch (ProcessorSubtable->ResourceType)
311 {
312 /* Setup the Resource Substructure subtable */
313
314 case ACPI_AEST_CACHE_RESOURCE:
315 InfoTable = AcpiDmTableInfoAestCacheRsrc;
316 Length = sizeof (ACPI_AEST_PROCESSOR_CACHE);
317 break;
318
319 case ACPI_AEST_TLB_RESOURCE:
320 InfoTable = AcpiDmTableInfoAestTlbRsrc;
321 Length = sizeof (ACPI_AEST_PROCESSOR_TLB);
322 break;
323
324 case ACPI_AEST_GENERIC_RESOURCE:
325 InfoTable = AcpiDmTableInfoAestGenRsrc;
326 Length = sizeof (ACPI_AEST_PROCESSOR_GENERIC);
327 break;
328
329 /* Error case below */
330 default:
331 AcpiOsPrintf ("\n**** Unknown AEST Processor Resource type 0x%X\n",
332 ProcessorSubtable->ResourceType);
333 return;
334 }
335
336 ProcessorSubtable = ACPI_ADD_PTR (ACPI_AEST_PROCESSOR, Table,
337 Offset);
338
339 /* Dump the resource substructure subtable */
340
341 Status = AcpiDmDumpTable (Table->Length, Offset, ProcessorSubtable,
342 Length, InfoTable);
343 if (ACPI_FAILURE (Status))
344 {
345 return;
346 }
347
348 AcpiOsPrintf ("\n");
349 }
350
351 /* Point past the resource substructure or the node-specific data */
352
353 Offset += Length;
354
355 /* Dump the interface structure, required to be present */
356
357 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
358 if (Subtable->Type >= ACPI_AEST_XFACE_RESERVED)
359 {
360 AcpiOsPrintf ("\n**** Unknown AEST Node Interface type 0x%X\n",
361 Subtable->Type);
362 return;
363 }
364
365 if (Revision == 1)
366 {
367 InfoTable = AcpiDmTableInfoAestXface;
368 Length = sizeof (ACPI_AEST_NODE_INTERFACE);
369 }
370 else if (Revision == 2)
371 {
372 InfoTable = AcpiDmTableInfoAestXfaceHeader;
373 Length = sizeof (ACPI_AEST_NODE_INTERFACE_HEADER);
374
375 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length, InfoTable);
376 if (ACPI_FAILURE (Status))
377 {
378 return;
379 }
380
381 Offset += Length;
382
383 InterfaceHeader = ACPI_CAST_PTR (ACPI_AEST_NODE_INTERFACE_HEADER, Subtable);
384 switch (InterfaceHeader->GroupFormat)
385 {
386 case ACPI_AEST_NODE_GROUP_FORMAT_4K:
387 InfoTable = AcpiDmTableInfoAestXface4k;
388 Length = sizeof (ACPI_AEST_NODE_INTERFACE_4K);
389 break;
390
391 case ACPI_AEST_NODE_GROUP_FORMAT_16K:
392 InfoTable = AcpiDmTableInfoAestXface16k;
393 Length = sizeof (ACPI_AEST_NODE_INTERFACE_16K);
394 break;
395
396 case ACPI_AEST_NODE_GROUP_FORMAT_64K:
397 InfoTable = AcpiDmTableInfoAestXface64k;
398 Length = sizeof (ACPI_AEST_NODE_INTERFACE_64K);
399 break;
400
401 default:
402 AcpiOsPrintf ("\n**** Unknown AEST Interface Group Format 0x%X\n",
403 InterfaceHeader->GroupFormat);
404 return;
405 }
406
407 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
408 }
409 else
410 {
411 AcpiOsPrintf ("\n**** Unknown AEST revision 0x%X\n", Revision);
412 return;
413 }
414
415 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length, InfoTable);
416 if (ACPI_FAILURE (Status))
417 {
418 return;
419 }
420
421 /* Point past the interface structure */
422
423 AcpiOsPrintf ("\n");
424 Offset += Length;
425
426 /* Dump the entire interrupt structure array, if present */
427
428 if (NodeHeader->NodeInterruptOffset)
429 {
430 Count = NodeHeader->NodeInterruptCount;
431 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
432
433 while (Count)
434 {
435 /* Dump the interrupt structure */
436
437 switch (Revision) {
438 case 1:
439 InfoTable = AcpiDmTableInfoAestXrupt;
440 Length = sizeof (ACPI_AEST_NODE_INTERRUPT);
441 break;
442
443 case 2:
444 InfoTable = AcpiDmTableInfoAestXruptV2;
445 Length = sizeof (ACPI_AEST_NODE_INTERRUPT_V2);
446 break;
447 default:
448 AcpiOsPrintf ("\n**** Unknown AEST revision 0x%X\n",
449 Revision);
450 return;
451 }
452 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
453 Length, InfoTable);
454 if (ACPI_FAILURE (Status))
455 {
456 return;
457 }
458
459 /* Point to the next interrupt structure */
460
461 Offset += Length;
462 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
463 Count--;
464 AcpiOsPrintf ("\n");
465 }
466 }
467 }
468 }
469
470 /*******************************************************************************
471 *
472 * FUNCTION: AcpiDmDumpApmt
473 *
474 * PARAMETERS: Table - A APMT table
475 *
476 * RETURN: None
477 *
478 * DESCRIPTION: Format the contents of a APMT. This table type consists
479 * of an open-ended number of subtables.
480 *
481 *
482 * APMT - ARM Performance Monitoring Unit table. Conforms to:
483 * ARM Performance Monitoring Unit Architecture 1.0 Platform Design Document
484 * ARM DEN0117 v1.0 November 25, 2021
485 *
486 ******************************************************************************/
487
488 void
AcpiDmDumpApmt(ACPI_TABLE_HEADER * Table)489 AcpiDmDumpApmt (
490 ACPI_TABLE_HEADER *Table)
491 {
492 ACPI_STATUS Status;
493 ACPI_APMT_NODE *Subtable;
494 UINT32 Length = Table->Length;
495 UINT32 Offset = sizeof (ACPI_TABLE_APMT);
496 UINT32 NodeNum = 0;
497
498 /* There is no main table (other than the standard ACPI header) */
499
500 /* Subtables */
501
502 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Table, Offset);
503 while (Offset < Table->Length)
504 {
505 AcpiOsPrintf ("\n");
506
507 if (Subtable->Type >= ACPI_APMT_NODE_TYPE_COUNT)
508 {
509 AcpiOsPrintf ("\n**** Unknown APMT subtable type 0x%X\n",
510 Subtable->Type);
511 return;
512 }
513
514 AcpiOsPrintf ("/* APMT Node-%u */\n", NodeNum++);
515
516 Status = AcpiDmDumpTable (Length, Offset, Subtable,
517 Subtable->Length, AcpiDmTableInfoApmtNode);
518 if (ACPI_FAILURE (Status))
519 {
520 return;
521 }
522
523 /* Point to next subtable */
524
525 Offset += Subtable->Length;
526 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Subtable,
527 Subtable->Length);
528 AcpiOsPrintf ("\n");
529 }
530 }
531
532
533 /*******************************************************************************
534 *
535 * FUNCTION: AcpiDmDumpAsf
536 *
537 * PARAMETERS: Table - A ASF table
538 *
539 * RETURN: None
540 *
541 * DESCRIPTION: Format the contents of a ASF table
542 *
543 ******************************************************************************/
544
545 void
AcpiDmDumpAsf(ACPI_TABLE_HEADER * Table)546 AcpiDmDumpAsf (
547 ACPI_TABLE_HEADER *Table)
548 {
549 ACPI_STATUS Status;
550 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
551 ACPI_ASF_INFO *Subtable;
552 ACPI_DMTABLE_INFO *InfoTable;
553 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
554 UINT8 *DataTable = NULL;
555 UINT32 DataCount = 0;
556 UINT32 DataLength = 0;
557 UINT32 DataOffset = 0;
558 UINT32 i;
559 UINT8 Type;
560
561
562 /* No main table, only subtables */
563
564 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
565 while (Offset < Table->Length)
566 {
567 /* Common subtable header */
568
569 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
570 Subtable->Header.Length, AcpiDmTableInfoAsfHdr);
571 if (ACPI_FAILURE (Status))
572 {
573 return;
574 }
575
576 /* The actual type is the lower 7 bits of Type */
577
578 Type = (UINT8) (Subtable->Header.Type & 0x7F);
579
580 switch (Type)
581 {
582 case ACPI_ASF_TYPE_INFO:
583
584 InfoTable = AcpiDmTableInfoAsf0;
585 break;
586
587 case ACPI_ASF_TYPE_ALERT:
588
589 InfoTable = AcpiDmTableInfoAsf1;
590 DataInfoTable = AcpiDmTableInfoAsf1a;
591 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT));
592 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts;
593 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength;
594 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
595 break;
596
597 case ACPI_ASF_TYPE_CONTROL:
598
599 InfoTable = AcpiDmTableInfoAsf2;
600 DataInfoTable = AcpiDmTableInfoAsf2a;
601 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE));
602 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls;
603 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength;
604 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
605 break;
606
607 case ACPI_ASF_TYPE_BOOT:
608
609 InfoTable = AcpiDmTableInfoAsf3;
610 break;
611
612 case ACPI_ASF_TYPE_ADDRESS:
613
614 InfoTable = AcpiDmTableInfoAsf4;
615 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS));
616 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices;
617 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
618 break;
619
620 default:
621
622 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
623 Subtable->Header.Type);
624 return;
625 }
626
627 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
628 Subtable->Header.Length, InfoTable);
629 if (ACPI_FAILURE (Status))
630 {
631 return;
632 }
633
634 /* Dump variable-length extra data */
635
636 switch (Type)
637 {
638 case ACPI_ASF_TYPE_ALERT:
639 case ACPI_ASF_TYPE_CONTROL:
640
641 for (i = 0; i < DataCount; i++)
642 {
643 AcpiOsPrintf ("\n");
644 Status = AcpiDmDumpTable (Table->Length, DataOffset,
645 DataTable, DataLength, DataInfoTable);
646 if (ACPI_FAILURE (Status))
647 {
648 return;
649 }
650
651 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
652 DataOffset += DataLength;
653 }
654 break;
655
656 case ACPI_ASF_TYPE_ADDRESS:
657
658 for (i = 0; i < DataLength; i++)
659 {
660 if (!(i % 16))
661 {
662 AcpiDmLineHeader (DataOffset, 1, "Addresses");
663 }
664
665 AcpiOsPrintf ("%2.2X ", *DataTable);
666 DataTable++;
667 DataOffset++;
668
669 if (DataOffset > Table->Length)
670 {
671 AcpiOsPrintf (
672 "**** ACPI table terminates in the middle of a "
673 "data structure! (ASF! table)\n");
674 return;
675 }
676 }
677
678 AcpiOsPrintf ("\n");
679 break;
680
681 default:
682
683 break;
684 }
685
686 AcpiOsPrintf ("\n");
687
688 /* Point to next subtable */
689
690 if (!Subtable->Header.Length)
691 {
692 AcpiOsPrintf ("Invalid zero subtable header length\n");
693 return;
694 }
695
696 Offset += Subtable->Header.Length;
697 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable,
698 Subtable->Header.Length);
699 }
700 }
701
702 /*******************************************************************************
703 *
704 * FUNCTION: AcpiDmDumpAspt
705 *
706 * PARAMETERS: Table - A ASPT table
707 *
708 * RETURN: None
709 *
710 * DESCRIPTION: Format the contents of a ASPT table
711 *
712 ******************************************************************************/
713
714 void
AcpiDmDumpAspt(ACPI_TABLE_HEADER * Table)715 AcpiDmDumpAspt (
716 ACPI_TABLE_HEADER *Table)
717 {
718 ACPI_STATUS Status;
719 UINT32 Offset = sizeof (ACPI_TABLE_ASPT);
720 UINT32 Length = Table->Length;
721 ACPI_ASPT_HEADER *Subtable;
722 ACPI_DMTABLE_INFO *InfoTable;
723 UINT16 Type;
724
725 /* Main table */
726 Status = AcpiDmDumpTable(Length, 0, Table, 0, AcpiDmTableInfoAspt);
727
728 /* Subtables */
729
730 Subtable = ACPI_ADD_PTR (ACPI_ASPT_HEADER, Table, Offset);
731 while (Offset < Table->Length)
732 {
733 AcpiOsPrintf ("\n");
734
735 /* Common subtable header */
736 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
737 Subtable->Length, AcpiDmTableInfoAsptHdr);
738 if (ACPI_FAILURE (Status))
739 {
740 return;
741 }
742
743 Type = Subtable->Type;
744
745 switch (Type)
746 {
747 case ACPI_ASPT_TYPE_GLOBAL_REGS:
748
749 InfoTable = AcpiDmTableInfoAspt0;
750 break;
751
752 case ACPI_ASPT_TYPE_SEV_MBOX_REGS:
753
754 InfoTable = AcpiDmTableInfoAspt1;
755 break;
756
757 case ACPI_ASPT_TYPE_ACPI_MBOX_REGS:
758
759 InfoTable = AcpiDmTableInfoAspt2;
760 break;
761
762 default:
763
764 AcpiOsPrintf ("\n**** Unknown ASPT subtable type 0x%X\n",
765 Subtable->Type);
766 return;
767 }
768
769 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
770 Subtable->Length, InfoTable);
771 if (ACPI_FAILURE (Status))
772 {
773 return;
774 }
775
776 AcpiOsPrintf ("\n");
777
778 /* Point to next subtable */
779 if (!Subtable->Length)
780 {
781 AcpiOsPrintf ("Invalid zero subtable header length\n");
782 return;
783 }
784
785 Offset += Subtable->Length;
786 Subtable = ACPI_ADD_PTR (ACPI_ASPT_HEADER, Subtable,
787 Subtable->Length);
788 }
789 }
790
791
792 /*******************************************************************************
793 *
794 * FUNCTION: AcpiDmDumpCdat
795 *
796 * PARAMETERS: InTable - A CDAT table
797 *
798 * RETURN: None
799 *
800 * DESCRIPTION: Format the contents of a CDAT. This table type consists
801 * of an open-ended number of subtables.
802 *
803 ******************************************************************************/
804
805 void
AcpiDmDumpCdat(ACPI_TABLE_HEADER * InTable)806 AcpiDmDumpCdat (
807 ACPI_TABLE_HEADER *InTable)
808 {
809 ACPI_TABLE_CDAT *Table = ACPI_CAST_PTR (ACPI_TABLE_CDAT, InTable);
810 ACPI_STATUS Status;
811 ACPI_CDAT_HEADER *Subtable;
812 ACPI_TABLE_CDAT *CdatTable = ACPI_CAST_PTR (ACPI_TABLE_CDAT, Table);
813 ACPI_DMTABLE_INFO *InfoTable;
814 UINT32 Length = CdatTable->Length;
815 UINT32 Offset = sizeof (ACPI_TABLE_CDAT);
816 UINT32 SubtableLength;
817 UINT32 SubtableType;
818 INT32 EntriesLength;
819
820
821 /* Main table */
822
823 Status = AcpiDmDumpTable (Offset, 0, CdatTable, 0,
824 AcpiDmTableInfoCdatTableHdr);
825 if (ACPI_FAILURE (Status))
826 {
827 return;
828 }
829
830 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, sizeof (ACPI_TABLE_CDAT));
831 while (Offset < Table->Length)
832 {
833 /* Dump the common subtable header */
834
835 DbgPrint (ASL_DEBUG_OUTPUT, "0) HeaderOffset: %X\n", Offset);
836 AcpiOsPrintf ("\n");
837 Status = AcpiDmDumpTable (Length, Offset, Subtable,
838 sizeof (ACPI_CDAT_HEADER), AcpiDmTableInfoCdatHeader);
839 if (ACPI_FAILURE (Status))
840 {
841 return;
842 }
843
844 /* Point past the common subtable header, decode the subtable type */
845
846 Offset += sizeof (ACPI_CDAT_HEADER);
847 SubtableType = Subtable->Type;
848
849 switch (Subtable->Type)
850 {
851 case ACPI_CDAT_TYPE_DSMAS:
852 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
853 SubtableLength = sizeof (ACPI_CDAT_DSMAS);
854
855 InfoTable = AcpiDmTableInfoCdat0;
856 break;
857
858 case ACPI_CDAT_TYPE_DSLBIS:
859 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
860 SubtableLength = sizeof (ACPI_CDAT_DSLBIS);
861 DbgPrint (ASL_DEBUG_OUTPUT, "1) Offset: %X\n", Offset);
862
863 InfoTable = AcpiDmTableInfoCdat1;
864 break;
865
866 case ACPI_CDAT_TYPE_DSMSCIS:
867 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
868 SubtableLength = sizeof (ACPI_CDAT_DSMSCIS);
869
870 InfoTable = AcpiDmTableInfoCdat2;
871 break;
872
873 case ACPI_CDAT_TYPE_DSIS:
874 DbgPrint (ASL_DEBUG_OUTPUT, "2) Offset: %X ", Offset);
875 SubtableLength = sizeof (ACPI_CDAT_DSIS);
876 DbgPrint (ASL_DEBUG_OUTPUT, "1) input pointer: %p\n", Table);
877 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
878 DbgPrint (ASL_DEBUG_OUTPUT, "1) output pointers: %p, %p, Offset: %X\n",
879 Table, Subtable, Offset);
880 DbgPrint (ASL_DEBUG_OUTPUT, "3) Offset: %X\n", Offset);
881
882 InfoTable = AcpiDmTableInfoCdat3;
883 break;
884
885 case ACPI_CDAT_TYPE_DSEMTS:
886 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
887 SubtableLength = sizeof (ACPI_CDAT_DSEMTS);
888
889 InfoTable = AcpiDmTableInfoCdat4;
890 break;
891
892 case ACPI_CDAT_TYPE_SSLBIS:
893 SubtableLength = Subtable->Length;
894
895 InfoTable = AcpiDmTableInfoCdat5;
896 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
897 break;
898
899 default:
900 fprintf (stderr, "ERROR: Unknown SubtableType: %X\n", Subtable->Type);
901 return;
902 }
903
904 DbgPrint (ASL_DEBUG_OUTPUT, "SubtableType: %X, Length: %X Actual "
905 "Length: %X Offset: %X tableptr: %p\n", SubtableType,
906 Subtable->Length, SubtableLength, Offset, Table);
907
908 /*
909 * Do the subtable-specific fields
910 */
911 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset, InfoTable);
912 if (ACPI_FAILURE (Status))
913 {
914 return;
915 }
916
917 DbgPrint (ASL_DEBUG_OUTPUT, "Subtable Type: %X, Offset: %X, SubtableLength: %X\n",
918 SubtableType, Offset, SubtableLength);
919
920 /* Additional sub-subtables, dependent on the main subtable type */
921
922 switch (SubtableType)
923 {
924 case ACPI_CDAT_TYPE_SSLBIS:
925 Offset += sizeof (ACPI_CDAT_SSLBIS);
926 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table,
927 Offset);
928
929 DbgPrint (ASL_DEBUG_OUTPUT, "Case SSLBIS, Offset: %X, SubtableLength: %X "
930 "Subtable->Length %X\n", Offset, SubtableLength, Subtable->Length);
931
932 /* Generate the total length of all the SSLBE entries */
933
934 EntriesLength = SubtableLength - sizeof (ACPI_CDAT_HEADER) -
935 sizeof (ACPI_CDAT_SSLBIS);
936 DbgPrint (ASL_DEBUG_OUTPUT, "EntriesLength: %X, Offset: %X, Table->Length: %X\n",
937 EntriesLength, Offset, Table->Length);
938
939 /* Do each of the SSLBE Entries */
940
941 while ((EntriesLength > 0) && (Offset < Table->Length))
942 {
943 AcpiOsPrintf ("\n");
944
945 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset,
946 AcpiDmTableInfoCdatEntries);
947 if (ACPI_FAILURE (Status))
948 {
949 return;
950 }
951
952 EntriesLength -= sizeof (ACPI_CDAT_SSLBE);
953 Offset += sizeof (ACPI_CDAT_SSLBE);
954 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
955 }
956
957 SubtableLength = 0;
958 break;
959
960 default:
961 break;
962 }
963
964 DbgPrint (ASL_DEBUG_OUTPUT, "Offset: %X, Subtable Length: %X\n",
965 Offset, SubtableLength);
966
967 /* Point to next subtable */
968
969 Offset += SubtableLength;
970 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
971 }
972
973 return;
974 }
975
976
977 /*******************************************************************************
978 *
979 * FUNCTION: AcpiDmDumpCedt
980 *
981 * PARAMETERS: Table - A CEDT table
982 *
983 * RETURN: None
984 *
985 * DESCRIPTION: Format the contents of a CEDT. This table type consists
986 * of an open-ended number of subtables.
987 *
988 ******************************************************************************/
989
990 void
AcpiDmDumpCedt(ACPI_TABLE_HEADER * Table)991 AcpiDmDumpCedt (
992 ACPI_TABLE_HEADER *Table)
993 {
994 ACPI_STATUS Status;
995 ACPI_CEDT_HEADER *Subtable;
996 UINT32 Length = Table->Length;
997 UINT32 Offset = sizeof (ACPI_TABLE_CEDT);
998
999
1000 /* There is no main table (other than the standard ACPI header) */
1001
1002 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset);
1003 while (Offset < Table->Length)
1004 {
1005 /* Common subtable header */
1006
1007 AcpiOsPrintf ("\n");
1008 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1009 Subtable->Length, AcpiDmTableInfoCedtHdr);
1010 if (ACPI_FAILURE (Status))
1011 {
1012 return;
1013 }
1014
1015 switch (Subtable->Type)
1016 {
1017 case ACPI_CEDT_TYPE_CHBS:
1018 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1019 Subtable->Length, AcpiDmTableInfoCedt0);
1020 if (ACPI_FAILURE (Status))
1021 {
1022 return;
1023 }
1024 break;
1025
1026 case ACPI_CEDT_TYPE_CFMWS:
1027 {
1028 ACPI_CEDT_CFMWS *ptr = (ACPI_CEDT_CFMWS *) Subtable;
1029 unsigned int i, max;
1030
1031 if (ptr->InterleaveWays < 8)
1032 max = 1 << (ptr->InterleaveWays);
1033 else
1034 max = 3 << (ptr->InterleaveWays - 8);
1035
1036 /* print out table with first "Interleave target" */
1037
1038 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1039 Subtable->Length, AcpiDmTableInfoCedt1);
1040 if (ACPI_FAILURE (Status))
1041 {
1042 return;
1043 }
1044
1045 /* Now, print out any interleave targets beyond the first. */
1046
1047 for (i = 1; i < max; i++)
1048 {
1049 unsigned int loc_offset = Offset + (i * 4) + ACPI_OFFSET (ACPI_CEDT_CFMWS, InterleaveTargets);
1050 unsigned int *trg = &(ptr->InterleaveTargets[i]);
1051
1052 Status = AcpiDmDumpTable (Length, loc_offset, trg,
1053 Subtable->Length, AcpiDmTableInfoCedt1_te);
1054 if (ACPI_FAILURE (Status))
1055 {
1056 return;
1057 }
1058 }
1059 break;
1060 }
1061
1062 case ACPI_CEDT_TYPE_CXIMS:
1063 {
1064 ACPI_CEDT_CXIMS *ptr = (ACPI_CEDT_CXIMS *) Subtable;
1065 unsigned int i, max = ptr->NrXormaps;
1066
1067 /* print out table with first "XOR Map" */
1068
1069 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1070 Subtable->Length, AcpiDmTableInfoCedt2);
1071 if (ACPI_FAILURE (Status))
1072 {
1073 return;
1074 }
1075
1076 /* Now, print out any XOR Map beyond the first. */
1077
1078 for (i = 1; i < max; i++)
1079 {
1080 unsigned int loc_offset = Offset + (i * 1) + ACPI_OFFSET (ACPI_CEDT_CXIMS, XormapList);
1081 UINT64 *trg = &(ptr->XormapList[i]);
1082
1083 Status = AcpiDmDumpTable (Length, loc_offset, trg,
1084 Subtable->Length, AcpiDmTableInfoCedt2_te);
1085 if (ACPI_FAILURE (Status))
1086 {
1087 return;
1088 }
1089 }
1090 break;
1091 }
1092
1093 default:
1094 AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n",
1095 Subtable->Type);
1096
1097 /* Attempt to continue */
1098 if (!Subtable->Length)
1099 {
1100 AcpiOsPrintf ("Invalid zero length subtable\n");
1101 return;
1102 }
1103 }
1104
1105 /* Point to next subtable */
1106 Offset += Subtable->Length;
1107 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable,
1108 Subtable->Length);
1109 }
1110 }
1111
1112 /*******************************************************************************
1113 *
1114 * FUNCTION: AcpiDmDumpCpep
1115 *
1116 * PARAMETERS: Table - A CPEP table
1117 *
1118 * RETURN: None
1119 *
1120 * DESCRIPTION: Format the contents of a CPEP. This table type consists
1121 * of an open-ended number of subtables.
1122 *
1123 ******************************************************************************/
1124
1125 void
AcpiDmDumpCpep(ACPI_TABLE_HEADER * Table)1126 AcpiDmDumpCpep (
1127 ACPI_TABLE_HEADER *Table)
1128 {
1129 ACPI_STATUS Status;
1130 ACPI_CPEP_POLLING *Subtable;
1131 UINT32 Length = Table->Length;
1132 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
1133
1134
1135 /* Main table */
1136
1137 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
1138 if (ACPI_FAILURE (Status))
1139 {
1140 return;
1141 }
1142
1143 /* Subtables */
1144
1145 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
1146 while (Offset < Table->Length)
1147 {
1148 AcpiOsPrintf ("\n");
1149 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1150 Subtable->Header.Length, AcpiDmTableInfoCpep0);
1151 if (ACPI_FAILURE (Status))
1152 {
1153 return;
1154 }
1155
1156 /* Point to next subtable */
1157
1158 Offset += Subtable->Header.Length;
1159 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable,
1160 Subtable->Header.Length);
1161 }
1162 }
1163
1164
1165 /*******************************************************************************
1166 *
1167 * FUNCTION: AcpiDmDumpCsrt
1168 *
1169 * PARAMETERS: Table - A CSRT table
1170 *
1171 * RETURN: None
1172 *
1173 * DESCRIPTION: Format the contents of a CSRT. This table type consists
1174 * of an open-ended number of subtables.
1175 *
1176 ******************************************************************************/
1177
1178 void
AcpiDmDumpCsrt(ACPI_TABLE_HEADER * Table)1179 AcpiDmDumpCsrt (
1180 ACPI_TABLE_HEADER *Table)
1181 {
1182 ACPI_STATUS Status;
1183 ACPI_CSRT_GROUP *Subtable;
1184 ACPI_CSRT_SHARED_INFO *SharedInfoTable;
1185 ACPI_CSRT_DESCRIPTOR *SubSubtable;
1186 UINT32 Length = Table->Length;
1187 UINT32 Offset = sizeof (ACPI_TABLE_CSRT);
1188 UINT32 SubOffset;
1189 UINT32 SubSubOffset;
1190 UINT32 InfoLength;
1191
1192
1193 /* The main table only contains the ACPI header, thus already handled */
1194
1195 /* Subtables (Resource Groups) */
1196
1197 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
1198 while (Offset < Table->Length)
1199 {
1200 /* Resource group subtable */
1201
1202 AcpiOsPrintf ("\n");
1203 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1204 Subtable->Length, AcpiDmTableInfoCsrt0);
1205 if (ACPI_FAILURE (Status))
1206 {
1207 return;
1208 }
1209
1210 /* Shared info subtable (One per resource group) */
1211
1212 SubOffset = sizeof (ACPI_CSRT_GROUP);
1213 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
1214 Offset + SubOffset);
1215
1216 AcpiOsPrintf ("\n");
1217 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
1218 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
1219 if (ACPI_FAILURE (Status))
1220 {
1221 return;
1222 }
1223
1224 SubOffset += Subtable->SharedInfoLength;
1225
1226 /* Sub-Subtables (Resource Descriptors) */
1227
1228 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
1229 Offset + SubOffset);
1230
1231 while ((SubOffset < Subtable->Length) &&
1232 ((Offset + SubOffset) < Table->Length))
1233 {
1234 AcpiOsPrintf ("\n");
1235 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable,
1236 SubSubtable->Length, AcpiDmTableInfoCsrt2);
1237 if (ACPI_FAILURE (Status))
1238 {
1239 return;
1240 }
1241
1242 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
1243
1244 /* Resource-specific info buffer */
1245
1246 InfoLength = SubSubtable->Length - SubSubOffset;
1247 if (InfoLength)
1248 {
1249 Status = AcpiDmDumpTable (Length,
1250 Offset + SubOffset + SubSubOffset, Table,
1251 InfoLength, AcpiDmTableInfoCsrt2a);
1252 if (ACPI_FAILURE (Status))
1253 {
1254 return;
1255 }
1256 }
1257
1258 /* Point to next sub-subtable */
1259
1260 SubOffset += SubSubtable->Length;
1261 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable,
1262 SubSubtable->Length);
1263 }
1264
1265 /* Point to next subtable */
1266
1267 Offset += Subtable->Length;
1268 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable,
1269 Subtable->Length);
1270 }
1271 }
1272
1273
1274 /*******************************************************************************
1275 *
1276 * FUNCTION: AcpiDmDumpDbg2
1277 *
1278 * PARAMETERS: Table - A DBG2 table
1279 *
1280 * RETURN: None
1281 *
1282 * DESCRIPTION: Format the contents of a DBG2. This table type consists
1283 * of an open-ended number of subtables.
1284 *
1285 ******************************************************************************/
1286
1287 void
AcpiDmDumpDbg2(ACPI_TABLE_HEADER * Table)1288 AcpiDmDumpDbg2 (
1289 ACPI_TABLE_HEADER *Table)
1290 {
1291 ACPI_STATUS Status;
1292 ACPI_DBG2_DEVICE *Subtable;
1293 UINT32 Length = Table->Length;
1294 UINT32 Offset = sizeof (ACPI_TABLE_DBG2);
1295 UINT32 i;
1296 UINT32 ArrayOffset;
1297 UINT32 AbsoluteOffset;
1298 UINT8 *Array;
1299
1300
1301 /* Main table */
1302
1303 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
1304 if (ACPI_FAILURE (Status))
1305 {
1306 return;
1307 }
1308
1309 /* Subtables */
1310
1311 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
1312 while (Offset < Table->Length)
1313 {
1314 AcpiOsPrintf ("\n");
1315 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1316 Subtable->Length, AcpiDmTableInfoDbg2Device);
1317 if (ACPI_FAILURE (Status))
1318 {
1319 return;
1320 }
1321
1322 /* Dump the BaseAddress array */
1323
1324 for (i = 0; i < Subtable->RegisterCount; i++)
1325 {
1326 ArrayOffset = Subtable->BaseAddressOffset +
1327 (sizeof (ACPI_GENERIC_ADDRESS) * i);
1328 AbsoluteOffset = Offset + ArrayOffset;
1329 Array = (UINT8 *) Subtable + ArrayOffset;
1330
1331 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1332 Subtable->Length, AcpiDmTableInfoDbg2Addr);
1333 if (ACPI_FAILURE (Status))
1334 {
1335 return;
1336 }
1337 }
1338
1339 /* Dump the AddressSize array */
1340
1341 for (i = 0; i < Subtable->RegisterCount; i++)
1342 {
1343 ArrayOffset = Subtable->AddressSizeOffset +
1344 (sizeof (UINT32) * i);
1345 AbsoluteOffset = Offset + ArrayOffset;
1346 Array = (UINT8 *) Subtable + ArrayOffset;
1347
1348 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1349 Subtable->Length, AcpiDmTableInfoDbg2Size);
1350 if (ACPI_FAILURE (Status))
1351 {
1352 return;
1353 }
1354 }
1355
1356 /* Dump the Namestring (required) */
1357
1358 AcpiOsPrintf ("\n");
1359 ArrayOffset = Subtable->NamepathOffset;
1360 AbsoluteOffset = Offset + ArrayOffset;
1361 Array = (UINT8 *) Subtable + ArrayOffset;
1362
1363 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1364 Subtable->Length, AcpiDmTableInfoDbg2Name);
1365 if (ACPI_FAILURE (Status))
1366 {
1367 return;
1368 }
1369
1370 /* Dump the OemData (optional) */
1371
1372 if (Subtable->OemDataOffset)
1373 {
1374 Status = AcpiDmDumpTable (Length, Subtable->OemDataOffset,
1375 Subtable, Subtable->OemDataLength,
1376 AcpiDmTableInfoDbg2OemData);
1377 if (ACPI_FAILURE (Status))
1378 {
1379 return;
1380 }
1381 }
1382
1383 /* Point to next subtable */
1384
1385 Offset += Subtable->Length;
1386 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable,
1387 Subtable->Length);
1388 }
1389 }
1390
1391
1392 /*******************************************************************************
1393 *
1394 * FUNCTION: AcpiDmDumpDmar
1395 *
1396 * PARAMETERS: Table - A DMAR table
1397 *
1398 * RETURN: None
1399 *
1400 * DESCRIPTION: Format the contents of a DMAR. This table type consists
1401 * of an open-ended number of subtables.
1402 *
1403 ******************************************************************************/
1404
1405 void
AcpiDmDumpDmar(ACPI_TABLE_HEADER * Table)1406 AcpiDmDumpDmar (
1407 ACPI_TABLE_HEADER *Table)
1408 {
1409 ACPI_STATUS Status;
1410 ACPI_DMAR_HEADER *Subtable;
1411 UINT32 Length = Table->Length;
1412 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
1413 ACPI_DMTABLE_INFO *InfoTable;
1414 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
1415 UINT32 ScopeOffset;
1416 UINT8 *PciPath;
1417 UINT32 PathOffset;
1418
1419
1420 /* Main table */
1421
1422 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
1423 if (ACPI_FAILURE (Status))
1424 {
1425 return;
1426 }
1427
1428 /* Subtables */
1429
1430 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
1431 while (Offset < Table->Length)
1432 {
1433 /* Common subtable header */
1434
1435 AcpiOsPrintf ("\n");
1436 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1437 Subtable->Length, AcpiDmTableInfoDmarHdr);
1438 if (ACPI_FAILURE (Status))
1439 {
1440 return;
1441 }
1442
1443 AcpiOsPrintf ("\n");
1444
1445 switch (Subtable->Type)
1446 {
1447 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
1448
1449 InfoTable = AcpiDmTableInfoDmar0;
1450 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
1451 break;
1452
1453 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
1454
1455 InfoTable = AcpiDmTableInfoDmar1;
1456 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
1457 break;
1458
1459 case ACPI_DMAR_TYPE_ROOT_ATS:
1460
1461 InfoTable = AcpiDmTableInfoDmar2;
1462 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
1463 break;
1464
1465 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
1466
1467 InfoTable = AcpiDmTableInfoDmar3;
1468 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
1469 break;
1470
1471 case ACPI_DMAR_TYPE_NAMESPACE:
1472
1473 InfoTable = AcpiDmTableInfoDmar4;
1474 ScopeOffset = sizeof (ACPI_DMAR_ANDD);
1475 break;
1476
1477 case ACPI_DMAR_TYPE_SATC:
1478
1479 InfoTable = AcpiDmTableInfoDmar5;
1480 ScopeOffset = sizeof (ACPI_DMAR_SATC);
1481 break;
1482
1483 case ACPI_DMAR_TYPE_SIDP:
1484
1485 InfoTable = AcpiDmTableInfoDmar6;
1486 ScopeOffset = sizeof (ACPI_DMAR_SIDP);
1487 break;
1488
1489 default:
1490
1491 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
1492 Subtable->Type);
1493 return;
1494 }
1495
1496 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1497 Subtable->Length, InfoTable);
1498 if (ACPI_FAILURE (Status))
1499 {
1500 return;
1501 }
1502
1503 /*
1504 * Dump the optional device scope entries
1505 */
1506 if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
1507 (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE))
1508 {
1509 /* These types do not support device scopes */
1510
1511 goto NextSubtable;
1512 }
1513
1514 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset);
1515 while (ScopeOffset < Subtable->Length)
1516 {
1517 AcpiOsPrintf ("\n");
1518 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
1519 ScopeTable->Length, AcpiDmTableInfoDmarScope);
1520 if (ACPI_FAILURE (Status))
1521 {
1522 return;
1523 }
1524 AcpiOsPrintf ("\n");
1525
1526 /* Dump the PCI Path entries for this device scope */
1527
1528 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
1529
1530 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
1531 sizeof (ACPI_DMAR_DEVICE_SCOPE));
1532
1533 while (PathOffset < ScopeTable->Length)
1534 {
1535 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
1536 "PCI Path");
1537 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
1538
1539 /* Point to next PCI Path entry */
1540
1541 PathOffset += 2;
1542 PciPath += 2;
1543 AcpiOsPrintf ("\n");
1544 }
1545
1546 /* Point to next device scope entry */
1547
1548 ScopeOffset += ScopeTable->Length;
1549 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
1550 ScopeTable, ScopeTable->Length);
1551 }
1552
1553 NextSubtable:
1554 /* Point to next subtable */
1555
1556 Offset += Subtable->Length;
1557 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable,
1558 Subtable->Length);
1559 }
1560 }
1561
1562
1563 /*******************************************************************************
1564 *
1565 * FUNCTION: AcpiDmDumpDrtm
1566 *
1567 * PARAMETERS: Table - A DRTM table
1568 *
1569 * RETURN: None
1570 *
1571 * DESCRIPTION: Format the contents of a DRTM.
1572 *
1573 ******************************************************************************/
1574
1575 void
AcpiDmDumpDrtm(ACPI_TABLE_HEADER * Table)1576 AcpiDmDumpDrtm (
1577 ACPI_TABLE_HEADER *Table)
1578 {
1579 ACPI_STATUS Status;
1580 UINT32 Offset;
1581 ACPI_DRTM_VTABLE_LIST *DrtmVtl;
1582 ACPI_DRTM_RESOURCE_LIST *DrtmRl;
1583 ACPI_DRTM_DPS_ID *DrtmDps;
1584 UINT32 Count;
1585
1586
1587 /* Main table */
1588
1589 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
1590 AcpiDmTableInfoDrtm);
1591 if (ACPI_FAILURE (Status))
1592 {
1593 return;
1594 }
1595
1596 Offset = sizeof (ACPI_TABLE_DRTM);
1597
1598 /* Sub-tables */
1599
1600 /* Dump ValidatedTable length */
1601
1602 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
1603 AcpiOsPrintf ("\n");
1604 Status = AcpiDmDumpTable (Table->Length, Offset,
1605 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
1606 AcpiDmTableInfoDrtm0);
1607 if (ACPI_FAILURE (Status))
1608 {
1609 return;
1610 }
1611
1612 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
1613
1614 /* Dump Validated table addresses */
1615
1616 Count = 0;
1617 while ((Offset < Table->Length) &&
1618 (DrtmVtl->ValidatedTableCount > Count))
1619 {
1620 Status = AcpiDmDumpTable (Table->Length, Offset,
1621 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
1622 AcpiDmTableInfoDrtm0a);
1623 if (ACPI_FAILURE (Status))
1624 {
1625 return;
1626 }
1627
1628 Offset += sizeof (UINT64);
1629 Count++;
1630 }
1631
1632 /* Dump ResourceList length */
1633
1634 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
1635 AcpiOsPrintf ("\n");
1636 Status = AcpiDmDumpTable (Table->Length, Offset,
1637 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
1638 AcpiDmTableInfoDrtm1);
1639 if (ACPI_FAILURE (Status))
1640 {
1641 return;
1642 }
1643
1644 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
1645
1646 /* Dump the Resource List */
1647
1648 Count = 0;
1649 while ((Offset < Table->Length) &&
1650 (DrtmRl->ResourceCount > Count))
1651 {
1652 Status = AcpiDmDumpTable (Table->Length, Offset,
1653 ACPI_ADD_PTR (void, Table, Offset),
1654 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
1655 if (ACPI_FAILURE (Status))
1656 {
1657 return;
1658 }
1659
1660 Offset += sizeof (ACPI_DRTM_RESOURCE);
1661 Count++;
1662 }
1663
1664 /* Dump DPS */
1665
1666 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
1667 AcpiOsPrintf ("\n");
1668 (void) AcpiDmDumpTable (Table->Length, Offset,
1669 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
1670 }
1671
1672
1673 /*******************************************************************************
1674 *
1675 * FUNCTION: AcpiDmDumpEinj
1676 *
1677 * PARAMETERS: Table - A EINJ table
1678 *
1679 * RETURN: None
1680 *
1681 * DESCRIPTION: Format the contents of a EINJ. This table type consists
1682 * of an open-ended number of subtables.
1683 *
1684 ******************************************************************************/
1685
1686 void
AcpiDmDumpEinj(ACPI_TABLE_HEADER * Table)1687 AcpiDmDumpEinj (
1688 ACPI_TABLE_HEADER *Table)
1689 {
1690 ACPI_STATUS Status;
1691 ACPI_WHEA_HEADER *Subtable;
1692 UINT32 Length = Table->Length;
1693 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
1694
1695
1696 /* Main table */
1697
1698 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
1699 if (ACPI_FAILURE (Status))
1700 {
1701 return;
1702 }
1703
1704 /* Subtables */
1705
1706 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1707 while (Offset < Table->Length)
1708 {
1709 AcpiOsPrintf ("\n");
1710 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1711 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
1712 if (ACPI_FAILURE (Status))
1713 {
1714 return;
1715 }
1716
1717 /* Point to next subtable (each subtable is of fixed length) */
1718
1719 Offset += sizeof (ACPI_WHEA_HEADER);
1720 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
1721 sizeof (ACPI_WHEA_HEADER));
1722 }
1723 }
1724
1725
1726 /*******************************************************************************
1727 *
1728 * FUNCTION: AcpiDmDumpErdt
1729 *
1730 * PARAMETERS: Table - A ERDT table
1731 *
1732 * RETURN: None
1733 *
1734 * DESCRIPTION: Format the contents of a ERDT. This table type consists
1735 * of an open-ended number of subtables.
1736 *
1737 ******************************************************************************/
1738
1739 void
AcpiDmDumpErdt(ACPI_TABLE_HEADER * Table)1740 AcpiDmDumpErdt (
1741 ACPI_TABLE_HEADER *Table)
1742 {
1743 ACPI_STATUS Status;
1744 ACPI_SUBTBL_HDR_16 *Subtable, *Subsubtable;
1745 ACPI_ERDT_DACD_PATHS *ScopeTable;
1746 UINT32 Offset = sizeof (ACPI_TABLE_ERDT);
1747 UINT32 Suboffset;
1748 UINT32 ScopeOffset;
1749 UINT32 SubsubtableLength = 0;
1750 ACPI_DMTABLE_INFO *InfoTable, *TrailEntries, *DacdEntries;
1751 UINT32 NumTrailers = 0;
1752
1753 /* Main table */
1754
1755 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoErdt);
1756 if (ACPI_FAILURE (Status))
1757 {
1758 return;
1759 }
1760
1761 /* Subtables */
1762 Subtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Offset);
1763 while (Offset < Table->Length)
1764 {
1765
1766 /* Dump common header */
1767
1768 AcpiOsPrintf ("\n");
1769 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1770 Subtable->Length, AcpiDmTableInfoErdtHdr);
1771 if (ACPI_FAILURE (Status))
1772 {
1773 return;
1774 }
1775
1776 AcpiOsPrintf ("\n");
1777 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1778 Subtable->Length, AcpiDmTableInfoErdtRmdd);
1779 if (ACPI_FAILURE (Status))
1780 {
1781 return;
1782 }
1783
1784 /* Subtables of this RMDD table */
1785
1786 Suboffset = Offset + sizeof(ACPI_ERDT_RMDD);
1787 Subsubtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Suboffset);
1788 while (Suboffset < Offset + Subtable->Length)
1789 {
1790 AcpiOsPrintf ("\n");
1791
1792 TrailEntries = NULL;
1793 DacdEntries = NULL;
1794 switch (Subsubtable->Type)
1795 {
1796 case ACPI_ERDT_TYPE_CACD:
1797 InfoTable = AcpiDmTableInfoErdtCacd;
1798 TrailEntries = AcpiDmTableInfoErdtCacdX2apic;
1799 SubsubtableLength = sizeof(ACPI_ERDT_CACD);
1800 break;
1801
1802 case ACPI_ERDT_TYPE_DACD:
1803 InfoTable = AcpiDmTableInfoErdtDacd;
1804 DacdEntries = AcpiDmTableInfoErdtDacdScope;
1805 SubsubtableLength = sizeof(ACPI_ERDT_DACD);
1806 break;
1807
1808 case ACPI_ERDT_TYPE_CMRC:
1809 InfoTable = AcpiDmTableInfoErdtCmrc;
1810 break;
1811
1812 case ACPI_ERDT_TYPE_MMRC:
1813 InfoTable = AcpiDmTableInfoErdtMmrc;
1814 TrailEntries = AcpiDmTableInfoErdtMmrcCorrFactor;
1815 SubsubtableLength = sizeof(ACPI_ERDT_MMRC);
1816 break;
1817
1818 case ACPI_ERDT_TYPE_MARC:
1819 InfoTable = AcpiDmTableInfoErdtMarc;
1820 break;
1821
1822 case ACPI_ERDT_TYPE_CARC:
1823 InfoTable = AcpiDmTableInfoErdtCarc;
1824 break;
1825
1826 case ACPI_ERDT_TYPE_CMRD:
1827 InfoTable = AcpiDmTableInfoErdtCmrd;
1828 break;
1829
1830 case ACPI_ERDT_TYPE_IBRD:
1831 InfoTable = AcpiDmTableInfoErdtIbrd;
1832 TrailEntries = AcpiDmTableInfoErdtIbrdCorrFactor;
1833 SubsubtableLength = sizeof(ACPI_ERDT_IBRD);
1834 break;
1835
1836 case ACPI_ERDT_TYPE_IBAD:
1837 InfoTable = AcpiDmTableInfoErdtIbad;
1838 break;
1839
1840 case ACPI_ERDT_TYPE_CARD:
1841 InfoTable = AcpiDmTableInfoErdtCard;
1842 break;
1843
1844 default:
1845 AcpiOsPrintf ("\n**** Unknown RMDD subtable type 0x%X\n",
1846 Subsubtable->Type);
1847
1848 /* Attempt to continue */
1849
1850 if (!Subsubtable->Length)
1851 {
1852 AcpiOsPrintf ("Invalid zero length subtable\n");
1853 return;
1854 }
1855 goto NextSubsubtable;
1856 }
1857
1858 /* Dump subtable header */
1859
1860 Status = AcpiDmDumpTable (Table->Length, Suboffset, Subsubtable,
1861 Subsubtable->Length, AcpiDmTableInfoErdtHdr);
1862 if (ACPI_FAILURE (Status))
1863 {
1864 return;
1865 }
1866
1867 /* Dump subtable body */
1868
1869 Status = AcpiDmDumpTable (Table->Length, Suboffset, Subsubtable,
1870 Subsubtable->Length, InfoTable);
1871 if (ACPI_FAILURE (Status))
1872 {
1873 return;
1874 }
1875
1876 /* CACD, MMRC, and IBRD subtables have simple flex array at end */
1877
1878 if (TrailEntries)
1879 {
1880 NumTrailers = 0;
1881 while (NumTrailers < Subsubtable->Length - SubsubtableLength)
1882 {
1883
1884 /* Dump one flex array element */
1885
1886 Status = AcpiDmDumpTable (Table->Length, Suboffset +
1887 SubsubtableLength + NumTrailers,
1888 ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Subsubtable,
1889 SubsubtableLength + NumTrailers),
1890 sizeof(UINT32), TrailEntries);
1891 if (ACPI_FAILURE (Status))
1892 {
1893 return;
1894 }
1895 NumTrailers += sizeof(UINT32);
1896 }
1897 }
1898
1899 /* DACD subtable has flex array of device agent structures */
1900
1901 if (DacdEntries) {
1902 ScopeOffset = Suboffset + SubsubtableLength;
1903 ScopeTable = ACPI_ADD_PTR (ACPI_ERDT_DACD_PATHS,
1904 Subsubtable, SubsubtableLength);
1905 while (ScopeOffset < Suboffset + Subsubtable->Length)
1906 {
1907 /* Dump one device agent structure */
1908
1909 AcpiOsPrintf ("\n");
1910 Status = AcpiDmDumpTable (Table->Length, ScopeOffset,
1911 ScopeTable, ScopeTable->Header.Length, DacdEntries);
1912 if (ACPI_FAILURE (Status))
1913 {
1914 return;
1915 }
1916
1917 /* Flex array of UINT8 for device path */
1918
1919 NumTrailers = 0;
1920 while (NumTrailers < ScopeTable->Header.Length - sizeof(ACPI_ERDT_DACD_PATHS))
1921 {
1922 /* Dump one UINT8 of the device path */
1923
1924 Status = AcpiDmDumpTable (Table->Length, ScopeOffset +
1925 sizeof(ACPI_ERDT_DACD_PATHS) + NumTrailers,
1926 ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, ScopeTable,
1927 sizeof(*ScopeTable) + NumTrailers),
1928 sizeof(UINT32), AcpiDmTableInfoErdtDacdPath);
1929 if (ACPI_FAILURE (Status))
1930 {
1931 return;
1932 }
1933 NumTrailers++;
1934 }
1935
1936 ScopeOffset += ScopeTable->Header.Length;
1937 ScopeTable = ACPI_ADD_PTR (ACPI_ERDT_DACD_PATHS,
1938 ScopeTable, ScopeTable->Header.Length);
1939 }
1940 }
1941 NextSubsubtable:
1942 Suboffset += Subsubtable->Length;
1943 Subsubtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Suboffset);
1944 }
1945
1946 Offset += Subtable->Length;
1947 Subtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Subtable,
1948 Subtable->Length);
1949 }
1950 }
1951
1952
1953 /*******************************************************************************
1954 *
1955 * FUNCTION: AcpiDmDumpErst
1956 *
1957 * PARAMETERS: Table - A ERST table
1958 *
1959 * RETURN: None
1960 *
1961 * DESCRIPTION: Format the contents of a ERST. This table type consists
1962 * of an open-ended number of subtables.
1963 *
1964 ******************************************************************************/
1965
1966 void
AcpiDmDumpErst(ACPI_TABLE_HEADER * Table)1967 AcpiDmDumpErst (
1968 ACPI_TABLE_HEADER *Table)
1969 {
1970 ACPI_STATUS Status;
1971 ACPI_WHEA_HEADER *Subtable;
1972 UINT32 Length = Table->Length;
1973 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
1974
1975
1976 /* Main table */
1977
1978 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1979 if (ACPI_FAILURE (Status))
1980 {
1981 return;
1982 }
1983
1984 /* Subtables */
1985
1986 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1987 while (Offset < Table->Length)
1988 {
1989 AcpiOsPrintf ("\n");
1990 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1991 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1992 if (ACPI_FAILURE (Status))
1993 {
1994 return;
1995 }
1996
1997 /* Point to next subtable (each subtable is of fixed length) */
1998
1999 Offset += sizeof (ACPI_WHEA_HEADER);
2000 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
2001 sizeof (ACPI_WHEA_HEADER));
2002 }
2003 }
2004
2005
2006 /*******************************************************************************
2007 *
2008 * FUNCTION: AcpiDmDumpFpdt
2009 *
2010 * PARAMETERS: Table - A FPDT table
2011 *
2012 * RETURN: None
2013 *
2014 * DESCRIPTION: Format the contents of a FPDT. This table type consists
2015 * of an open-ended number of subtables.
2016 *
2017 ******************************************************************************/
2018
2019 void
AcpiDmDumpFpdt(ACPI_TABLE_HEADER * Table)2020 AcpiDmDumpFpdt (
2021 ACPI_TABLE_HEADER *Table)
2022 {
2023 ACPI_STATUS Status;
2024 ACPI_FPDT_HEADER *Subtable;
2025 UINT32 Length = Table->Length;
2026 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
2027 ACPI_DMTABLE_INFO *InfoTable;
2028
2029
2030 /* There is no main table (other than the standard ACPI header) */
2031
2032 /* Subtables */
2033
2034 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
2035 while (Offset < Table->Length)
2036 {
2037 /* Common subtable header */
2038
2039 AcpiOsPrintf ("\n");
2040 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2041 Subtable->Length, AcpiDmTableInfoFpdtHdr);
2042 if (ACPI_FAILURE (Status))
2043 {
2044 return;
2045 }
2046
2047 switch (Subtable->Type)
2048 {
2049 case ACPI_FPDT_TYPE_BOOT:
2050
2051 InfoTable = AcpiDmTableInfoFpdt0;
2052 break;
2053
2054 case ACPI_FPDT_TYPE_S3PERF:
2055
2056 InfoTable = AcpiDmTableInfoFpdt1;
2057 break;
2058
2059 default:
2060
2061 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
2062 Subtable->Type);
2063
2064 /* Attempt to continue */
2065
2066 if (!Subtable->Length)
2067 {
2068 AcpiOsPrintf ("Invalid zero length subtable\n");
2069 return;
2070 }
2071 goto NextSubtable;
2072 }
2073
2074 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2075 Subtable->Length, InfoTable);
2076 if (ACPI_FAILURE (Status))
2077 {
2078 return;
2079 }
2080
2081 NextSubtable:
2082 /* Point to next subtable */
2083
2084 Offset += Subtable->Length;
2085 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable,
2086 Subtable->Length);
2087 }
2088 }
2089
2090
2091 /*******************************************************************************
2092 *
2093 * FUNCTION: AcpiDmDumpGtdt
2094 *
2095 * PARAMETERS: Table - A GTDT table
2096 *
2097 * RETURN: None
2098 *
2099 * DESCRIPTION: Format the contents of a GTDT. This table type consists
2100 * of an open-ended number of subtables.
2101 *
2102 ******************************************************************************/
2103
2104 void
AcpiDmDumpGtdt(ACPI_TABLE_HEADER * Table)2105 AcpiDmDumpGtdt (
2106 ACPI_TABLE_HEADER *Table)
2107 {
2108 ACPI_STATUS Status;
2109 ACPI_GTDT_HEADER *Subtable;
2110 UINT32 Length = Table->Length;
2111 UINT32 Offset = sizeof (ACPI_TABLE_GTDT);
2112 ACPI_DMTABLE_INFO *InfoTable;
2113 UINT32 SubtableLength;
2114 UINT32 GtCount;
2115 ACPI_GTDT_TIMER_ENTRY *GtxTable;
2116
2117
2118 /* Main table */
2119
2120 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
2121 if (ACPI_FAILURE (Status))
2122 {
2123 return;
2124 }
2125
2126 /* Rev 3 fields */
2127
2128 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
2129
2130 if (Table->Revision > 2)
2131 {
2132 SubtableLength = sizeof (ACPI_GTDT_EL2);
2133 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2134 SubtableLength, AcpiDmTableInfoGtdtEl2);
2135 if (ACPI_FAILURE (Status))
2136 {
2137 return;
2138 }
2139 Offset += SubtableLength;
2140 }
2141
2142 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
2143
2144 /* Subtables */
2145
2146 while (Offset < Table->Length)
2147 {
2148 /* Common subtable header */
2149
2150 AcpiOsPrintf ("\n");
2151 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2152 Subtable->Length, AcpiDmTableInfoGtdtHdr);
2153 if (ACPI_FAILURE (Status))
2154 {
2155 return;
2156 }
2157
2158 GtCount = 0;
2159 switch (Subtable->Type)
2160 {
2161 case ACPI_GTDT_TYPE_TIMER_BLOCK:
2162
2163 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
2164 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
2165 Subtable))->TimerCount;
2166
2167 InfoTable = AcpiDmTableInfoGtdt0;
2168 break;
2169
2170 case ACPI_GTDT_TYPE_WATCHDOG:
2171
2172 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG);
2173
2174 InfoTable = AcpiDmTableInfoGtdt1;
2175 break;
2176
2177 default:
2178
2179 /* Cannot continue on unknown type - no length */
2180
2181 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
2182 Subtable->Type);
2183 return;
2184 }
2185
2186 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2187 Subtable->Length, InfoTable);
2188 if (ACPI_FAILURE (Status))
2189 {
2190 return;
2191 }
2192
2193 /* Point to end of current subtable (each subtable above is of fixed length) */
2194
2195 Offset += SubtableLength;
2196
2197 /* If there are any Gt Timer Blocks from above, dump them now */
2198
2199 if (GtCount)
2200 {
2201 GtxTable = ACPI_ADD_PTR (
2202 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength);
2203 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
2204
2205 while (GtCount)
2206 {
2207 AcpiOsPrintf ("\n");
2208 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
2209 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
2210 if (ACPI_FAILURE (Status))
2211 {
2212 return;
2213 }
2214 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
2215 GtxTable++;
2216 GtCount--;
2217 }
2218 }
2219
2220 /* Point to next subtable */
2221
2222 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength);
2223 }
2224 }
2225
2226
2227 /*******************************************************************************
2228 *
2229 * FUNCTION: AcpiDmDumpHest
2230 *
2231 * PARAMETERS: Table - A HEST table
2232 *
2233 * RETURN: None
2234 *
2235 * DESCRIPTION: Format the contents of a HEST. This table type consists
2236 * of an open-ended number of subtables.
2237 *
2238 ******************************************************************************/
2239
2240 void
AcpiDmDumpHest(ACPI_TABLE_HEADER * Table)2241 AcpiDmDumpHest (
2242 ACPI_TABLE_HEADER *Table)
2243 {
2244 ACPI_STATUS Status;
2245 ACPI_HEST_HEADER *Subtable;
2246 UINT32 Length = Table->Length;
2247 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
2248 ACPI_DMTABLE_INFO *InfoTable;
2249 UINT32 SubtableLength;
2250 UINT32 BankCount;
2251 ACPI_HEST_IA_ERROR_BANK *BankTable;
2252
2253
2254 /* Main table */
2255
2256 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
2257 if (ACPI_FAILURE (Status))
2258 {
2259 return;
2260 }
2261
2262 /* Subtables */
2263
2264 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
2265 while (Offset < Table->Length)
2266 {
2267 BankCount = 0;
2268 switch (Subtable->Type)
2269 {
2270 case ACPI_HEST_TYPE_IA32_CHECK:
2271
2272 InfoTable = AcpiDmTableInfoHest0;
2273 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
2274 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
2275 Subtable))->NumHardwareBanks;
2276 break;
2277
2278 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
2279
2280 InfoTable = AcpiDmTableInfoHest1;
2281 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED);
2282 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
2283 Subtable))->NumHardwareBanks;
2284 break;
2285
2286 case ACPI_HEST_TYPE_IA32_NMI:
2287
2288 InfoTable = AcpiDmTableInfoHest2;
2289 SubtableLength = sizeof (ACPI_HEST_IA_NMI);
2290 break;
2291
2292 case ACPI_HEST_TYPE_AER_ROOT_PORT:
2293
2294 InfoTable = AcpiDmTableInfoHest6;
2295 SubtableLength = sizeof (ACPI_HEST_AER_ROOT);
2296 break;
2297
2298 case ACPI_HEST_TYPE_AER_ENDPOINT:
2299
2300 InfoTable = AcpiDmTableInfoHest7;
2301 SubtableLength = sizeof (ACPI_HEST_AER);
2302 break;
2303
2304 case ACPI_HEST_TYPE_AER_BRIDGE:
2305
2306 InfoTable = AcpiDmTableInfoHest8;
2307 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE);
2308 break;
2309
2310 case ACPI_HEST_TYPE_GENERIC_ERROR:
2311
2312 InfoTable = AcpiDmTableInfoHest9;
2313 SubtableLength = sizeof (ACPI_HEST_GENERIC);
2314 break;
2315
2316 case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
2317
2318 InfoTable = AcpiDmTableInfoHest10;
2319 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2);
2320 break;
2321
2322 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
2323
2324 InfoTable = AcpiDmTableInfoHest11;
2325 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK);
2326 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
2327 Subtable))->NumHardwareBanks;
2328 break;
2329
2330 default:
2331
2332 /* Cannot continue on unknown type - no length */
2333
2334 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
2335 Subtable->Type);
2336 return;
2337 }
2338
2339 AcpiOsPrintf ("\n");
2340 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2341 SubtableLength, InfoTable);
2342 if (ACPI_FAILURE (Status))
2343 {
2344 return;
2345 }
2346
2347 /* Point to end of current subtable (each subtable above is of fixed length) */
2348
2349 Offset += SubtableLength;
2350
2351 /* If there are any (fixed-length) Error Banks from above, dump them now */
2352
2353 if (BankCount)
2354 {
2355 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable,
2356 SubtableLength);
2357 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
2358
2359 while (BankCount)
2360 {
2361 AcpiOsPrintf ("\n");
2362 Status = AcpiDmDumpTable (Length, Offset, BankTable,
2363 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
2364 if (ACPI_FAILURE (Status))
2365 {
2366 return;
2367 }
2368
2369 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
2370 BankTable++;
2371 BankCount--;
2372 }
2373 }
2374
2375 /* Point to next subtable */
2376
2377 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength);
2378 }
2379 }
2380
2381
2382 /*******************************************************************************
2383 *
2384 * FUNCTION: AcpiDmDumpHmat
2385 *
2386 * PARAMETERS: Table - A HMAT table
2387 *
2388 * RETURN: None
2389 *
2390 * DESCRIPTION: Format the contents of a HMAT.
2391 *
2392 ******************************************************************************/
2393
2394 void
AcpiDmDumpHmat(ACPI_TABLE_HEADER * Table)2395 AcpiDmDumpHmat (
2396 ACPI_TABLE_HEADER *Table)
2397 {
2398 ACPI_STATUS Status;
2399 ACPI_HMAT_STRUCTURE *HmatStruct;
2400 ACPI_HMAT_LOCALITY *HmatLocality;
2401 ACPI_HMAT_CACHE *HmatCache;
2402 UINT32 Offset;
2403 UINT32 SubtableOffset;
2404 UINT32 Length;
2405 ACPI_DMTABLE_INFO *InfoTable;
2406 UINT32 i, j;
2407
2408
2409 /* Main table */
2410
2411 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat);
2412 if (ACPI_FAILURE (Status))
2413 {
2414 return;
2415 }
2416 Offset = sizeof (ACPI_TABLE_HMAT);
2417
2418 while (Offset < Table->Length)
2419 {
2420 AcpiOsPrintf ("\n");
2421
2422 /* Dump HMAT structure header */
2423
2424 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset);
2425 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE))
2426 {
2427 AcpiOsPrintf ("Invalid HMAT structure length\n");
2428 return;
2429 }
2430 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
2431 HmatStruct->Length, AcpiDmTableInfoHmatHdr);
2432 if (ACPI_FAILURE (Status))
2433 {
2434 return;
2435 }
2436
2437 switch (HmatStruct->Type)
2438 {
2439 case ACPI_HMAT_TYPE_ADDRESS_RANGE:
2440
2441 InfoTable = AcpiDmTableInfoHmat0;
2442 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN);
2443 break;
2444
2445 case ACPI_HMAT_TYPE_LOCALITY:
2446
2447 InfoTable = AcpiDmTableInfoHmat1;
2448 Length = sizeof (ACPI_HMAT_LOCALITY);
2449 break;
2450
2451 case ACPI_HMAT_TYPE_CACHE:
2452
2453 InfoTable = AcpiDmTableInfoHmat2;
2454 Length = sizeof (ACPI_HMAT_CACHE);
2455 break;
2456
2457 default:
2458
2459 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n",
2460 HmatStruct->Type);
2461
2462 /* Attempt to continue */
2463
2464 goto NextSubtable;
2465 }
2466
2467 /* Dump HMAT structure body */
2468
2469 if (HmatStruct->Length < Length)
2470 {
2471 AcpiOsPrintf ("Invalid HMAT structure length\n");
2472 return;
2473 }
2474 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
2475 HmatStruct->Length, InfoTable);
2476 if (ACPI_FAILURE (Status))
2477 {
2478 return;
2479 }
2480
2481 /* Dump HMAT structure additional */
2482
2483 switch (HmatStruct->Type)
2484 {
2485 case ACPI_HMAT_TYPE_LOCALITY:
2486
2487 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct);
2488 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY);
2489
2490 /* Dump initiator proximity domains */
2491
2492 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2493 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4))
2494 {
2495 AcpiOsPrintf ("Invalid initiator proximity domain number\n");
2496 return;
2497 }
2498 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
2499 {
2500 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2501 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2502 4, AcpiDmTableInfoHmat1a);
2503 if (ACPI_FAILURE (Status))
2504 {
2505 return;
2506 }
2507
2508 SubtableOffset += 4;
2509 }
2510
2511 /* Dump target proximity domains */
2512
2513 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2514 (UINT32)(HmatLocality->NumberOfTargetPDs * 4))
2515 {
2516 AcpiOsPrintf ("Invalid target proximity domain number\n");
2517 return;
2518 }
2519 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++)
2520 {
2521 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2522 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2523 4, AcpiDmTableInfoHmat1b);
2524 if (ACPI_FAILURE (Status))
2525 {
2526 return;
2527 }
2528
2529 SubtableOffset += 4;
2530 }
2531
2532 /* Dump latency/bandwidth entris */
2533
2534 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2535 (UINT32)(HmatLocality->NumberOfInitiatorPDs *
2536 HmatLocality->NumberOfTargetPDs * 2))
2537 {
2538 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n");
2539 return;
2540 }
2541 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
2542 {
2543 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++)
2544 {
2545 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2546 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2547 2, AcpiDmTableInfoHmat1c);
2548 if (ACPI_FAILURE(Status))
2549 {
2550 return;
2551 }
2552
2553 SubtableOffset += 2;
2554 }
2555 }
2556 break;
2557
2558 case ACPI_HMAT_TYPE_CACHE:
2559
2560 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct);
2561 SubtableOffset = sizeof (ACPI_HMAT_CACHE);
2562
2563 /* Dump SMBIOS handles */
2564
2565 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2566 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2))
2567 {
2568 AcpiOsPrintf ("Invalid SMBIOS handle number\n");
2569 return;
2570 }
2571 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++)
2572 {
2573 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2574 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2575 2, AcpiDmTableInfoHmat2a);
2576 if (ACPI_FAILURE (Status))
2577 {
2578 return;
2579 }
2580
2581 SubtableOffset += 2;
2582 }
2583 break;
2584
2585 default:
2586
2587 break;
2588 }
2589
2590 NextSubtable:
2591 /* Point to next HMAT structure subtable */
2592
2593 Offset += (HmatStruct->Length);
2594 }
2595 }
2596