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