1 /******************************************************************************
2 *
3 * Module Name: dmtbdump2 - 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 <wchar.h>
153 #include <contrib/dev/acpica/include/acpi.h>
154 #include <contrib/dev/acpica/include/accommon.h>
155 #include <contrib/dev/acpica/include/acdisasm.h>
156 #include <contrib/dev/acpica/include/actables.h>
157 #include <contrib/dev/acpica/compiler/aslcompiler.h>
158
159 /* This module used for application-level code only */
160
161 #define _COMPONENT ACPI_CA_DISASSEMBLER
162 ACPI_MODULE_NAME ("dmtbdump2")
163
164
165 /*******************************************************************************
166 *
167 * FUNCTION: AcpiDmDumpIort
168 *
169 * PARAMETERS: Table - A IORT table
170 *
171 * RETURN: None
172 *
173 * DESCRIPTION: Format the contents of a IORT
174 *
175 ******************************************************************************/
176
177 void
AcpiDmDumpIort(ACPI_TABLE_HEADER * Table)178 AcpiDmDumpIort (
179 ACPI_TABLE_HEADER *Table)
180 {
181 ACPI_STATUS Status;
182 ACPI_TABLE_IORT *Iort;
183 ACPI_IORT_NODE *IortNode;
184 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL;
185 ACPI_IORT_SMMU *IortSmmu = NULL;
186 ACPI_IORT_RMR *IortRmr = NULL;
187 UINT32 Offset;
188 UINT32 NodeOffset;
189 UINT32 Length;
190 ACPI_DMTABLE_INFO *InfoTable;
191 char *String;
192 UINT32 i;
193 UINT32 MappingByteLength;
194 UINT8 Revision;
195
196
197 /* Main table */
198
199 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
200 if (ACPI_FAILURE (Status))
201 {
202 return;
203 }
204
205 Revision = Table->Revision;
206
207 /* IORT Revisions E, E.a and E.c have known issues and are not supported */
208
209 if (Revision == 1 || Revision == 2 || Revision == 4)
210 {
211 AcpiOsPrintf ("\n**** Unsupported IORT revision 0x%X\n",
212 Revision);
213 return;
214 }
215
216 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
217 Offset = sizeof (ACPI_TABLE_IORT);
218
219 /* Dump the OptionalPadding (optional) */
220
221 if (Iort->NodeOffset > Offset)
222 {
223 Status = AcpiDmDumpTable (Table->Length, Offset, Table,
224 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
225 if (ACPI_FAILURE (Status))
226 {
227 return;
228 }
229 }
230
231 Offset = Iort->NodeOffset;
232 while (Offset < Table->Length)
233 {
234 /* Common subtable header */
235
236 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
237 AcpiOsPrintf ("\n");
238 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
239
240 if (Revision == 0)
241 {
242 Status = AcpiDmDumpTable (Table->Length, Offset,
243 IortNode, Length, AcpiDmTableInfoIortHdr);
244 }
245 else if (Revision >= 3)
246 {
247 Status = AcpiDmDumpTable (Table->Length, Offset,
248 IortNode, Length, AcpiDmTableInfoIortHdr3);
249 }
250
251 if (ACPI_FAILURE (Status))
252 {
253 return;
254 }
255
256 NodeOffset = Length;
257
258 switch (IortNode->Type)
259 {
260 case ACPI_IORT_NODE_ITS_GROUP:
261
262 InfoTable = AcpiDmTableInfoIort0;
263 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
264 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
265 break;
266
267 case ACPI_IORT_NODE_NAMED_COMPONENT:
268
269 InfoTable = AcpiDmTableInfoIort1;
270 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
271 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
272 Length += strlen (String) + 1;
273 break;
274
275 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
276
277 InfoTable = AcpiDmTableInfoIort2;
278 Length = IortNode->Length - NodeOffset;
279 break;
280
281 case ACPI_IORT_NODE_SMMU:
282
283 InfoTable = AcpiDmTableInfoIort3;
284 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
285 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
286 break;
287
288 case ACPI_IORT_NODE_SMMU_V3:
289
290 InfoTable = AcpiDmTableInfoIort4;
291 Length = IortNode->Length - NodeOffset;
292 break;
293
294 case ACPI_IORT_NODE_PMCG:
295
296 InfoTable = AcpiDmTableInfoIort5;
297 Length = IortNode->Length - NodeOffset;
298 break;
299
300 case ACPI_IORT_NODE_RMR:
301
302 InfoTable = AcpiDmTableInfoIort6;
303 Length = IortNode->Length - NodeOffset;
304 IortRmr = ACPI_ADD_PTR (ACPI_IORT_RMR, IortNode, NodeOffset);
305 break;
306
307 default:
308
309 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
310 IortNode->Type);
311
312 /* Attempt to continue */
313
314 if (!IortNode->Length)
315 {
316 AcpiOsPrintf ("Invalid zero length IORT node\n");
317 return;
318 }
319 goto NextSubtable;
320 }
321
322 /* Dump the node subtable header */
323
324 AcpiOsPrintf ("\n");
325 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
326 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
327 Length, InfoTable);
328 if (ACPI_FAILURE (Status))
329 {
330 return;
331 }
332
333 NodeOffset += Length;
334
335 /* Dump the node specific data */
336
337 switch (IortNode->Type)
338 {
339 case ACPI_IORT_NODE_ITS_GROUP:
340
341 /* Validate IortItsGroup to avoid compiler warnings */
342
343 if (IortItsGroup)
344 {
345 for (i = 0; i < IortItsGroup->ItsCount; i++)
346 {
347 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
348 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
349 4, AcpiDmTableInfoIort0a);
350 if (ACPI_FAILURE (Status))
351 {
352 return;
353 }
354
355 NodeOffset += 4;
356 }
357 }
358 break;
359
360 case ACPI_IORT_NODE_NAMED_COMPONENT:
361
362 /* Dump the Padding (optional) */
363
364 if (IortNode->Length > NodeOffset)
365 {
366 MappingByteLength =
367 IortNode->MappingCount * sizeof (ACPI_IORT_ID_MAPPING);
368 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
369 Table, IortNode->Length - NodeOffset - MappingByteLength,
370 AcpiDmTableInfoIort1a);
371 if (ACPI_FAILURE (Status))
372 {
373 return;
374 }
375 }
376 break;
377
378 case ACPI_IORT_NODE_SMMU:
379
380 AcpiOsPrintf ("\n");
381
382 /* Validate IortSmmu to avoid compiler warnings */
383
384 if (IortSmmu)
385 {
386 Length = 2 * sizeof (UINT64);
387 NodeOffset = IortSmmu->GlobalInterruptOffset;
388 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
389 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
390 Length, AcpiDmTableInfoIort3a);
391 if (ACPI_FAILURE (Status))
392 {
393 return;
394 }
395
396 NodeOffset = IortSmmu->ContextInterruptOffset;
397 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
398 {
399 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
400 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
401 8, AcpiDmTableInfoIort3b);
402 if (ACPI_FAILURE (Status))
403 {
404 return;
405 }
406
407 NodeOffset += 8;
408 }
409
410 NodeOffset = IortSmmu->PmuInterruptOffset;
411 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
412 {
413 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
414 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
415 8, AcpiDmTableInfoIort3c);
416 if (ACPI_FAILURE (Status))
417 {
418 return;
419 }
420
421 NodeOffset += 8;
422 }
423 }
424 break;
425
426 case ACPI_IORT_NODE_RMR:
427
428 /* Validate IortRmr to avoid compiler warnings */
429 if (IortRmr)
430 {
431 NodeOffset = IortRmr->RmrOffset;
432 Length = sizeof (ACPI_IORT_RMR_DESC);
433 for (i = 0; i < IortRmr->RmrCount; i++)
434 {
435 AcpiOsPrintf ("\n");
436 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
437 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
438 Length, AcpiDmTableInfoIort6a);
439 if (ACPI_FAILURE (Status))
440 {
441 return;
442 }
443
444 NodeOffset += Length;
445 }
446 }
447 break;
448
449 default:
450
451 break;
452 }
453
454 /* Dump the ID mappings */
455
456 NodeOffset = IortNode->MappingOffset;
457 for (i = 0; i < IortNode->MappingCount; i++)
458 {
459 AcpiOsPrintf ("\n");
460 Length = sizeof (ACPI_IORT_ID_MAPPING);
461 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
462 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
463 Length, AcpiDmTableInfoIortMap);
464 if (ACPI_FAILURE (Status))
465 {
466 return;
467 }
468
469 NodeOffset += Length;
470 }
471
472 NextSubtable:
473 /* Point to next node subtable */
474
475 Offset += IortNode->Length;
476 }
477 }
478
479
480 /*******************************************************************************
481 *
482 * FUNCTION: AcpiDmDumpIvrs
483 *
484 * PARAMETERS: Table - A IVRS table
485 *
486 * RETURN: None
487 *
488 * DESCRIPTION: Format the contents of a IVRS. Notes:
489 * The IVRS is essentially a flat table, with the following
490 * structure:
491 * <Main ACPI Table Header>
492 * <Main subtable - virtualization info>
493 * <IVHD>
494 * <Device Entries>
495 * ...
496 * <IVHD>
497 * <Device Entries>
498 * <IVMD>
499 * ...
500 *
501 ******************************************************************************/
502
503 void
AcpiDmDumpIvrs(ACPI_TABLE_HEADER * Table)504 AcpiDmDumpIvrs (
505 ACPI_TABLE_HEADER *Table)
506 {
507 ACPI_STATUS Status;
508 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
509 UINT32 EntryOffset;
510 UINT32 EntryLength;
511 UINT32 EntryType;
512 ACPI_IVRS_DEVICE_HID *HidSubtable;
513 ACPI_IVRS_DE_HEADER *DeviceEntry;
514 ACPI_IVRS_HEADER *Subtable;
515 ACPI_DMTABLE_INFO *InfoTable;
516
517
518 /* Main table */
519
520 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
521 if (ACPI_FAILURE (Status))
522 {
523 return;
524 }
525
526 /* Subtables */
527
528 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
529
530 while (Offset < Table->Length)
531 {
532 switch (Subtable->Type)
533 {
534 /* Type 10h, IVHD (I/O Virtualization Hardware Definition) */
535
536 case ACPI_IVRS_TYPE_HARDWARE1:
537
538 AcpiOsPrintf ("\n");
539 InfoTable = AcpiDmTableInfoIvrsHware1;
540 break;
541
542 /* Types 11h, 40h, IVHD (I/O Virtualization Hardware Definition) */
543
544 case ACPI_IVRS_TYPE_HARDWARE2:
545 case ACPI_IVRS_TYPE_HARDWARE3:
546
547 AcpiOsPrintf ("\n");
548 InfoTable = AcpiDmTableInfoIvrsHware23;
549 break;
550
551 /* Types 20h-22h, IVMD (I/O Virtualization Memory Definition Block) */
552
553 case ACPI_IVRS_TYPE_MEMORY1:
554 case ACPI_IVRS_TYPE_MEMORY2:
555 case ACPI_IVRS_TYPE_MEMORY3:
556
557 AcpiOsPrintf ("\n");
558 InfoTable = AcpiDmTableInfoIvrsMemory;
559 break;
560
561 default:
562
563 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
564 Subtable->Type);
565
566 /* Attempt to continue */
567
568 if (!Subtable->Length)
569 {
570 AcpiOsPrintf ("Invalid zero length subtable\n");
571 return;
572 }
573 goto NextSubtable;
574 }
575
576 /* Dump the subtable */
577
578 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
579 Subtable->Length, InfoTable);
580 if (ACPI_FAILURE (Status))
581 {
582 return;
583 }
584
585 /* The hardware subtables (IVHD) can contain multiple device entries */
586
587 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1 ||
588 Subtable->Type == ACPI_IVRS_TYPE_HARDWARE2 ||
589 Subtable->Type == ACPI_IVRS_TYPE_HARDWARE3)
590 {
591 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1)
592 {
593 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE1);
594 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
595 sizeof (ACPI_IVRS_HARDWARE1));
596 }
597 else
598 {
599 /* ACPI_IVRS_TYPE_HARDWARE2, HARDWARE3 subtable types */
600
601 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE2);
602 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
603 sizeof (ACPI_IVRS_HARDWARE2));
604 }
605
606 /* Process all of the Device Entries */
607
608 while (EntryOffset < (Offset + Subtable->Length))
609 {
610 AcpiOsPrintf ("\n");
611
612 /*
613 * Upper 2 bits of Type encode the length of the device entry
614 *
615 * 00 = 4 byte
616 * 01 = 8 byte
617 * 1x = variable length
618 */
619 EntryType = DeviceEntry->Type;
620 EntryLength = EntryType >> 6 == 1 ? 8 : 4;
621
622 switch (EntryType)
623 {
624 /* 4-byte device entries */
625
626 case ACPI_IVRS_TYPE_PAD4:
627 case ACPI_IVRS_TYPE_ALL:
628 case ACPI_IVRS_TYPE_SELECT:
629 case ACPI_IVRS_TYPE_START:
630 case ACPI_IVRS_TYPE_END:
631
632 InfoTable = AcpiDmTableInfoIvrs4;
633 break;
634
635 /* 8-byte entries, type A */
636
637 case ACPI_IVRS_TYPE_ALIAS_SELECT:
638 case ACPI_IVRS_TYPE_ALIAS_START:
639
640 InfoTable = AcpiDmTableInfoIvrs8a;
641 break;
642
643 /* 8-byte entries, type B */
644
645 case ACPI_IVRS_TYPE_PAD8:
646 case ACPI_IVRS_TYPE_EXT_SELECT:
647 case ACPI_IVRS_TYPE_EXT_START:
648
649 InfoTable = AcpiDmTableInfoIvrs8b;
650 break;
651
652 /* 8-byte entries, type C */
653
654 case ACPI_IVRS_TYPE_SPECIAL:
655
656 InfoTable = AcpiDmTableInfoIvrs8c;
657 break;
658
659 /* Variable-length entries */
660
661 case ACPI_IVRS_TYPE_HID:
662
663 EntryLength = 4;
664 InfoTable = AcpiDmTableInfoIvrsHid;
665 break;
666
667 default:
668 InfoTable = AcpiDmTableInfoIvrs4;
669 AcpiOsPrintf (
670 "\n**** Unknown IVRS device entry type/length: "
671 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
672 EntryType, EntryLength, EntryOffset);
673 break;
674 }
675
676 /* Dump the Device Entry */
677
678 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
679 DeviceEntry, EntryLength, InfoTable);
680 if (ACPI_FAILURE (Status))
681 {
682 return;
683 }
684
685 HidSubtable = ACPI_CAST_PTR (ACPI_IVRS_DEVICE_HID, DeviceEntry);
686 EntryOffset += EntryLength;
687 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, HidSubtable,
688 EntryLength);
689
690 if (EntryType == ACPI_IVRS_TYPE_HID)
691 {
692 /*
693 * Determine if the HID is an integer or a string.
694 * An integer is defined to be 32 bits, with the upper 32 bits
695 * set to zero. (from the ACPI Spec): "The HID can be a 32-bit
696 * integer or a character string. If an integer, the lower
697 * 4 bytes of the field contain the integer and the upper
698 * 4 bytes are padded with 0".
699 */
700 if (UtIsIdInteger ((UINT8 *) &HidSubtable->AcpiHid))
701 {
702 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
703 &HidSubtable->AcpiHid, 8, AcpiDmTableInfoIvrsHidInteger);
704 }
705 else
706 {
707 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
708 &HidSubtable->AcpiHid, 8, AcpiDmTableInfoIvrsHidString);
709 }
710 if (ACPI_FAILURE (Status))
711 {
712 return;
713 }
714
715 EntryOffset += 8;
716
717 /*
718 * Determine if the CID is an integer or a string. The format
719 * of the CID is the same as the HID above. From ACPI Spec:
720 * "If present, CID must be a single Compatible Device ID
721 * following the same format as the HID field."
722 */
723 if (UtIsIdInteger ((UINT8 *) &HidSubtable->AcpiCid))
724 {
725 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
726 &HidSubtable->AcpiCid, 8, AcpiDmTableInfoIvrsCidInteger);
727 }
728 else
729 {
730 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
731 &HidSubtable->AcpiCid, 8, AcpiDmTableInfoIvrsCidString);
732 }
733 if (ACPI_FAILURE (Status))
734 {
735 return;
736 }
737
738 EntryOffset += 8;
739 EntryLength = HidSubtable->UidLength;
740
741 if (EntryLength > ACPI_IVRS_UID_NOT_PRESENT)
742 {
743 /* Dump the UID based upon the UidType field (String or Integer) */
744
745 if (HidSubtable->UidType == ACPI_IVRS_UID_IS_STRING)
746 {
747 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
748 &HidSubtable->UidType, EntryLength, AcpiDmTableInfoIvrsUidString);
749 if (ACPI_FAILURE (Status))
750 {
751 return;
752 }
753 }
754 else /* ACPI_IVRS_UID_IS_INTEGER */
755 {
756 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
757 &HidSubtable->UidType, EntryLength, AcpiDmTableInfoIvrsUidInteger);
758 if (ACPI_FAILURE (Status))
759 {
760 return;
761 }
762 }
763 }
764
765 EntryOffset += EntryLength+2;
766 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER,
767 Table, EntryOffset);
768 }
769 }
770 }
771
772 NextSubtable:
773 /* Point to next subtable */
774
775 Offset += Subtable->Length;
776 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, Subtable->Length);
777 }
778 }
779
780
781 /*******************************************************************************
782 *
783 * FUNCTION: AcpiDmDumpLpit
784 *
785 * PARAMETERS: Table - A LPIT table
786 *
787 * RETURN: None
788 *
789 * DESCRIPTION: Format the contents of a LPIT. This table type consists
790 * of an open-ended number of subtables. Note: There are no
791 * entries in the main table. An LPIT consists of the table
792 * header and then subtables only.
793 *
794 ******************************************************************************/
795
796 void
AcpiDmDumpLpit(ACPI_TABLE_HEADER * Table)797 AcpiDmDumpLpit (
798 ACPI_TABLE_HEADER *Table)
799 {
800 ACPI_STATUS Status;
801 ACPI_LPIT_HEADER *Subtable;
802 UINT32 Length = Table->Length;
803 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
804 ACPI_DMTABLE_INFO *InfoTable;
805 UINT32 SubtableLength;
806
807
808 /* Subtables */
809
810 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
811 while (Offset < Table->Length)
812 {
813 /* Common subtable header */
814
815 Status = AcpiDmDumpTable (Length, Offset, Subtable,
816 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
817 if (ACPI_FAILURE (Status))
818 {
819 return;
820 }
821
822 switch (Subtable->Type)
823 {
824 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
825
826 InfoTable = AcpiDmTableInfoLpit0;
827 SubtableLength = sizeof (ACPI_LPIT_NATIVE);
828 break;
829
830 default:
831
832 /* Cannot continue on unknown type - no length */
833
834 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
835 Subtable->Type);
836 return;
837 }
838
839 Status = AcpiDmDumpTable (Length, Offset, Subtable,
840 SubtableLength, InfoTable);
841 if (ACPI_FAILURE (Status))
842 {
843 return;
844 }
845
846 AcpiOsPrintf ("\n");
847
848 /* Point to next subtable */
849
850 Offset += SubtableLength;
851 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength);
852 }
853 }
854
855
856 /*******************************************************************************
857 *
858 * FUNCTION: AcpiDmDumpMadt
859 *
860 * PARAMETERS: Table - A MADT table
861 *
862 * RETURN: None
863 *
864 * DESCRIPTION: Format the contents of a MADT. This table type consists
865 * of an open-ended number of subtables.
866 *
867 ******************************************************************************/
868
869 void
AcpiDmDumpMadt(ACPI_TABLE_HEADER * Table)870 AcpiDmDumpMadt (
871 ACPI_TABLE_HEADER *Table)
872 {
873 ACPI_STATUS Status;
874 ACPI_SUBTABLE_HEADER *Subtable;
875 UINT32 Length = Table->Length;
876 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
877 ACPI_DMTABLE_INFO *InfoTable;
878 UINT8 Revision;
879
880
881 /* Main table */
882
883 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
884 if (ACPI_FAILURE (Status))
885 {
886 return;
887 }
888
889 Revision = Table->Revision;
890
891 /* Subtables */
892
893 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
894 DbgPrint (ASL_PARSE_OUTPUT, "//0B) Offset %X, from table start: 0x%8.8X%8.8X\n",
895 Offset, ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table)));
896 while (Offset < Table->Length)
897 {
898 /* Common subtable header */
899
900 AcpiOsPrintf ("\n");
901 Status = AcpiDmDumpTable (Length, Offset, Subtable,
902 Subtable->Length, AcpiDmTableInfoMadtHdr);
903 if (ACPI_FAILURE (Status))
904 {
905 return;
906 }
907
908 DbgPrint (ASL_PARSE_OUTPUT, "subtableType: %X\n", Subtable->Type);
909 switch (Subtable->Type)
910 {
911 case ACPI_MADT_TYPE_LOCAL_APIC:
912
913 InfoTable = AcpiDmTableInfoMadt0;
914 break;
915
916 case ACPI_MADT_TYPE_IO_APIC:
917
918 InfoTable = AcpiDmTableInfoMadt1;
919 break;
920
921 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
922
923 InfoTable = AcpiDmTableInfoMadt2;
924 break;
925
926 case ACPI_MADT_TYPE_NMI_SOURCE:
927
928 InfoTable = AcpiDmTableInfoMadt3;
929 break;
930
931 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
932
933 InfoTable = AcpiDmTableInfoMadt4;
934 break;
935
936 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
937
938 InfoTable = AcpiDmTableInfoMadt5;
939 break;
940
941 case ACPI_MADT_TYPE_IO_SAPIC:
942
943 InfoTable = AcpiDmTableInfoMadt6;
944 break;
945
946 case ACPI_MADT_TYPE_LOCAL_SAPIC:
947
948 InfoTable = AcpiDmTableInfoMadt7;
949 break;
950
951 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
952
953 InfoTable = AcpiDmTableInfoMadt8;
954 break;
955
956 case ACPI_MADT_TYPE_LOCAL_X2APIC:
957
958 InfoTable = AcpiDmTableInfoMadt9;
959 break;
960
961 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
962
963 InfoTable = AcpiDmTableInfoMadt10;
964 break;
965
966 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
967
968 if (Revision > 6)
969 InfoTable = AcpiDmTableInfoMadt11b;
970 else if (Revision == 6)
971 InfoTable = AcpiDmTableInfoMadt11a;
972 else
973 InfoTable = AcpiDmTableInfoMadt11;
974 break;
975
976 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
977
978 InfoTable = AcpiDmTableInfoMadt12;
979 break;
980
981 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
982
983 InfoTable = AcpiDmTableInfoMadt13;
984 break;
985
986 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
987
988 InfoTable = Revision > 6 ? AcpiDmTableInfoMadt14a :
989 AcpiDmTableInfoMadt14;
990 break;
991
992 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
993
994 InfoTable = Revision > 6 ? AcpiDmTableInfoMadt15a :
995 AcpiDmTableInfoMadt15;
996 break;
997
998 case ACPI_MADT_TYPE_MULTIPROC_WAKEUP:
999
1000 InfoTable = AcpiDmTableInfoMadt16;
1001 break;
1002
1003 case ACPI_MADT_TYPE_CORE_PIC:
1004
1005 InfoTable = AcpiDmTableInfoMadt17;
1006 break;
1007
1008 case ACPI_MADT_TYPE_LIO_PIC:
1009
1010 InfoTable = AcpiDmTableInfoMadt18;
1011 break;
1012
1013 case ACPI_MADT_TYPE_HT_PIC:
1014
1015 InfoTable = AcpiDmTableInfoMadt19;
1016 break;
1017
1018 case ACPI_MADT_TYPE_EIO_PIC:
1019
1020 InfoTable = AcpiDmTableInfoMadt20;
1021 break;
1022
1023 case ACPI_MADT_TYPE_MSI_PIC:
1024
1025 InfoTable = AcpiDmTableInfoMadt21;
1026 break;
1027
1028 case ACPI_MADT_TYPE_BIO_PIC:
1029
1030 InfoTable = AcpiDmTableInfoMadt22;
1031 break;
1032
1033 case ACPI_MADT_TYPE_LPC_PIC:
1034
1035 InfoTable = AcpiDmTableInfoMadt23;
1036 break;
1037
1038 case ACPI_MADT_TYPE_RINTC:
1039
1040 InfoTable = AcpiDmTableInfoMadt24;
1041 break;
1042
1043 case ACPI_MADT_TYPE_IMSIC:
1044
1045 InfoTable = AcpiDmTableInfoMadt25;
1046 break;
1047
1048 case ACPI_MADT_TYPE_APLIC:
1049
1050 InfoTable = AcpiDmTableInfoMadt26;
1051 break;
1052
1053 case ACPI_MADT_TYPE_PLIC:
1054
1055 InfoTable = AcpiDmTableInfoMadt27;
1056 break;
1057
1058 default:
1059
1060 if ((Subtable->Type >= ACPI_MADT_TYPE_RESERVED) &&
1061 (Subtable->Type < ACPI_MADT_TYPE_OEM_RESERVED))
1062 {
1063 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
1064 Subtable->Type);
1065 goto NextSubtable;
1066 }
1067 else if (Subtable->Type >= ACPI_MADT_TYPE_OEM_RESERVED)
1068 {
1069 DbgPrint (ASL_PARSE_OUTPUT, "//[Found an OEM structure, type = %0x]\n",
1070 Subtable->Type);
1071 Offset += sizeof (ACPI_SUBTABLE_HEADER);
1072 DbgPrint (ASL_PARSE_OUTPUT, "//[0) Subtable->Length = %X, Subtable = %p, Offset = %X]\n",
1073 Subtable->Length, Subtable, Offset);
1074 DbgPrint (ASL_PARSE_OUTPUT, "//[0A) Offset from table start: 0x%8.8X%8.8X]\n",
1075 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table)));
1076 }
1077
1078 /* Attempt to continue */
1079
1080 if (!Subtable->Length)
1081 {
1082 AcpiOsPrintf ("Invalid zero length subtable\n");
1083 return;
1084 }
1085
1086 /* Dump the OEM data */
1087
1088 Status = AcpiDmDumpTable (Length, Offset, ACPI_CAST_PTR (UINT8, Table) + Offset,
1089 Subtable->Length - sizeof (ACPI_SUBTABLE_HEADER), AcpiDmTableInfoMadt128);
1090 if (ACPI_FAILURE (Status))
1091 {
1092 return;
1093 }
1094
1095 DbgPrint (ASL_PARSE_OUTPUT, "//[1) Subtable->Length = %X, Offset = %X]\n",
1096 Subtable->Length, Offset);
1097 Offset -= sizeof (ACPI_SUBTABLE_HEADER);
1098
1099 goto NextSubtable;
1100 }
1101
1102 DbgPrint (ASL_PARSE_OUTPUT, "//[2) Subtable->Length = %X, Offset = %X]\n",
1103 Subtable->Length, Offset);
1104 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1105 Subtable->Length, InfoTable);
1106 if (ACPI_FAILURE (Status))
1107 {
1108 return;
1109 }
1110
1111 NextSubtable:
1112 /* Point to next subtable */
1113
1114 DbgPrint (ASL_PARSE_OUTPUT, "//[3) Subtable->Length = %X, Offset = %X]\n",
1115 Subtable->Length, Offset);
1116 DbgPrint (ASL_PARSE_OUTPUT, "//[4) Offset from table start: 0x%8.8X%8.8X (%p) %p]\n",
1117 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (UINT8, Subtable) - ACPI_CAST_PTR (UINT8, Table)), Subtable, Table);
1118 if (Offset > Table->Length)
1119 {
1120 return;
1121 }
1122
1123 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable,
1124 Subtable->Length);
1125
1126 Offset = ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table);
1127 if (Offset >= Table->Length)
1128 {
1129 return;
1130 }
1131
1132 DbgPrint (ASL_PARSE_OUTPUT, "//[5) Next Subtable %p, length %X]\n",
1133 Subtable, Subtable->Length);
1134 DbgPrint (ASL_PARSE_OUTPUT, "//[5B) Offset from table start: 0x%8.8X%8.8X (%p)]\n",
1135 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table)), Subtable);
1136 }
1137 }
1138
1139
1140 /*******************************************************************************
1141 *
1142 * FUNCTION: AcpiDmDumpMcfg
1143 *
1144 * PARAMETERS: Table - A MCFG Table
1145 *
1146 * RETURN: None
1147 *
1148 * DESCRIPTION: Format the contents of a MCFG table
1149 *
1150 ******************************************************************************/
1151
1152 void
AcpiDmDumpMcfg(ACPI_TABLE_HEADER * Table)1153 AcpiDmDumpMcfg (
1154 ACPI_TABLE_HEADER *Table)
1155 {
1156 ACPI_STATUS Status;
1157 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
1158 ACPI_MCFG_ALLOCATION *Subtable;
1159
1160
1161 /* Main table */
1162
1163 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1164 if (ACPI_FAILURE (Status))
1165 {
1166 return;
1167 }
1168
1169 /* Subtables */
1170
1171 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1172 while (Offset < Table->Length)
1173 {
1174 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1175 {
1176 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1177 (UINT32) sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1178 return;
1179 }
1180
1181 AcpiOsPrintf ("\n");
1182 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1183 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1184 if (ACPI_FAILURE (Status))
1185 {
1186 return;
1187 }
1188
1189 /* Point to next subtable (each subtable is of fixed length) */
1190
1191 Offset += sizeof (ACPI_MCFG_ALLOCATION);
1192 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable,
1193 sizeof (ACPI_MCFG_ALLOCATION));
1194 }
1195 }
1196
1197 /*******************************************************************************
1198 *
1199 * FUNCTION: AcpiDmDumpMpam
1200 *
1201 * PARAMETERS: Table - A MPAM table
1202 *
1203 * RETURN: None
1204 *
1205 * DESCRIPTION: Format the contents of a MPAM table
1206 *
1207 ******************************************************************************/
1208
1209 void
AcpiDmDumpMpam(ACPI_TABLE_HEADER * Table)1210 AcpiDmDumpMpam (
1211 ACPI_TABLE_HEADER *Table)
1212 {
1213 ACPI_STATUS Status;
1214 ACPI_MPAM_MSC_NODE *MpamMscNode;
1215 ACPI_MPAM_RESOURCE_NODE *MpamResourceNode;
1216 ACPI_MPAM_FUNC_DEPS *MpamFunctionalDependency;
1217 ACPI_DMTABLE_INFO *InfoTable;
1218 UINT32 Offset = sizeof(ACPI_TABLE_HEADER);
1219 UINT32 TempOffset;
1220 UINT32 MpamResourceNodeLength = 0;
1221
1222 while (Offset < Table->Length)
1223 {
1224 MpamMscNode = ACPI_ADD_PTR (ACPI_MPAM_MSC_NODE, Table, Offset);
1225
1226 /* Subtable: MSC */
1227 Status = AcpiDmDumpTable (Table->Length, Offset, MpamMscNode,
1228 MpamMscNode->Length, AcpiDmTableInfoMpam0);
1229 if (ACPI_FAILURE (Status))
1230 {
1231 return;
1232 }
1233
1234 /* Offset the start of the array of resources */
1235 Offset += sizeof(ACPI_MPAM_MSC_NODE);
1236
1237 /* Subtable: MSC RIS(es) */
1238 for (UINT32 ResourceIdx = 0; ResourceIdx < MpamMscNode->NumResourceNodes; ResourceIdx++)
1239 {
1240 AcpiOsPrintf ("\n");
1241 MpamResourceNode = ACPI_ADD_PTR (ACPI_MPAM_RESOURCE_NODE, Table, Offset);
1242
1243 MpamResourceNodeLength = sizeof(ACPI_MPAM_RESOURCE_NODE) +
1244 MpamResourceNode->NumFunctionalDeps * sizeof(ACPI_MPAM_FUNC_DEPS);
1245 TempOffset = Offset;
1246 Offset += MpamResourceNodeLength;
1247
1248 /* Subtable: MSC RIS */
1249 Status = AcpiDmDumpTable (Table->Length, TempOffset, MpamResourceNode,
1250 sizeof(ACPI_MPAM_RESOURCE_NODE), AcpiDmTableInfoMpam1);
1251 if (ACPI_FAILURE (Status))
1252 {
1253 return;
1254 }
1255
1256 switch (MpamResourceNode->LocatorType)
1257 {
1258 case ACPI_MPAM_LOCATION_TYPE_PROCESSOR_CACHE:
1259 InfoTable = AcpiDmTableInfoMpam1A;
1260 break;
1261 case ACPI_MPAM_LOCATION_TYPE_MEMORY:
1262 InfoTable = AcpiDmTableInfoMpam1B;
1263 break;
1264 case ACPI_MPAM_LOCATION_TYPE_SMMU:
1265 InfoTable = AcpiDmTableInfoMpam1C;
1266 break;
1267 case ACPI_MPAM_LOCATION_TYPE_MEMORY_CACHE:
1268 InfoTable = AcpiDmTableInfoMpam1D;
1269 break;
1270 case ACPI_MPAM_LOCATION_TYPE_ACPI_DEVICE:
1271 InfoTable = AcpiDmTableInfoMpam1E;
1272 break;
1273 case ACPI_MPAM_LOCATION_TYPE_INTERCONNECT:
1274 InfoTable = AcpiDmTableInfoMpam1F;
1275 break;
1276 case ACPI_MPAM_LOCATION_TYPE_UNKNOWN:
1277 InfoTable = AcpiDmTableInfoMpam1G;
1278 default:
1279 AcpiOsPrintf ("\n**** Unknown MPAM locator type 0x%X\n",
1280 MpamResourceNode->LocatorType);
1281 return;
1282 }
1283
1284 /* Subtable: MSC Resource Locator(s) */
1285 TempOffset += ACPI_OFFSET(ACPI_MPAM_RESOURCE_NODE, Locator);
1286 Status = AcpiDmDumpTable (Table->Length, TempOffset, &MpamResourceNode->Locator,
1287 sizeof(ACPI_MPAM_RESOURCE_LOCATOR), InfoTable);
1288 if (ACPI_FAILURE (Status))
1289 {
1290 return;
1291 }
1292
1293 /* Get the number of functional dependencies of an RIS */
1294 TempOffset += sizeof(ACPI_MPAM_RESOURCE_LOCATOR);
1295 Status = AcpiDmDumpTable (Table->Length, TempOffset, &MpamResourceNode->NumFunctionalDeps,
1296 sizeof(UINT32), AcpiDmTableInfoMpam1Deps);
1297 if (ACPI_FAILURE (Status))
1298 {
1299 return;
1300 }
1301
1302 TempOffset += sizeof(UINT32);
1303 MpamFunctionalDependency = ACPI_ADD_PTR (ACPI_MPAM_FUNC_DEPS, MpamResourceNode,
1304 sizeof(ACPI_MPAM_RESOURCE_NODE));
1305 /* Subtable: MSC functional dependencies */
1306 for (UINT32 funcDep = 0; funcDep < MpamResourceNode->NumFunctionalDeps; funcDep++)
1307 {
1308 AcpiOsPrintf ("\n");
1309 Status = AcpiDmDumpTable (sizeof(ACPI_MPAM_FUNC_DEPS), 0,
1310 &MpamResourceNode->NumFunctionalDeps, 0, AcpiDmTableInfoMpam2);
1311 Status = AcpiDmDumpTable (Table->Length, TempOffset, MpamFunctionalDependency,
1312 sizeof(ACPI_MPAM_FUNC_DEPS), AcpiDmTableInfoMpam2);
1313 if (ACPI_FAILURE (Status))
1314 {
1315 return;
1316 }
1317 TempOffset += sizeof(ACPI_MPAM_FUNC_DEPS);
1318 MpamFunctionalDependency++;
1319 }
1320
1321 AcpiOsPrintf ("\n\n");
1322 }
1323
1324 }
1325
1326 return;
1327 }
1328
1329 /*******************************************************************************
1330 *
1331 * FUNCTION: AcpiDmDumpMpst
1332 *
1333 * PARAMETERS: Table - A MPST Table
1334 *
1335 * RETURN: None
1336 *
1337 * DESCRIPTION: Format the contents of a MPST table
1338 *
1339 ******************************************************************************/
1340
1341 void
AcpiDmDumpMpst(ACPI_TABLE_HEADER * Table)1342 AcpiDmDumpMpst (
1343 ACPI_TABLE_HEADER *Table)
1344 {
1345 ACPI_STATUS Status;
1346 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
1347 ACPI_MPST_POWER_NODE *Subtable0;
1348 ACPI_MPST_POWER_STATE *Subtable0A;
1349 ACPI_MPST_COMPONENT *Subtable0B;
1350 ACPI_MPST_DATA_HDR *Subtable1;
1351 ACPI_MPST_POWER_DATA *Subtable2;
1352 UINT16 SubtableCount;
1353 UINT32 PowerStateCount;
1354 UINT32 ComponentCount;
1355
1356
1357 /* Main table */
1358
1359 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
1360 if (ACPI_FAILURE (Status))
1361 {
1362 return;
1363 }
1364
1365 /* Subtable: Memory Power Node(s) */
1366
1367 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
1368 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
1369
1370 while ((Offset < Table->Length) && SubtableCount)
1371 {
1372 AcpiOsPrintf ("\n");
1373 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0,
1374 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
1375 if (ACPI_FAILURE (Status))
1376 {
1377 return;
1378 }
1379
1380 /* Extract the sub-subtable counts */
1381
1382 PowerStateCount = Subtable0->NumPowerStates;
1383 ComponentCount = Subtable0->NumPhysicalComponents;
1384 Offset += sizeof (ACPI_MPST_POWER_NODE);
1385
1386 /* Sub-subtables - Memory Power State Structure(s) */
1387
1388 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0,
1389 sizeof (ACPI_MPST_POWER_NODE));
1390
1391 while (PowerStateCount)
1392 {
1393 AcpiOsPrintf ("\n");
1394 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A,
1395 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
1396 if (ACPI_FAILURE (Status))
1397 {
1398 return;
1399 }
1400
1401 Subtable0A++;
1402 PowerStateCount--;
1403 Offset += sizeof (ACPI_MPST_POWER_STATE);
1404 }
1405
1406 /* Sub-subtables - Physical Component ID Structure(s) */
1407
1408 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A);
1409
1410 if (ComponentCount)
1411 {
1412 AcpiOsPrintf ("\n");
1413 }
1414
1415 while (ComponentCount)
1416 {
1417 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B,
1418 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
1419 if (ACPI_FAILURE (Status))
1420 {
1421 return;
1422 }
1423
1424 Subtable0B++;
1425 ComponentCount--;
1426 Offset += sizeof (ACPI_MPST_COMPONENT);
1427 }
1428
1429 /* Point to next Memory Power Node subtable */
1430
1431 SubtableCount--;
1432 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0,
1433 sizeof (ACPI_MPST_POWER_NODE) +
1434 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) +
1435 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents));
1436 }
1437
1438 /* Subtable: Count of Memory Power State Characteristic structures */
1439
1440 AcpiOsPrintf ("\n");
1441 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0);
1442 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1,
1443 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1444 if (ACPI_FAILURE (Status))
1445 {
1446 return;
1447 }
1448
1449 SubtableCount = Subtable1->CharacteristicsCount;
1450 Offset += sizeof (ACPI_MPST_DATA_HDR);
1451
1452 /* Subtable: Memory Power State Characteristics structure(s) */
1453
1454 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1,
1455 sizeof (ACPI_MPST_DATA_HDR));
1456
1457 while ((Offset < Table->Length) && SubtableCount)
1458 {
1459 AcpiOsPrintf ("\n");
1460 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2,
1461 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1462 if (ACPI_FAILURE (Status))
1463 {
1464 return;
1465 }
1466
1467 Subtable2++;
1468 SubtableCount--;
1469 Offset += sizeof (ACPI_MPST_POWER_DATA);
1470 }
1471 }
1472
1473
1474 /*******************************************************************************
1475 *
1476 * FUNCTION: AcpiDmDumpMrrm
1477 *
1478 * PARAMETERS: Table - A MRRM table
1479 *
1480 * RETURN: None
1481 *
1482 * DESCRIPTION: Format the contents of a MRRM
1483 *
1484 ******************************************************************************/
1485
1486 void
AcpiDmDumpMrrm(ACPI_TABLE_HEADER * Table)1487 AcpiDmDumpMrrm (
1488 ACPI_TABLE_HEADER *Table)
1489 {
1490 ACPI_STATUS Status;
1491 ACPI_MRRM_MEM_RANGE_ENTRY *Subtable;
1492 UINT16 Offset = sizeof (ACPI_TABLE_MRRM);
1493
1494 /* Main table */
1495
1496 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMrrm);
1497 if (ACPI_FAILURE (Status))
1498 {
1499 return;
1500 }
1501
1502 /* Subtables (all are same type) */
1503
1504 Subtable = ACPI_ADD_PTR (ACPI_MRRM_MEM_RANGE_ENTRY, Table, Offset);
1505 while (Offset < Table->Length)
1506 {
1507 AcpiOsPrintf ("\n");
1508 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1509 Subtable->Header.Length, AcpiDmTableInfoMrrm0);
1510 if (ACPI_FAILURE (Status))
1511 {
1512 return;
1513 }
1514
1515 Offset += Subtable->Header.Length;
1516 Subtable = ACPI_ADD_PTR (ACPI_MRRM_MEM_RANGE_ENTRY, Subtable,
1517 Subtable->Header.Length);
1518 }
1519 }
1520
1521
1522 /*******************************************************************************
1523 *
1524 * FUNCTION: AcpiDmDumpMsct
1525 *
1526 * PARAMETERS: Table - A MSCT table
1527 *
1528 * RETURN: None
1529 *
1530 * DESCRIPTION: Format the contents of a MSCT
1531 *
1532 ******************************************************************************/
1533
1534 void
AcpiDmDumpMsct(ACPI_TABLE_HEADER * Table)1535 AcpiDmDumpMsct (
1536 ACPI_TABLE_HEADER *Table)
1537 {
1538 ACPI_STATUS Status;
1539 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1540 ACPI_MSCT_PROXIMITY *Subtable;
1541
1542
1543 /* Main table */
1544
1545 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1546 if (ACPI_FAILURE (Status))
1547 {
1548 return;
1549 }
1550
1551 /* Subtables */
1552
1553 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1554 while (Offset < Table->Length)
1555 {
1556 /* Common subtable header */
1557
1558 AcpiOsPrintf ("\n");
1559 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1560 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1561 if (ACPI_FAILURE (Status))
1562 {
1563 return;
1564 }
1565
1566 /* Point to next subtable */
1567
1568 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1569 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable,
1570 sizeof (ACPI_MSCT_PROXIMITY));
1571 }
1572 }
1573
1574
1575 /*******************************************************************************
1576 *
1577 * FUNCTION: AcpiDmDumpNfit
1578 *
1579 * PARAMETERS: Table - A NFIT table
1580 *
1581 * RETURN: None
1582 *
1583 * DESCRIPTION: Format the contents of an NFIT.
1584 *
1585 ******************************************************************************/
1586
1587 void
AcpiDmDumpNfit(ACPI_TABLE_HEADER * Table)1588 AcpiDmDumpNfit (
1589 ACPI_TABLE_HEADER *Table)
1590 {
1591 ACPI_STATUS Status;
1592 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
1593 UINT32 FieldOffset = 0;
1594 UINT32 Length;
1595 ACPI_NFIT_HEADER *Subtable;
1596 ACPI_DMTABLE_INFO *InfoTable;
1597 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
1598 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
1599 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
1600 UINT32 i;
1601
1602
1603 /* Main table */
1604
1605 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
1606 if (ACPI_FAILURE (Status))
1607 {
1608 return;
1609 }
1610
1611 /* Subtables */
1612
1613 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
1614 while (Offset < Table->Length)
1615 {
1616 /* NFIT subtable header */
1617
1618 AcpiOsPrintf ("\n");
1619 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1620 Subtable->Length, AcpiDmTableInfoNfitHdr);
1621 if (ACPI_FAILURE (Status))
1622 {
1623 return;
1624 }
1625
1626 switch (Subtable->Type)
1627 {
1628 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1629
1630 InfoTable = AcpiDmTableInfoNfit0;
1631 break;
1632
1633 case ACPI_NFIT_TYPE_MEMORY_MAP:
1634
1635 InfoTable = AcpiDmTableInfoNfit1;
1636 break;
1637
1638 case ACPI_NFIT_TYPE_INTERLEAVE:
1639
1640 /* Has a variable number of 32-bit values at the end */
1641
1642 InfoTable = AcpiDmTableInfoNfit2;
1643 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
1644 break;
1645
1646 case ACPI_NFIT_TYPE_SMBIOS:
1647
1648 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable);
1649 InfoTable = AcpiDmTableInfoNfit3;
1650 break;
1651
1652 case ACPI_NFIT_TYPE_CONTROL_REGION:
1653
1654 InfoTable = AcpiDmTableInfoNfit4;
1655 break;
1656
1657 case ACPI_NFIT_TYPE_DATA_REGION:
1658
1659 InfoTable = AcpiDmTableInfoNfit5;
1660 break;
1661
1662 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1663
1664 /* Has a variable number of 64-bit addresses at the end */
1665
1666 InfoTable = AcpiDmTableInfoNfit6;
1667 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS);
1668 break;
1669
1670 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */
1671
1672 InfoTable = AcpiDmTableInfoNfit7;
1673 break;
1674
1675 default:
1676 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
1677 Subtable->Type);
1678
1679 /* Attempt to continue */
1680
1681 if (!Subtable->Length)
1682 {
1683 AcpiOsPrintf ("Invalid zero length subtable\n");
1684 return;
1685 }
1686 goto NextSubtable;
1687 }
1688
1689 AcpiOsPrintf ("\n");
1690 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1691 Subtable->Length, InfoTable);
1692 if (ACPI_FAILURE (Status))
1693 {
1694 return;
1695 }
1696
1697 /* Per-subtable variable-length fields */
1698
1699 switch (Subtable->Type)
1700 {
1701 case ACPI_NFIT_TYPE_INTERLEAVE:
1702
1703 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable);
1704 for (i = 0; i < Interleave->LineCount; i++)
1705 {
1706 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1707 &Interleave->LineOffset[i],
1708 sizeof (UINT32), AcpiDmTableInfoNfit2a);
1709 if (ACPI_FAILURE (Status))
1710 {
1711 return;
1712 }
1713
1714 FieldOffset += sizeof (UINT32);
1715 }
1716 break;
1717
1718 case ACPI_NFIT_TYPE_SMBIOS:
1719
1720 Length = Subtable->Length -
1721 sizeof (ACPI_NFIT_SMBIOS);
1722
1723 if (Length)
1724 {
1725 Status = AcpiDmDumpTable (Table->Length,
1726 sizeof (ACPI_NFIT_SMBIOS),
1727 SmbiosInfo,
1728 Length, AcpiDmTableInfoNfit3a);
1729 if (ACPI_FAILURE (Status))
1730 {
1731 return;
1732 }
1733 }
1734
1735 break;
1736
1737 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1738
1739 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable);
1740 for (i = 0; i < Hint->HintCount; i++)
1741 {
1742 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1743 &Hint->HintAddress[i],
1744 sizeof (UINT64), AcpiDmTableInfoNfit6a);
1745 if (ACPI_FAILURE (Status))
1746 {
1747 return;
1748 }
1749
1750 FieldOffset += sizeof (UINT64);
1751 }
1752 break;
1753
1754 default:
1755 break;
1756 }
1757
1758 NextSubtable:
1759 /* Point to next subtable */
1760
1761 Offset += Subtable->Length;
1762 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length);
1763 }
1764 }
1765
1766
1767 /*******************************************************************************
1768 *
1769 * FUNCTION: AcpiDmDumpPcct
1770 *
1771 * PARAMETERS: Table - A PCCT table
1772 *
1773 * RETURN: None
1774 *
1775 * DESCRIPTION: Format the contents of a PCCT. This table type consists
1776 * of an open-ended number of subtables.
1777 *
1778 ******************************************************************************/
1779
1780 void
AcpiDmDumpPcct(ACPI_TABLE_HEADER * Table)1781 AcpiDmDumpPcct (
1782 ACPI_TABLE_HEADER *Table)
1783 {
1784 ACPI_STATUS Status;
1785 ACPI_PCCT_SUBSPACE *Subtable;
1786 ACPI_DMTABLE_INFO *InfoTable;
1787 UINT32 Length = Table->Length;
1788 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
1789
1790
1791 /* Main table */
1792
1793 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1794 if (ACPI_FAILURE (Status))
1795 {
1796 return;
1797 }
1798
1799 /* Subtables */
1800
1801 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1802 while (Offset < Table->Length)
1803 {
1804 /* Common subtable header */
1805
1806 AcpiOsPrintf ("\n");
1807 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1808 Subtable->Header.Length, AcpiDmTableInfoPcctHdr);
1809 if (ACPI_FAILURE (Status))
1810 {
1811 return;
1812 }
1813
1814 switch (Subtable->Header.Type)
1815 {
1816 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
1817
1818 InfoTable = AcpiDmTableInfoPcct0;
1819 break;
1820
1821 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
1822
1823 InfoTable = AcpiDmTableInfoPcct1;
1824 break;
1825
1826 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
1827
1828 InfoTable = AcpiDmTableInfoPcct2;
1829 break;
1830
1831 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
1832
1833 InfoTable = AcpiDmTableInfoPcct3;
1834 break;
1835
1836 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
1837
1838 InfoTable = AcpiDmTableInfoPcct4;
1839 break;
1840
1841 case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE:
1842
1843 InfoTable = AcpiDmTableInfoPcct5;
1844 break;
1845
1846 default:
1847
1848 AcpiOsPrintf (
1849 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
1850 Subtable->Header.Type);
1851 return;
1852 }
1853
1854 AcpiOsPrintf ("\n");
1855 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1856 Subtable->Header.Length, InfoTable);
1857 if (ACPI_FAILURE (Status))
1858 {
1859 return;
1860 }
1861
1862 /* Point to next subtable */
1863
1864 Offset += Subtable->Header.Length;
1865 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable,
1866 Subtable->Header.Length);
1867 }
1868 }
1869
1870
1871 /*******************************************************************************
1872 *
1873 * FUNCTION: AcpiDmDumpPdtt
1874 *
1875 * PARAMETERS: Table - A PDTT table
1876 *
1877 * RETURN: None
1878 *
1879 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length
1880 * table that contains an open-ended number of IDs
1881 * at the end of the table.
1882 *
1883 ******************************************************************************/
1884
1885 void
AcpiDmDumpPdtt(ACPI_TABLE_HEADER * Table)1886 AcpiDmDumpPdtt (
1887 ACPI_TABLE_HEADER *Table)
1888 {
1889 ACPI_STATUS Status;
1890 ACPI_PDTT_CHANNEL *Subtable;
1891 UINT32 Length = Table->Length;
1892 UINT32 Offset = sizeof (ACPI_TABLE_PDTT);
1893
1894
1895 /* Main table */
1896
1897 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt);
1898 if (ACPI_FAILURE (Status))
1899 {
1900 return;
1901 }
1902
1903 /* Subtables. Currently there is only one type, but can be multiples */
1904
1905 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset);
1906 while (Offset < Table->Length)
1907 {
1908 AcpiOsPrintf ("\n");
1909 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1910 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0);
1911 if (ACPI_FAILURE (Status))
1912 {
1913 return;
1914 }
1915
1916 /* Point to next subtable */
1917
1918 Offset += sizeof (ACPI_PDTT_CHANNEL);
1919 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable,
1920 sizeof (ACPI_PDTT_CHANNEL));
1921 }
1922 }
1923
1924
1925 /*******************************************************************************
1926 *
1927 * FUNCTION: AcpiDmDumpPhat
1928 *
1929 * PARAMETERS: Table - A PHAT table
1930 *
1931 * RETURN: None
1932 *
1933 * DESCRIPTION: Format the contents of a PHAT.
1934 *
1935 ******************************************************************************/
1936
1937 void
AcpiDmDumpPhat(ACPI_TABLE_HEADER * Table)1938 AcpiDmDumpPhat (
1939 ACPI_TABLE_HEADER *Table)
1940 {
1941 ACPI_STATUS Status;
1942 ACPI_DMTABLE_INFO *InfoTable;
1943 ACPI_PHAT_HEADER *Subtable;
1944 ACPI_PHAT_VERSION_DATA *VersionData;
1945 ACPI_PHAT_HEALTH_DATA *HealthData;
1946 UINT32 RecordCount;
1947 UINT32 Length = Table->Length;
1948 UINT32 Offset = sizeof (ACPI_TABLE_PHAT);
1949 UINT32 OriginalOffset;
1950 UINT32 SubtableLength;
1951 UINT32 PathLength;
1952 UINT32 VendorLength;
1953 UINT16 RecordType;
1954
1955
1956 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, sizeof (ACPI_TABLE_PHAT));
1957
1958 while (Offset < Table->Length)
1959 {
1960 /* Common subtable header */
1961
1962 AcpiOsPrintf ("\n");
1963 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1964 sizeof (ACPI_PHAT_HEADER), AcpiDmTableInfoPhatHdr);
1965 if (ACPI_FAILURE (Status))
1966 {
1967 return;
1968 }
1969
1970 DbgPrint (ASL_DEBUG_OUTPUT, "\n/* %u, Subtable->Type %X */\n",
1971 __LINE__, Subtable->Type);
1972
1973 switch (Subtable->Type)
1974 {
1975 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
1976
1977 InfoTable = AcpiDmTableInfoPhat0;
1978 SubtableLength = sizeof (ACPI_PHAT_VERSION_DATA);
1979 break;
1980
1981 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
1982
1983 InfoTable = AcpiDmTableInfoPhat1;
1984 SubtableLength = sizeof (ACPI_PHAT_HEALTH_DATA);
1985 break;
1986
1987 default:
1988
1989 DbgPrint (ASL_DEBUG_OUTPUT, "\n**** Unknown PHAT subtable type 0x%X\n\n",
1990 Subtable->Type);
1991
1992 return;
1993 }
1994
1995 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1996 SubtableLength, InfoTable);
1997 if (ACPI_FAILURE (Status))
1998 {
1999 return;
2000 }
2001
2002 Offset += SubtableLength;
2003
2004 OriginalOffset = Offset;
2005 switch (Subtable->Type)
2006 {
2007 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
2008
2009 VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, Subtable);
2010 RecordCount = VersionData->ElementCount;
2011 RecordType = *ACPI_CAST_PTR (UINT8, Subtable);
2012
2013 /*
2014 * Skip past a zero-valued block (not part of the ACPI PHAT specification).
2015 * First, check for a zero length record and a zero element count
2016 */
2017 if (!VersionData->Header.Length && !VersionData->ElementCount)
2018 {
2019 while (RecordType == 0)
2020 {
2021 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, Offset);
2022 RecordType = *ACPI_CAST_PTR (UINT8, Subtable);
2023 RecordCount = VersionData->ElementCount;
2024 Offset += 1;
2025 }
2026
2027 Offset -= 1;
2028 AcpiOsPrintf ("\n/* Warning: Block of zeros found above starting at Offset %X Length %X */\n"
2029 "/* (not compliant to PHAT specification -- ignoring block) */\n",
2030 OriginalOffset - 12, Offset - OriginalOffset + 12);
2031 }
2032
2033 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, RecordCount: %X, Offset %X, SubtableLength %X */\n",
2034 __LINE__, RecordCount, Offset, SubtableLength);
2035
2036 /* Emit each of the version elements */
2037
2038 while (RecordCount && VersionData->Header.Length)
2039 {
2040 AcpiOsPrintf ("\n/* Version Element #%Xh Offset %Xh */\n\n",
2041 VersionData->ElementCount - RecordCount + 1, Offset);
2042
2043 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, Offset);
2044 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2045 sizeof (ACPI_PHAT_VERSION_ELEMENT), AcpiDmTableInfoPhat0a);
2046 if (ACPI_FAILURE (Status))
2047 {
2048 return;
2049 }
2050
2051 Offset += sizeof (ACPI_PHAT_VERSION_ELEMENT);
2052 RecordCount--;
2053 }
2054
2055 break;
2056
2057 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
2058
2059 HealthData = ACPI_CAST_PTR (ACPI_PHAT_HEALTH_DATA, Subtable);
2060 PathLength = Subtable->Length - sizeof (ACPI_PHAT_HEALTH_DATA);
2061 VendorLength = 0;
2062
2063 /* An offset of 0 should be ignored */
2064 if (HealthData->DeviceSpecificOffset != 0)
2065 {
2066 if (HealthData->DeviceSpecificOffset > Subtable->Length)
2067 {
2068 AcpiOsPrintf ("\n/* Warning: Oversized device-specific data offset %X */\n"
2069 "/* (maximum is %X -- ignoring device-specific data) */\n",
2070 HealthData->DeviceSpecificOffset, Subtable->Length);
2071 }
2072 else if (HealthData->DeviceSpecificOffset < sizeof (ACPI_PHAT_HEALTH_DATA))
2073 {
2074 AcpiOsPrintf ("\n/* Warning: Undersized device-specific data offset %X */\n"
2075 "/* (minimum is %X -- ignoring device-specific data) */\n",
2076 HealthData->DeviceSpecificOffset, (UINT8) sizeof (ACPI_PHAT_HEALTH_DATA));
2077 }
2078 else
2079 {
2080 PathLength = HealthData->DeviceSpecificOffset - sizeof (ACPI_PHAT_HEALTH_DATA);
2081 VendorLength = Subtable->Length - HealthData->DeviceSpecificOffset;
2082 }
2083 }
2084
2085 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, PathLength %X, Offset %X */\n",
2086 __LINE__, PathLength, Offset);
2087
2088 if (PathLength)
2089 {
2090 Status = AcpiDmDumpTable (Length, Offset,
2091 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA)),
2092 PathLength, AcpiDmTableInfoPhat1a);
2093 if (ACPI_FAILURE (Status))
2094 {
2095 return;
2096 }
2097
2098 Offset += PathLength;
2099 }
2100
2101 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, VendorLength %X, Offset %X */\n",
2102 __LINE__, VendorLength, Offset);
2103
2104 if (VendorLength)
2105 {
2106 Status = AcpiDmDumpTable (Length, Offset,
2107 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, HealthData->DeviceSpecificOffset),
2108 VendorLength, AcpiDmTableInfoPhat1b);
2109 if (ACPI_FAILURE (Status))
2110 {
2111 return;
2112 }
2113
2114 Offset += VendorLength;
2115 }
2116
2117 break;
2118
2119 default:
2120
2121 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n",
2122 Subtable->Type);
2123 return;
2124 }
2125
2126 /* Next subtable */
2127
2128 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, Bottom of main loop: Offset %X, "
2129 "Subtable->Length %X, Table->Length %X */\n",
2130 __LINE__, Offset, Subtable->Length, Table->Length);
2131
2132 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table,
2133 Offset);
2134 }
2135 }
2136
2137
2138 /*******************************************************************************
2139 *
2140 * FUNCTION: AcpiDmDumpPmtt
2141 *
2142 * PARAMETERS: Table - A PMTT table
2143 *
2144 * RETURN: None
2145 *
2146 * DESCRIPTION: Format the contents of a PMTT. This table type consists
2147 * of an open-ended number of subtables.
2148 *
2149 ******************************************************************************/
2150
2151 void
AcpiDmDumpPmtt(ACPI_TABLE_HEADER * Table)2152 AcpiDmDumpPmtt (
2153 ACPI_TABLE_HEADER *Table)
2154 {
2155 ACPI_STATUS Status;
2156 ACPI_PMTT_HEADER *Subtable;
2157 UINT32 Length = Table->Length;
2158 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
2159
2160
2161 /* Main table */
2162
2163 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
2164 if (ACPI_FAILURE (Status))
2165 {
2166 return;
2167 }
2168
2169 /* Subtables */
2170
2171 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
2172 while (Offset < Table->Length)
2173 {
2174 /* Each of the types below contain the common subtable header */
2175
2176 AcpiOsPrintf ("\n");
2177 switch (Subtable->Type)
2178 {
2179 case ACPI_PMTT_TYPE_SOCKET:
2180
2181 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2182 Subtable->Length, AcpiDmTableInfoPmtt0);
2183 if (ACPI_FAILURE (Status))
2184 {
2185 return;
2186 }
2187 break;
2188
2189 case ACPI_PMTT_TYPE_CONTROLLER:
2190 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2191 Subtable->Length, AcpiDmTableInfoPmtt1);
2192 if (ACPI_FAILURE (Status))
2193 {
2194 return;
2195 }
2196 break;
2197
2198 case ACPI_PMTT_TYPE_DIMM:
2199 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2200 Subtable->Length, AcpiDmTableInfoPmtt2);
2201 if (ACPI_FAILURE (Status))
2202 {
2203 return;
2204 }
2205 break;
2206
2207 case ACPI_PMTT_TYPE_VENDOR:
2208 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2209 Subtable->Length, AcpiDmTableInfoPmttVendor);
2210 if (ACPI_FAILURE (Status))
2211 {
2212 return;
2213 }
2214 break;
2215
2216 default:
2217 AcpiOsPrintf (
2218 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2219 Subtable->Type);
2220 return;
2221 }
2222
2223 /* Point to next subtable */
2224
2225 Offset += Subtable->Length;
2226 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2227 Subtable, Subtable->Length);
2228 }
2229 }
2230
2231
2232 /*******************************************************************************
2233 *
2234 * FUNCTION: AcpiDmDumpPptt
2235 *
2236 * PARAMETERS: Table - A PMTT table
2237 *
2238 * RETURN: None
2239 *
2240 * DESCRIPTION: Format the contents of a PPTT. This table type consists
2241 * of an open-ended number of subtables.
2242 *
2243 ******************************************************************************/
2244
2245 void
AcpiDmDumpPptt(ACPI_TABLE_HEADER * Table)2246 AcpiDmDumpPptt (
2247 ACPI_TABLE_HEADER *Table)
2248 {
2249 ACPI_STATUS Status;
2250 ACPI_SUBTABLE_HEADER *Subtable;
2251 ACPI_PPTT_PROCESSOR *PpttProcessor;
2252 UINT8 Length;
2253 UINT8 SubtableOffset;
2254 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
2255 ACPI_DMTABLE_INFO *InfoTable;
2256 UINT32 i;
2257
2258
2259 /* There is no main table (other than the standard ACPI header) */
2260
2261 /* Subtables */
2262
2263 Offset = sizeof (ACPI_TABLE_HEADER);
2264 while (Offset < Table->Length)
2265 {
2266 AcpiOsPrintf ("\n");
2267
2268 /* Common subtable header */
2269
2270 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2271 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER))
2272 {
2273 AcpiOsPrintf ("Invalid subtable length\n");
2274 return;
2275 }
2276 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2277 Subtable->Length, AcpiDmTableInfoPpttHdr);
2278 if (ACPI_FAILURE (Status))
2279 {
2280 return;
2281 }
2282
2283 switch (Subtable->Type)
2284 {
2285 case ACPI_PPTT_TYPE_PROCESSOR:
2286
2287 InfoTable = AcpiDmTableInfoPptt0;
2288 Length = sizeof (ACPI_PPTT_PROCESSOR);
2289 break;
2290
2291 case ACPI_PPTT_TYPE_CACHE:
2292
2293 InfoTable = AcpiDmTableInfoPptt1;
2294 Length = sizeof (ACPI_PPTT_CACHE);
2295 break;
2296
2297 case ACPI_PPTT_TYPE_ID:
2298
2299 InfoTable = AcpiDmTableInfoPptt2;
2300 Length = sizeof (ACPI_PPTT_ID);
2301 break;
2302
2303 default:
2304
2305 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
2306 Subtable->Type);
2307
2308 /* Attempt to continue */
2309
2310 goto NextSubtable;
2311 }
2312
2313 if (Subtable->Length < Length)
2314 {
2315 AcpiOsPrintf ("Invalid subtable length\n");
2316 return;
2317 }
2318 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2319 Subtable->Length, InfoTable);
2320 if (ACPI_FAILURE (Status))
2321 {
2322 return;
2323 }
2324 SubtableOffset = Length;
2325
2326 switch (Subtable->Type)
2327 {
2328 case ACPI_PPTT_TYPE_PROCESSOR:
2329
2330 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable);
2331
2332 /* Dump SMBIOS handles */
2333
2334 if ((UINT8)(Subtable->Length - SubtableOffset) <
2335 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
2336 {
2337 AcpiOsPrintf ("Invalid private resource number\n");
2338 return;
2339 }
2340 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
2341 {
2342 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2343 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2344 4, AcpiDmTableInfoPptt0a);
2345 if (ACPI_FAILURE (Status))
2346 {
2347 return;
2348 }
2349
2350 SubtableOffset += 4;
2351 }
2352 break;
2353
2354 case ACPI_PPTT_TYPE_CACHE:
2355
2356 if (Table->Revision < 3)
2357 {
2358 break;
2359 }
2360 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2361 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2362 sizeof (ACPI_PPTT_CACHE_V1), AcpiDmTableInfoPptt1a);
2363 if (ACPI_FAILURE (Status))
2364 {
2365 return;
2366 }
2367 break;
2368
2369 default:
2370
2371 break;
2372 }
2373
2374 NextSubtable:
2375 /* Point to next subtable */
2376
2377 Offset += Subtable->Length;
2378 }
2379 }
2380
2381
2382 /*******************************************************************************
2383 *
2384 * FUNCTION: AcpiDmDumpPrmt
2385 *
2386 * PARAMETERS: Table - A PRMT table
2387 *
2388 * RETURN: None
2389 *
2390 * DESCRIPTION: Format the contents of a PRMT. This table type consists
2391 * of an open-ended number of subtables.
2392 *
2393 ******************************************************************************/
2394
2395 void
AcpiDmDumpPrmt(ACPI_TABLE_HEADER * Table)2396 AcpiDmDumpPrmt (
2397 ACPI_TABLE_HEADER *Table)
2398 {
2399 UINT32 CurrentOffset = sizeof (ACPI_TABLE_HEADER);
2400 ACPI_TABLE_PRMT_HEADER *PrmtHeader;
2401 ACPI_PRMT_MODULE_INFO *PrmtModuleInfo;
2402 ACPI_PRMT_HANDLER_INFO *PrmtHandlerInfo;
2403 ACPI_STATUS Status;
2404 UINT32 i, j;
2405
2406
2407 /* Main table header */
2408
2409 PrmtHeader = ACPI_ADD_PTR (ACPI_TABLE_PRMT_HEADER, Table, CurrentOffset);
2410 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHeader,
2411 sizeof (ACPI_TABLE_PRMT_HEADER), AcpiDmTableInfoPrmtHdr);
2412 if (ACPI_FAILURE (Status))
2413 {
2414 AcpiOsPrintf ("Invalid PRMT header\n");
2415 return;
2416 }
2417
2418 CurrentOffset += sizeof (ACPI_TABLE_PRMT_HEADER);
2419
2420 /* PRM Module Information Structure array */
2421
2422 for (i = 0; i < PrmtHeader->ModuleInfoCount; ++i)
2423 {
2424 PrmtModuleInfo = ACPI_ADD_PTR (ACPI_PRMT_MODULE_INFO, Table, CurrentOffset);
2425 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtModuleInfo,
2426 sizeof (ACPI_PRMT_MODULE_INFO), AcpiDmTableInfoPrmtModule);
2427
2428 CurrentOffset += sizeof (ACPI_PRMT_MODULE_INFO);
2429
2430 /* PRM handler information structure array */
2431
2432 for (j = 0; j < PrmtModuleInfo->HandlerInfoCount; ++j)
2433 {
2434 PrmtHandlerInfo = ACPI_ADD_PTR (ACPI_PRMT_HANDLER_INFO, Table, CurrentOffset);
2435 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHandlerInfo,
2436 sizeof (ACPI_PRMT_HANDLER_INFO), AcpiDmTableInfoPrmtHandler);
2437
2438 CurrentOffset += sizeof (ACPI_PRMT_HANDLER_INFO);
2439 }
2440 }
2441 }
2442
2443
2444 /*******************************************************************************
2445 *
2446 * FUNCTION: AcpiDmDumpRas2
2447 *
2448 * PARAMETERS: Table - A RAS2 table
2449 *
2450 * RETURN: None
2451 *
2452 * DESCRIPTION: Format the contents of a Ras2. This is a variable-length
2453 * table that contains an open-ended number of the RAS2 PCC
2454 * descriptors at the end of the table.
2455 *
2456 ******************************************************************************/
2457
2458 void
AcpiDmDumpRas2(ACPI_TABLE_HEADER * Table)2459 AcpiDmDumpRas2 (
2460 ACPI_TABLE_HEADER *Table)
2461 {
2462 ACPI_STATUS Status;
2463 ACPI_RAS2_PCC_DESC *Subtable;
2464 UINT32 Length = Table->Length;
2465 UINT32 Offset = sizeof (ACPI_TABLE_RAS2);
2466
2467
2468 /* Main table */
2469
2470 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRas2);
2471 if (ACPI_FAILURE (Status))
2472 {
2473 return;
2474 }
2475
2476 /* Subtables - RAS2 PCC descriptor list */
2477
2478 Subtable = ACPI_ADD_PTR (ACPI_RAS2_PCC_DESC, Table, Offset);
2479 while (Offset < Table->Length)
2480 {
2481 AcpiOsPrintf ("\n");
2482 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2483 sizeof (ACPI_RAS2_PCC_DESC), AcpiDmTableInfoRas2PccDesc);
2484 if (ACPI_FAILURE (Status))
2485 {
2486 return;
2487 }
2488
2489 /* Point to next subtable */
2490
2491 Offset += sizeof (ACPI_RAS2_PCC_DESC);
2492 Subtable = ACPI_ADD_PTR (ACPI_RAS2_PCC_DESC, Subtable,
2493 sizeof (ACPI_RAS2_PCC_DESC));
2494 }
2495 }
2496
2497
2498 /*******************************************************************************
2499 *
2500 * FUNCTION: AcpiDmDumpRgrt
2501 *
2502 * PARAMETERS: Table - A RGRT table
2503 *
2504 * RETURN: None
2505 *
2506 * DESCRIPTION: Format the contents of a RGRT
2507 *
2508 ******************************************************************************/
2509
2510 void
AcpiDmDumpRgrt(ACPI_TABLE_HEADER * Table)2511 AcpiDmDumpRgrt (
2512 ACPI_TABLE_HEADER *Table)
2513 {
2514 ACPI_STATUS Status;
2515 ACPI_TABLE_RGRT *Subtable = ACPI_CAST_PTR (ACPI_TABLE_RGRT, Table);
2516 UINT32 Offset = sizeof (ACPI_TABLE_RGRT);
2517
2518
2519 /* Main table */
2520
2521 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoRgrt);
2522 if (ACPI_FAILURE (Status))
2523 {
2524 return;
2525 }
2526
2527 /* Dump the binary image as a subtable */
2528
2529 Status = AcpiDmDumpTable (Table->Length, Offset, &Subtable->Image,
2530 Table->Length - Offset, AcpiDmTableInfoRgrt0);
2531 if (ACPI_FAILURE (Status))
2532 {
2533 return;
2534 }
2535 }
2536
2537
2538 /*******************************************************************************
2539 *
2540 * FUNCTION: AcpiDmDumpRhct
2541 *
2542 * PARAMETERS: Table - A RHCT table
2543 *
2544 * RETURN: None
2545 *
2546 * DESCRIPTION: Format the contents of a RHCT.
2547 *
2548 ******************************************************************************/
2549
2550 void
AcpiDmDumpRhct(ACPI_TABLE_HEADER * Table)2551 AcpiDmDumpRhct (
2552 ACPI_TABLE_HEADER *Table)
2553 {
2554 ACPI_STATUS Status;
2555 ACPI_RHCT_NODE_HEADER *Subtable;
2556 ACPI_RHCT_HART_INFO *RhctHartInfo;
2557 ACPI_RHCT_ISA_STRING *RhctIsaString;
2558 ACPI_RHCT_CMO_NODE *RhctCmoNode;
2559 ACPI_RHCT_MMU_NODE *RhctMmuNode;
2560 UINT32 Length = Table->Length;
2561 UINT8 SubtableOffset, IsaPadOffset;
2562 UINT32 Offset = sizeof (ACPI_TABLE_RHCT);
2563 UINT32 i;
2564
2565 /* Main table */
2566
2567 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRhct);
2568 if (ACPI_FAILURE (Status))
2569 {
2570 return;
2571 }
2572
2573 /* Subtables */
2574
2575 while (Offset < Table->Length)
2576 {
2577 AcpiOsPrintf ("\n");
2578
2579 /* Common subtable header */
2580
2581 Subtable = ACPI_ADD_PTR (ACPI_RHCT_NODE_HEADER, Table, Offset);
2582 if (Subtable->Length < sizeof (ACPI_RHCT_NODE_HEADER))
2583 {
2584 AcpiOsPrintf ("Invalid subtable length\n");
2585 return;
2586 }
2587 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2588 Subtable->Length, AcpiDmTableInfoRhctNodeHdr);
2589 if (ACPI_FAILURE (Status))
2590 {
2591 return;
2592 }
2593
2594 Length = sizeof (ACPI_RHCT_NODE_HEADER);
2595
2596 if (Subtable->Length < Length)
2597 {
2598 AcpiOsPrintf ("Invalid subtable length\n");
2599 return;
2600 }
2601 SubtableOffset = (UINT8) Length;
2602
2603 switch (Subtable->Type)
2604 {
2605 case ACPI_RHCT_NODE_TYPE_HART_INFO:
2606 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2607 ACPI_ADD_PTR (ACPI_RHCT_HART_INFO, Subtable, SubtableOffset),
2608 sizeof (ACPI_RHCT_HART_INFO), AcpiDmTableInfoRhctHartInfo1);
2609
2610 RhctHartInfo = ACPI_ADD_PTR (ACPI_RHCT_HART_INFO, Subtable, SubtableOffset);
2611
2612 if ((UINT16)(Subtable->Length - SubtableOffset) <
2613 (UINT16)(RhctHartInfo->NumOffsets * 4))
2614 {
2615 AcpiOsPrintf ("Invalid number of offsets\n");
2616 return;
2617 }
2618 SubtableOffset += sizeof (ACPI_RHCT_HART_INFO);
2619 for (i = 0; i < RhctHartInfo->NumOffsets; i++)
2620 {
2621 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2622 ACPI_ADD_PTR (UINT32, Subtable, SubtableOffset),
2623 4, AcpiDmTableInfoRhctHartInfo2);
2624 if (ACPI_FAILURE (Status))
2625 {
2626 return;
2627 }
2628
2629 SubtableOffset += 4;
2630 }
2631 break;
2632
2633 case ACPI_RHCT_NODE_TYPE_ISA_STRING:
2634 RhctIsaString = ACPI_ADD_PTR (ACPI_RHCT_ISA_STRING, Subtable, SubtableOffset);
2635 IsaPadOffset = (UINT8) (SubtableOffset + 2 + RhctIsaString->IsaLength);
2636 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2637 RhctIsaString, RhctIsaString->IsaLength, AcpiDmTableInfoRhctIsa1);
2638 if (Subtable->Length > IsaPadOffset)
2639 {
2640 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2641 ACPI_ADD_PTR (UINT8, Subtable, IsaPadOffset),
2642 (Subtable->Length - IsaPadOffset), AcpiDmTableInfoRhctIsaPad);
2643 }
2644
2645 break;
2646
2647 case ACPI_RHCT_NODE_TYPE_CMO:
2648 RhctCmoNode = ACPI_ADD_PTR (ACPI_RHCT_CMO_NODE, Subtable, SubtableOffset);
2649 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2650 RhctCmoNode, 4, AcpiDmTableInfoRhctCmo1);
2651 break;
2652
2653 case ACPI_RHCT_NODE_TYPE_MMU:
2654 RhctMmuNode = ACPI_ADD_PTR (ACPI_RHCT_MMU_NODE, Subtable, SubtableOffset);
2655 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2656 RhctMmuNode, 2, AcpiDmTableInfoRhctMmu1);
2657 break;
2658
2659 default:
2660 break;
2661 }
2662
2663 /* Point to next subtable */
2664
2665 Offset += Subtable->Length;
2666 }
2667 }
2668
2669 /*******************************************************************************
2670 *
2671 * FUNCTION: AcpiDmDumpRimt
2672 *
2673 * PARAMETERS: Table - A RIMT table
2674 *
2675 * RETURN: None
2676 *
2677 * DESCRIPTION: Format the contents of a RIMT.
2678 *
2679 ******************************************************************************/
2680
2681 void
AcpiDmDumpRimt(ACPI_TABLE_HEADER * Table)2682 AcpiDmDumpRimt (
2683 ACPI_TABLE_HEADER *Table)
2684 {
2685 ACPI_RIMT_PLATFORM_DEVICE *PlatNode;
2686 ACPI_RIMT_PCIE_RC *PcieNode;
2687 ACPI_RIMT_NODE *Subtable;
2688 ACPI_STATUS Status;
2689 UINT32 Length = Table->Length;
2690 UINT16 SubtableOffset;
2691 UINT32 NodeOffset;
2692 UINT16 i;
2693 UINT32 Offset = sizeof (ACPI_TABLE_RIMT);
2694
2695 /* Main table */
2696
2697 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRimt);
2698 if (ACPI_FAILURE (Status))
2699 {
2700 return;
2701 }
2702
2703 /* Subtables */
2704
2705 while (Offset < Table->Length)
2706 {
2707 AcpiOsPrintf ("\n");
2708
2709 /* Common subtable header */
2710
2711 Subtable = ACPI_ADD_PTR (ACPI_RIMT_NODE, Table, Offset);
2712 if (Subtable->Length < sizeof (ACPI_RIMT_NODE))
2713 {
2714 AcpiOsPrintf ("Invalid subtable length\n");
2715 return;
2716 }
2717 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2718 Subtable->Length, AcpiDmTableInfoRimtNodeHdr);
2719 if (ACPI_FAILURE (Status))
2720 {
2721 return;
2722 }
2723
2724 Length = sizeof (ACPI_RIMT_NODE);
2725
2726 if (Subtable->Length < Length)
2727 {
2728 AcpiOsPrintf ("Invalid subtable length\n");
2729 return;
2730 }
2731 SubtableOffset = (UINT16) Length;
2732
2733 switch (Subtable->Type)
2734 {
2735 case ACPI_RIMT_NODE_TYPE_IOMMU:
2736 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2737 ACPI_ADD_PTR (ACPI_RIMT_IOMMU, Subtable, SubtableOffset),
2738 sizeof (ACPI_RIMT_IOMMU), AcpiDmTableInfoRimtIommu);
2739
2740 break;
2741
2742 case ACPI_RIMT_NODE_TYPE_PCIE_ROOT_COMPLEX:
2743 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2744 ACPI_ADD_PTR (ACPI_RIMT_PCIE_RC, Subtable, SubtableOffset),
2745 sizeof (ACPI_RIMT_PCIE_RC), AcpiDmTableInfoRimtPcieRc);
2746
2747 PcieNode = ACPI_ADD_PTR (ACPI_RIMT_PCIE_RC, Subtable, SubtableOffset);
2748
2749 /* Dump the ID mappings */
2750 NodeOffset = PcieNode->IdMappingOffset;
2751 for (i = 0; i < PcieNode->NumIdMappings; i++)
2752 {
2753 AcpiOsPrintf ("\n");
2754 Length = sizeof (ACPI_RIMT_ID_MAPPING);
2755 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2756 ACPI_ADD_PTR (ACPI_RIMT_ID_MAPPING, Subtable, NodeOffset),
2757 Length, AcpiDmTableInfoRimtIdMapping);
2758 if (ACPI_FAILURE (Status))
2759 {
2760 return;
2761 }
2762
2763 NodeOffset += Length;
2764 }
2765 break;
2766
2767 case ACPI_RIMT_NODE_TYPE_PLAT_DEVICE:
2768 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2769 ACPI_ADD_PTR (ACPI_RIMT_PLATFORM_DEVICE, Subtable, SubtableOffset),
2770 sizeof (ACPI_RIMT_PLATFORM_DEVICE), AcpiDmTableInfoRimtPlatDev);
2771 PlatNode = ACPI_ADD_PTR (ACPI_RIMT_PLATFORM_DEVICE, Subtable, SubtableOffset);
2772
2773 /* Dump the ID mappings */
2774 NodeOffset = PlatNode->IdMappingOffset;
2775 for (i = 0; i < PlatNode->NumIdMappings; i++)
2776 {
2777 AcpiOsPrintf ("\n");
2778 Length = sizeof (ACPI_RIMT_ID_MAPPING);
2779 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2780 ACPI_ADD_PTR (ACPI_RIMT_ID_MAPPING, Subtable, NodeOffset),
2781 Length, AcpiDmTableInfoRimtIdMapping);
2782 if (ACPI_FAILURE (Status))
2783 {
2784 return;
2785 }
2786
2787 NodeOffset += Length;
2788 }
2789 break;
2790
2791 default:
2792 break;
2793 }
2794
2795 /* Point to next subtable */
2796
2797 Offset += Subtable->Length;
2798 }
2799 }
2800
2801
2802 /*******************************************************************************
2803 *
2804 * FUNCTION: AcpiDmDumpS3pt
2805 *
2806 * PARAMETERS: Table - A S3PT table
2807 *
2808 * RETURN: Length of the table
2809 *
2810 * DESCRIPTION: Format the contents of a S3PT
2811 *
2812 ******************************************************************************/
2813
2814 UINT32
AcpiDmDumpS3pt(ACPI_TABLE_HEADER * Tables)2815 AcpiDmDumpS3pt (
2816 ACPI_TABLE_HEADER *Tables)
2817 {
2818 ACPI_STATUS Status;
2819 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
2820 ACPI_FPDT_HEADER *Subtable;
2821 ACPI_DMTABLE_INFO *InfoTable;
2822 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
2823
2824
2825 /* Main table */
2826
2827 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
2828 if (ACPI_FAILURE (Status))
2829 {
2830 return 0;
2831 }
2832
2833 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
2834 while (Offset < S3ptTable->Length)
2835 {
2836 /* Common subtable header */
2837
2838 AcpiOsPrintf ("\n");
2839 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
2840 Subtable->Length, AcpiDmTableInfoS3ptHdr);
2841 if (ACPI_FAILURE (Status))
2842 {
2843 return 0;
2844 }
2845
2846 switch (Subtable->Type)
2847 {
2848 case ACPI_S3PT_TYPE_RESUME:
2849
2850 InfoTable = AcpiDmTableInfoS3pt0;
2851 break;
2852
2853 case ACPI_S3PT_TYPE_SUSPEND:
2854
2855 InfoTable = AcpiDmTableInfoS3pt1;
2856 break;
2857
2858 default:
2859
2860 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
2861 Subtable->Type);
2862
2863 /* Attempt to continue */
2864
2865 if (!Subtable->Length)
2866 {
2867 AcpiOsPrintf ("Invalid zero length subtable\n");
2868 return 0;
2869 }
2870 goto NextSubtable;
2871 }
2872
2873 AcpiOsPrintf ("\n");
2874 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
2875 Subtable->Length, InfoTable);
2876 if (ACPI_FAILURE (Status))
2877 {
2878 return 0;
2879 }
2880
2881 NextSubtable:
2882 /* Point to next subtable */
2883
2884 Offset += Subtable->Length;
2885 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length);
2886 }
2887
2888 return (S3ptTable->Length);
2889 }
2890
2891
2892 /*******************************************************************************
2893 *
2894 * FUNCTION: AcpiDmDumpSdev
2895 *
2896 * PARAMETERS: Table - A SDEV table
2897 *
2898 * RETURN: None
2899 *
2900 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length
2901 * table that contains variable strings and vendor data.
2902 *
2903 ******************************************************************************/
2904
2905 void
AcpiDmDumpSdev(ACPI_TABLE_HEADER * Table)2906 AcpiDmDumpSdev (
2907 ACPI_TABLE_HEADER *Table)
2908 {
2909 ACPI_STATUS Status;
2910 ACPI_SDEV_HEADER *Subtable;
2911 ACPI_SDEV_PCIE *Pcie;
2912 ACPI_SDEV_NAMESPACE *Namesp;
2913 ACPI_DMTABLE_INFO *InfoTable;
2914 ACPI_DMTABLE_INFO *SecureComponentInfoTable;
2915 UINT32 Length = Table->Length;
2916 UINT32 Offset = sizeof (ACPI_TABLE_SDEV);
2917 UINT16 PathOffset;
2918 UINT16 PathLength;
2919 UINT16 VendorDataOffset;
2920 UINT16 VendorDataLength;
2921 ACPI_SDEV_SECURE_COMPONENT *SecureComponent = NULL;
2922 UINT32 CurrentOffset = 0;
2923
2924
2925 /* Main table */
2926
2927 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev);
2928 if (ACPI_FAILURE (Status))
2929 {
2930 return;
2931 }
2932
2933 /* Subtables */
2934
2935 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset);
2936 while (Offset < Table->Length)
2937 {
2938 /* Common subtable header */
2939
2940 AcpiOsPrintf ("\n");
2941 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2942 Subtable->Length, AcpiDmTableInfoSdevHdr);
2943 if (ACPI_FAILURE (Status))
2944 {
2945 return;
2946 }
2947
2948 switch (Subtable->Type)
2949 {
2950 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
2951
2952 InfoTable = AcpiDmTableInfoSdev0;
2953 break;
2954
2955 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
2956
2957 InfoTable = AcpiDmTableInfoSdev1;
2958 break;
2959
2960 default:
2961 goto NextSubtable;
2962 }
2963
2964 AcpiOsPrintf ("\n");
2965 Status = AcpiDmDumpTable (Table->Length, 0, Subtable,
2966 Subtable->Length, InfoTable);
2967 if (ACPI_FAILURE (Status))
2968 {
2969 return;
2970 }
2971
2972 switch (Subtable->Type)
2973 {
2974 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
2975
2976 CurrentOffset = sizeof (ACPI_SDEV_NAMESPACE);
2977 if (Subtable->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT)
2978 {
2979 SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT,
2980 ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)));
2981
2982 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2983 ACPI_ADD_PTR(UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)),
2984 sizeof (ACPI_SDEV_SECURE_COMPONENT), AcpiDmTableInfoSdev0b);
2985 if (ACPI_FAILURE (Status))
2986 {
2987 return;
2988 }
2989 CurrentOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT);
2990
2991 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2992 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
2993 sizeof (ACPI_SDEV_HEADER), AcpiDmTableInfoSdevSecCompHdr);
2994 if (ACPI_FAILURE (Status))
2995 {
2996 return;
2997 }
2998 CurrentOffset += sizeof (ACPI_SDEV_HEADER);
2999
3000 switch (Subtable->Type)
3001 {
3002 case ACPI_SDEV_TYPE_ID_COMPONENT:
3003
3004 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId;
3005 break;
3006
3007 case ACPI_SDEV_TYPE_MEM_COMPONENT:
3008
3009 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem;
3010 break;
3011
3012 default:
3013 goto NextSubtable;
3014 }
3015
3016 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
3017 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
3018 SecureComponent->SecureComponentLength, SecureComponentInfoTable);
3019 CurrentOffset += SecureComponent->SecureComponentLength;
3020 }
3021
3022 /* Dump the PCIe device ID(s) */
3023
3024 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable);
3025 PathOffset = Namesp->DeviceIdOffset;
3026 PathLength = Namesp->DeviceIdLength;
3027
3028 if (PathLength)
3029 {
3030 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
3031 ACPI_ADD_PTR (UINT8, Namesp, PathOffset),
3032 PathLength, AcpiDmTableInfoSdev0a);
3033 if (ACPI_FAILURE (Status))
3034 {
3035 return;
3036 }
3037 CurrentOffset += PathLength;
3038 }
3039
3040 /* Dump the vendor-specific data */
3041
3042 VendorDataLength =
3043 Namesp->VendorDataLength;
3044 VendorDataOffset =
3045 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
3046
3047 if (VendorDataLength)
3048 {
3049 Status = AcpiDmDumpTable (Table->Length, 0,
3050 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset),
3051 VendorDataLength, AcpiDmTableInfoSdev1b);
3052 if (ACPI_FAILURE (Status))
3053 {
3054 return;
3055 }
3056 }
3057 break;
3058
3059 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
3060
3061 /* PCI path substructures */
3062
3063 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable);
3064 PathOffset = Pcie->PathOffset;
3065 PathLength = Pcie->PathLength;
3066
3067 while (PathLength)
3068 {
3069 Status = AcpiDmDumpTable (Table->Length,
3070 PathOffset + Offset,
3071 ACPI_ADD_PTR (UINT8, Pcie, PathOffset),
3072 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a);
3073 if (ACPI_FAILURE (Status))
3074 {
3075 return;
3076 }
3077
3078 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH);
3079 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH);
3080 }
3081
3082 /* VendorData */
3083
3084 VendorDataLength = Pcie->VendorDataLength;
3085 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength;
3086
3087 if (VendorDataLength)
3088 {
3089 Status = AcpiDmDumpTable (Table->Length, 0,
3090 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset),
3091 VendorDataLength, AcpiDmTableInfoSdev1b);
3092 if (ACPI_FAILURE (Status))
3093 {
3094 return;
3095 }
3096 }
3097 break;
3098
3099 default:
3100 goto NextSubtable;
3101 }
3102
3103 NextSubtable:
3104 /* Point to next subtable */
3105
3106 Offset += Subtable->Length;
3107 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable,
3108 Subtable->Length);
3109 }
3110 }
3111