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 - 2024, 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: AcpiDmDumpMsct
1477 *
1478 * PARAMETERS: Table - A MSCT table
1479 *
1480 * RETURN: None
1481 *
1482 * DESCRIPTION: Format the contents of a MSCT
1483 *
1484 ******************************************************************************/
1485
1486 void
AcpiDmDumpMsct(ACPI_TABLE_HEADER * Table)1487 AcpiDmDumpMsct (
1488 ACPI_TABLE_HEADER *Table)
1489 {
1490 ACPI_STATUS Status;
1491 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1492 ACPI_MSCT_PROXIMITY *Subtable;
1493
1494
1495 /* Main table */
1496
1497 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1498 if (ACPI_FAILURE (Status))
1499 {
1500 return;
1501 }
1502
1503 /* Subtables */
1504
1505 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1506 while (Offset < Table->Length)
1507 {
1508 /* Common subtable header */
1509
1510 AcpiOsPrintf ("\n");
1511 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1512 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1513 if (ACPI_FAILURE (Status))
1514 {
1515 return;
1516 }
1517
1518 /* Point to next subtable */
1519
1520 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1521 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable,
1522 sizeof (ACPI_MSCT_PROXIMITY));
1523 }
1524 }
1525
1526
1527 /*******************************************************************************
1528 *
1529 * FUNCTION: AcpiDmDumpNfit
1530 *
1531 * PARAMETERS: Table - A NFIT table
1532 *
1533 * RETURN: None
1534 *
1535 * DESCRIPTION: Format the contents of an NFIT.
1536 *
1537 ******************************************************************************/
1538
1539 void
AcpiDmDumpNfit(ACPI_TABLE_HEADER * Table)1540 AcpiDmDumpNfit (
1541 ACPI_TABLE_HEADER *Table)
1542 {
1543 ACPI_STATUS Status;
1544 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
1545 UINT32 FieldOffset = 0;
1546 UINT32 Length;
1547 ACPI_NFIT_HEADER *Subtable;
1548 ACPI_DMTABLE_INFO *InfoTable;
1549 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
1550 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
1551 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
1552 UINT32 i;
1553
1554
1555 /* Main table */
1556
1557 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
1558 if (ACPI_FAILURE (Status))
1559 {
1560 return;
1561 }
1562
1563 /* Subtables */
1564
1565 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
1566 while (Offset < Table->Length)
1567 {
1568 /* NFIT subtable header */
1569
1570 AcpiOsPrintf ("\n");
1571 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1572 Subtable->Length, AcpiDmTableInfoNfitHdr);
1573 if (ACPI_FAILURE (Status))
1574 {
1575 return;
1576 }
1577
1578 switch (Subtable->Type)
1579 {
1580 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1581
1582 InfoTable = AcpiDmTableInfoNfit0;
1583 break;
1584
1585 case ACPI_NFIT_TYPE_MEMORY_MAP:
1586
1587 InfoTable = AcpiDmTableInfoNfit1;
1588 break;
1589
1590 case ACPI_NFIT_TYPE_INTERLEAVE:
1591
1592 /* Has a variable number of 32-bit values at the end */
1593
1594 InfoTable = AcpiDmTableInfoNfit2;
1595 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
1596 break;
1597
1598 case ACPI_NFIT_TYPE_SMBIOS:
1599
1600 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable);
1601 InfoTable = AcpiDmTableInfoNfit3;
1602 break;
1603
1604 case ACPI_NFIT_TYPE_CONTROL_REGION:
1605
1606 InfoTable = AcpiDmTableInfoNfit4;
1607 break;
1608
1609 case ACPI_NFIT_TYPE_DATA_REGION:
1610
1611 InfoTable = AcpiDmTableInfoNfit5;
1612 break;
1613
1614 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1615
1616 /* Has a variable number of 64-bit addresses at the end */
1617
1618 InfoTable = AcpiDmTableInfoNfit6;
1619 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS);
1620 break;
1621
1622 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */
1623
1624 InfoTable = AcpiDmTableInfoNfit7;
1625 break;
1626
1627 default:
1628 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
1629 Subtable->Type);
1630
1631 /* Attempt to continue */
1632
1633 if (!Subtable->Length)
1634 {
1635 AcpiOsPrintf ("Invalid zero length subtable\n");
1636 return;
1637 }
1638 goto NextSubtable;
1639 }
1640
1641 AcpiOsPrintf ("\n");
1642 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1643 Subtable->Length, InfoTable);
1644 if (ACPI_FAILURE (Status))
1645 {
1646 return;
1647 }
1648
1649 /* Per-subtable variable-length fields */
1650
1651 switch (Subtable->Type)
1652 {
1653 case ACPI_NFIT_TYPE_INTERLEAVE:
1654
1655 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable);
1656 for (i = 0; i < Interleave->LineCount; i++)
1657 {
1658 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1659 &Interleave->LineOffset[i],
1660 sizeof (UINT32), AcpiDmTableInfoNfit2a);
1661 if (ACPI_FAILURE (Status))
1662 {
1663 return;
1664 }
1665
1666 FieldOffset += sizeof (UINT32);
1667 }
1668 break;
1669
1670 case ACPI_NFIT_TYPE_SMBIOS:
1671
1672 Length = Subtable->Length -
1673 sizeof (ACPI_NFIT_SMBIOS);
1674
1675 if (Length)
1676 {
1677 Status = AcpiDmDumpTable (Table->Length,
1678 sizeof (ACPI_NFIT_SMBIOS),
1679 SmbiosInfo,
1680 Length, AcpiDmTableInfoNfit3a);
1681 if (ACPI_FAILURE (Status))
1682 {
1683 return;
1684 }
1685 }
1686
1687 break;
1688
1689 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1690
1691 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable);
1692 for (i = 0; i < Hint->HintCount; i++)
1693 {
1694 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1695 &Hint->HintAddress[i],
1696 sizeof (UINT64), AcpiDmTableInfoNfit6a);
1697 if (ACPI_FAILURE (Status))
1698 {
1699 return;
1700 }
1701
1702 FieldOffset += sizeof (UINT64);
1703 }
1704 break;
1705
1706 default:
1707 break;
1708 }
1709
1710 NextSubtable:
1711 /* Point to next subtable */
1712
1713 Offset += Subtable->Length;
1714 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length);
1715 }
1716 }
1717
1718
1719 /*******************************************************************************
1720 *
1721 * FUNCTION: AcpiDmDumpPcct
1722 *
1723 * PARAMETERS: Table - A PCCT table
1724 *
1725 * RETURN: None
1726 *
1727 * DESCRIPTION: Format the contents of a PCCT. This table type consists
1728 * of an open-ended number of subtables.
1729 *
1730 ******************************************************************************/
1731
1732 void
AcpiDmDumpPcct(ACPI_TABLE_HEADER * Table)1733 AcpiDmDumpPcct (
1734 ACPI_TABLE_HEADER *Table)
1735 {
1736 ACPI_STATUS Status;
1737 ACPI_PCCT_SUBSPACE *Subtable;
1738 ACPI_DMTABLE_INFO *InfoTable;
1739 UINT32 Length = Table->Length;
1740 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
1741
1742
1743 /* Main table */
1744
1745 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1746 if (ACPI_FAILURE (Status))
1747 {
1748 return;
1749 }
1750
1751 /* Subtables */
1752
1753 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1754 while (Offset < Table->Length)
1755 {
1756 /* Common subtable header */
1757
1758 AcpiOsPrintf ("\n");
1759 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1760 Subtable->Header.Length, AcpiDmTableInfoPcctHdr);
1761 if (ACPI_FAILURE (Status))
1762 {
1763 return;
1764 }
1765
1766 switch (Subtable->Header.Type)
1767 {
1768 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
1769
1770 InfoTable = AcpiDmTableInfoPcct0;
1771 break;
1772
1773 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
1774
1775 InfoTable = AcpiDmTableInfoPcct1;
1776 break;
1777
1778 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
1779
1780 InfoTable = AcpiDmTableInfoPcct2;
1781 break;
1782
1783 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
1784
1785 InfoTable = AcpiDmTableInfoPcct3;
1786 break;
1787
1788 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
1789
1790 InfoTable = AcpiDmTableInfoPcct4;
1791 break;
1792
1793 case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE:
1794
1795 InfoTable = AcpiDmTableInfoPcct5;
1796 break;
1797
1798 default:
1799
1800 AcpiOsPrintf (
1801 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
1802 Subtable->Header.Type);
1803 return;
1804 }
1805
1806 AcpiOsPrintf ("\n");
1807 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1808 Subtable->Header.Length, InfoTable);
1809 if (ACPI_FAILURE (Status))
1810 {
1811 return;
1812 }
1813
1814 /* Point to next subtable */
1815
1816 Offset += Subtable->Header.Length;
1817 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable,
1818 Subtable->Header.Length);
1819 }
1820 }
1821
1822
1823 /*******************************************************************************
1824 *
1825 * FUNCTION: AcpiDmDumpPdtt
1826 *
1827 * PARAMETERS: Table - A PDTT table
1828 *
1829 * RETURN: None
1830 *
1831 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length
1832 * table that contains an open-ended number of IDs
1833 * at the end of the table.
1834 *
1835 ******************************************************************************/
1836
1837 void
AcpiDmDumpPdtt(ACPI_TABLE_HEADER * Table)1838 AcpiDmDumpPdtt (
1839 ACPI_TABLE_HEADER *Table)
1840 {
1841 ACPI_STATUS Status;
1842 ACPI_PDTT_CHANNEL *Subtable;
1843 UINT32 Length = Table->Length;
1844 UINT32 Offset = sizeof (ACPI_TABLE_PDTT);
1845
1846
1847 /* Main table */
1848
1849 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt);
1850 if (ACPI_FAILURE (Status))
1851 {
1852 return;
1853 }
1854
1855 /* Subtables. Currently there is only one type, but can be multiples */
1856
1857 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset);
1858 while (Offset < Table->Length)
1859 {
1860 AcpiOsPrintf ("\n");
1861 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1862 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0);
1863 if (ACPI_FAILURE (Status))
1864 {
1865 return;
1866 }
1867
1868 /* Point to next subtable */
1869
1870 Offset += sizeof (ACPI_PDTT_CHANNEL);
1871 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable,
1872 sizeof (ACPI_PDTT_CHANNEL));
1873 }
1874 }
1875
1876
1877 /*******************************************************************************
1878 *
1879 * FUNCTION: AcpiDmDumpPhat
1880 *
1881 * PARAMETERS: Table - A PHAT table
1882 *
1883 * RETURN: None
1884 *
1885 * DESCRIPTION: Format the contents of a PHAT.
1886 *
1887 ******************************************************************************/
1888
1889 void
AcpiDmDumpPhat(ACPI_TABLE_HEADER * Table)1890 AcpiDmDumpPhat (
1891 ACPI_TABLE_HEADER *Table)
1892 {
1893 ACPI_STATUS Status;
1894 ACPI_DMTABLE_INFO *InfoTable;
1895 ACPI_PHAT_HEADER *Subtable;
1896 ACPI_PHAT_VERSION_DATA *VersionData;
1897 ACPI_PHAT_HEALTH_DATA *HealthData;
1898 UINT32 RecordCount;
1899 UINT32 Length = Table->Length;
1900 UINT32 Offset = sizeof (ACPI_TABLE_PHAT);
1901 UINT32 OriginalOffset;
1902 UINT32 SubtableLength;
1903 UINT32 PathLength;
1904 UINT32 VendorLength;
1905 UINT16 RecordType;
1906
1907
1908 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, sizeof (ACPI_TABLE_PHAT));
1909
1910 while (Offset < Table->Length)
1911 {
1912 /* Common subtable header */
1913
1914 AcpiOsPrintf ("\n");
1915 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1916 sizeof (ACPI_PHAT_HEADER), AcpiDmTableInfoPhatHdr);
1917 if (ACPI_FAILURE (Status))
1918 {
1919 return;
1920 }
1921
1922 DbgPrint (ASL_DEBUG_OUTPUT, "\n/* %u, Subtable->Type %X */\n",
1923 __LINE__, Subtable->Type);
1924
1925 switch (Subtable->Type)
1926 {
1927 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
1928
1929 InfoTable = AcpiDmTableInfoPhat0;
1930 SubtableLength = sizeof (ACPI_PHAT_VERSION_DATA);
1931 break;
1932
1933 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
1934
1935 InfoTable = AcpiDmTableInfoPhat1;
1936 SubtableLength = sizeof (ACPI_PHAT_HEALTH_DATA);
1937 break;
1938
1939 default:
1940
1941 DbgPrint (ASL_DEBUG_OUTPUT, "\n**** Unknown PHAT subtable type 0x%X\n\n",
1942 Subtable->Type);
1943
1944 return;
1945 }
1946
1947 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1948 SubtableLength, InfoTable);
1949 if (ACPI_FAILURE (Status))
1950 {
1951 return;
1952 }
1953
1954 Offset += SubtableLength;
1955
1956 OriginalOffset = Offset;
1957 switch (Subtable->Type)
1958 {
1959 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
1960
1961 VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, Subtable);
1962 RecordCount = VersionData->ElementCount;
1963 RecordType = *ACPI_CAST_PTR (UINT8, Subtable);
1964
1965 /*
1966 * Skip past a zero-valued block (not part of the ACPI PHAT specification).
1967 * First, check for a zero length record and a zero element count
1968 */
1969 if (!VersionData->Header.Length && !VersionData->ElementCount)
1970 {
1971 while (RecordType == 0)
1972 {
1973 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, Offset);
1974 RecordType = *ACPI_CAST_PTR (UINT8, Subtable);
1975 RecordCount = VersionData->ElementCount;
1976 Offset += 1;
1977 }
1978
1979 Offset -= 1;
1980 AcpiOsPrintf ("\n/* Warning: Block of zeros found above starting at Offset %X Length %X */\n"
1981 "/* (not compliant to PHAT specification -- ignoring block) */\n",
1982 OriginalOffset - 12, Offset - OriginalOffset + 12);
1983 }
1984
1985 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, RecordCount: %X, Offset %X, SubtableLength %X */\n",
1986 __LINE__, RecordCount, Offset, SubtableLength);
1987
1988 /* Emit each of the version elements */
1989
1990 while (RecordCount && VersionData->Header.Length)
1991 {
1992 AcpiOsPrintf ("\n/* Version Element #%Xh Offset %Xh */\n\n",
1993 VersionData->ElementCount - RecordCount + 1, Offset);
1994
1995 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, Offset);
1996 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1997 sizeof (ACPI_PHAT_VERSION_ELEMENT), AcpiDmTableInfoPhat0a);
1998 if (ACPI_FAILURE (Status))
1999 {
2000 return;
2001 }
2002
2003 Offset += sizeof (ACPI_PHAT_VERSION_ELEMENT);
2004 RecordCount--;
2005 }
2006
2007 break;
2008
2009 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
2010
2011 HealthData = ACPI_CAST_PTR (ACPI_PHAT_HEALTH_DATA, Subtable);
2012 PathLength = Subtable->Length - sizeof (ACPI_PHAT_HEALTH_DATA);
2013 VendorLength = 0;
2014
2015 /* An offset of 0 should be ignored */
2016 if (HealthData->DeviceSpecificOffset != 0)
2017 {
2018 if (HealthData->DeviceSpecificOffset > Subtable->Length)
2019 {
2020 AcpiOsPrintf ("\n/* Warning: Oversized device-specific data offset %X */\n"
2021 "/* (maximum is %X -- ignoring device-specific data) */\n",
2022 HealthData->DeviceSpecificOffset, Subtable->Length);
2023 }
2024 else if (HealthData->DeviceSpecificOffset < sizeof (ACPI_PHAT_HEALTH_DATA))
2025 {
2026 AcpiOsPrintf ("\n/* Warning: Undersized device-specific data offset %X */\n"
2027 "/* (minimum is %X -- ignoring device-specific data) */\n",
2028 HealthData->DeviceSpecificOffset, (UINT8) sizeof (ACPI_PHAT_HEALTH_DATA));
2029 }
2030 else
2031 {
2032 PathLength = HealthData->DeviceSpecificOffset - sizeof (ACPI_PHAT_HEALTH_DATA);
2033 VendorLength = Subtable->Length - HealthData->DeviceSpecificOffset;
2034 }
2035 }
2036
2037 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, PathLength %X, Offset %X */\n",
2038 __LINE__, PathLength, Offset);
2039
2040 if (PathLength)
2041 {
2042 Status = AcpiDmDumpTable (Length, Offset,
2043 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA)),
2044 PathLength, AcpiDmTableInfoPhat1a);
2045 if (ACPI_FAILURE (Status))
2046 {
2047 return;
2048 }
2049
2050 Offset += PathLength;
2051 }
2052
2053 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, VendorLength %X, Offset %X */\n",
2054 __LINE__, VendorLength, Offset);
2055
2056 if (VendorLength)
2057 {
2058 Status = AcpiDmDumpTable (Length, Offset,
2059 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, HealthData->DeviceSpecificOffset),
2060 VendorLength, AcpiDmTableInfoPhat1b);
2061 if (ACPI_FAILURE (Status))
2062 {
2063 return;
2064 }
2065
2066 Offset += VendorLength;
2067 }
2068
2069 break;
2070
2071 default:
2072
2073 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n",
2074 Subtable->Type);
2075 return;
2076 }
2077
2078 /* Next subtable */
2079
2080 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, Bottom of main loop: Offset %X, "
2081 "Subtable->Length %X, Table->Length %X */\n",
2082 __LINE__, Offset, Subtable->Length, Table->Length);
2083
2084 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table,
2085 Offset);
2086 }
2087 }
2088
2089
2090 /*******************************************************************************
2091 *
2092 * FUNCTION: AcpiDmDumpPmtt
2093 *
2094 * PARAMETERS: Table - A PMTT table
2095 *
2096 * RETURN: None
2097 *
2098 * DESCRIPTION: Format the contents of a PMTT. This table type consists
2099 * of an open-ended number of subtables.
2100 *
2101 ******************************************************************************/
2102
2103 void
AcpiDmDumpPmtt(ACPI_TABLE_HEADER * Table)2104 AcpiDmDumpPmtt (
2105 ACPI_TABLE_HEADER *Table)
2106 {
2107 ACPI_STATUS Status;
2108 ACPI_PMTT_HEADER *Subtable;
2109 UINT32 Length = Table->Length;
2110 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
2111
2112
2113 /* Main table */
2114
2115 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
2116 if (ACPI_FAILURE (Status))
2117 {
2118 return;
2119 }
2120
2121 /* Subtables */
2122
2123 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
2124 while (Offset < Table->Length)
2125 {
2126 /* Each of the types below contain the common subtable header */
2127
2128 AcpiOsPrintf ("\n");
2129 switch (Subtable->Type)
2130 {
2131 case ACPI_PMTT_TYPE_SOCKET:
2132
2133 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2134 Subtable->Length, AcpiDmTableInfoPmtt0);
2135 if (ACPI_FAILURE (Status))
2136 {
2137 return;
2138 }
2139 break;
2140
2141 case ACPI_PMTT_TYPE_CONTROLLER:
2142 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2143 Subtable->Length, AcpiDmTableInfoPmtt1);
2144 if (ACPI_FAILURE (Status))
2145 {
2146 return;
2147 }
2148 break;
2149
2150 case ACPI_PMTT_TYPE_DIMM:
2151 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2152 Subtable->Length, AcpiDmTableInfoPmtt2);
2153 if (ACPI_FAILURE (Status))
2154 {
2155 return;
2156 }
2157 break;
2158
2159 case ACPI_PMTT_TYPE_VENDOR:
2160 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2161 Subtable->Length, AcpiDmTableInfoPmttVendor);
2162 if (ACPI_FAILURE (Status))
2163 {
2164 return;
2165 }
2166 break;
2167
2168 default:
2169 AcpiOsPrintf (
2170 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2171 Subtable->Type);
2172 return;
2173 }
2174
2175 /* Point to next subtable */
2176
2177 Offset += Subtable->Length;
2178 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2179 Subtable, Subtable->Length);
2180 }
2181 }
2182
2183
2184 /*******************************************************************************
2185 *
2186 * FUNCTION: AcpiDmDumpPptt
2187 *
2188 * PARAMETERS: Table - A PMTT table
2189 *
2190 * RETURN: None
2191 *
2192 * DESCRIPTION: Format the contents of a PPTT. This table type consists
2193 * of an open-ended number of subtables.
2194 *
2195 ******************************************************************************/
2196
2197 void
AcpiDmDumpPptt(ACPI_TABLE_HEADER * Table)2198 AcpiDmDumpPptt (
2199 ACPI_TABLE_HEADER *Table)
2200 {
2201 ACPI_STATUS Status;
2202 ACPI_SUBTABLE_HEADER *Subtable;
2203 ACPI_PPTT_PROCESSOR *PpttProcessor;
2204 UINT8 Length;
2205 UINT8 SubtableOffset;
2206 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
2207 ACPI_DMTABLE_INFO *InfoTable;
2208 UINT32 i;
2209
2210
2211 /* There is no main table (other than the standard ACPI header) */
2212
2213 /* Subtables */
2214
2215 Offset = sizeof (ACPI_TABLE_HEADER);
2216 while (Offset < Table->Length)
2217 {
2218 AcpiOsPrintf ("\n");
2219
2220 /* Common subtable header */
2221
2222 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2223 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER))
2224 {
2225 AcpiOsPrintf ("Invalid subtable length\n");
2226 return;
2227 }
2228 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2229 Subtable->Length, AcpiDmTableInfoPpttHdr);
2230 if (ACPI_FAILURE (Status))
2231 {
2232 return;
2233 }
2234
2235 switch (Subtable->Type)
2236 {
2237 case ACPI_PPTT_TYPE_PROCESSOR:
2238
2239 InfoTable = AcpiDmTableInfoPptt0;
2240 Length = sizeof (ACPI_PPTT_PROCESSOR);
2241 break;
2242
2243 case ACPI_PPTT_TYPE_CACHE:
2244
2245 InfoTable = AcpiDmTableInfoPptt1;
2246 Length = sizeof (ACPI_PPTT_CACHE);
2247 break;
2248
2249 case ACPI_PPTT_TYPE_ID:
2250
2251 InfoTable = AcpiDmTableInfoPptt2;
2252 Length = sizeof (ACPI_PPTT_ID);
2253 break;
2254
2255 default:
2256
2257 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
2258 Subtable->Type);
2259
2260 /* Attempt to continue */
2261
2262 goto NextSubtable;
2263 }
2264
2265 if (Subtable->Length < Length)
2266 {
2267 AcpiOsPrintf ("Invalid subtable length\n");
2268 return;
2269 }
2270 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2271 Subtable->Length, InfoTable);
2272 if (ACPI_FAILURE (Status))
2273 {
2274 return;
2275 }
2276 SubtableOffset = Length;
2277
2278 switch (Subtable->Type)
2279 {
2280 case ACPI_PPTT_TYPE_PROCESSOR:
2281
2282 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable);
2283
2284 /* Dump SMBIOS handles */
2285
2286 if ((UINT8)(Subtable->Length - SubtableOffset) <
2287 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
2288 {
2289 AcpiOsPrintf ("Invalid private resource number\n");
2290 return;
2291 }
2292 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
2293 {
2294 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2295 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2296 4, AcpiDmTableInfoPptt0a);
2297 if (ACPI_FAILURE (Status))
2298 {
2299 return;
2300 }
2301
2302 SubtableOffset += 4;
2303 }
2304 break;
2305
2306 case ACPI_PPTT_TYPE_CACHE:
2307
2308 if (Table->Revision < 3)
2309 {
2310 break;
2311 }
2312 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2313 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2314 sizeof (ACPI_PPTT_CACHE_V1), AcpiDmTableInfoPptt1a);
2315 if (ACPI_FAILURE (Status))
2316 {
2317 return;
2318 }
2319 break;
2320
2321 default:
2322
2323 break;
2324 }
2325
2326 NextSubtable:
2327 /* Point to next subtable */
2328
2329 Offset += Subtable->Length;
2330 }
2331 }
2332
2333
2334 /*******************************************************************************
2335 *
2336 * FUNCTION: AcpiDmDumpPrmt
2337 *
2338 * PARAMETERS: Table - A PRMT table
2339 *
2340 * RETURN: None
2341 *
2342 * DESCRIPTION: Format the contents of a PRMT. This table type consists
2343 * of an open-ended number of subtables.
2344 *
2345 ******************************************************************************/
2346
2347 void
AcpiDmDumpPrmt(ACPI_TABLE_HEADER * Table)2348 AcpiDmDumpPrmt (
2349 ACPI_TABLE_HEADER *Table)
2350 {
2351 UINT32 CurrentOffset = sizeof (ACPI_TABLE_HEADER);
2352 ACPI_TABLE_PRMT_HEADER *PrmtHeader;
2353 ACPI_PRMT_MODULE_INFO *PrmtModuleInfo;
2354 ACPI_PRMT_HANDLER_INFO *PrmtHandlerInfo;
2355 ACPI_STATUS Status;
2356 UINT32 i, j;
2357
2358
2359 /* Main table header */
2360
2361 PrmtHeader = ACPI_ADD_PTR (ACPI_TABLE_PRMT_HEADER, Table, CurrentOffset);
2362 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHeader,
2363 sizeof (ACPI_TABLE_PRMT_HEADER), AcpiDmTableInfoPrmtHdr);
2364 if (ACPI_FAILURE (Status))
2365 {
2366 AcpiOsPrintf ("Invalid PRMT header\n");
2367 return;
2368 }
2369
2370 CurrentOffset += sizeof (ACPI_TABLE_PRMT_HEADER);
2371
2372 /* PRM Module Information Structure array */
2373
2374 for (i = 0; i < PrmtHeader->ModuleInfoCount; ++i)
2375 {
2376 PrmtModuleInfo = ACPI_ADD_PTR (ACPI_PRMT_MODULE_INFO, Table, CurrentOffset);
2377 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtModuleInfo,
2378 sizeof (ACPI_PRMT_MODULE_INFO), AcpiDmTableInfoPrmtModule);
2379
2380 CurrentOffset += sizeof (ACPI_PRMT_MODULE_INFO);
2381
2382 /* PRM handler information structure array */
2383
2384 for (j = 0; j < PrmtModuleInfo->HandlerInfoCount; ++j)
2385 {
2386 PrmtHandlerInfo = ACPI_ADD_PTR (ACPI_PRMT_HANDLER_INFO, Table, CurrentOffset);
2387 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHandlerInfo,
2388 sizeof (ACPI_PRMT_HANDLER_INFO), AcpiDmTableInfoPrmtHandler);
2389
2390 CurrentOffset += sizeof (ACPI_PRMT_HANDLER_INFO);
2391 }
2392 }
2393 }
2394
2395
2396 /*******************************************************************************
2397 *
2398 * FUNCTION: AcpiDmDumpRas2
2399 *
2400 * PARAMETERS: Table - A RAS2 table
2401 *
2402 * RETURN: None
2403 *
2404 * DESCRIPTION: Format the contents of a Ras2. This is a variable-length
2405 * table that contains an open-ended number of the RAS2 PCC
2406 * descriptors at the end of the table.
2407 *
2408 ******************************************************************************/
2409
2410 void
AcpiDmDumpRas2(ACPI_TABLE_HEADER * Table)2411 AcpiDmDumpRas2 (
2412 ACPI_TABLE_HEADER *Table)
2413 {
2414 ACPI_STATUS Status;
2415 ACPI_RAS2_PCC_DESC *Subtable;
2416 UINT32 Length = Table->Length;
2417 UINT32 Offset = sizeof (ACPI_TABLE_RAS2);
2418
2419
2420 /* Main table */
2421
2422 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRas2);
2423 if (ACPI_FAILURE (Status))
2424 {
2425 return;
2426 }
2427
2428 /* Subtables - RAS2 PCC descriptor list */
2429
2430 Subtable = ACPI_ADD_PTR (ACPI_RAS2_PCC_DESC, Table, Offset);
2431 while (Offset < Table->Length)
2432 {
2433 AcpiOsPrintf ("\n");
2434 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2435 sizeof (ACPI_RAS2_PCC_DESC), AcpiDmTableInfoRas2PccDesc);
2436 if (ACPI_FAILURE (Status))
2437 {
2438 return;
2439 }
2440
2441 /* Point to next subtable */
2442
2443 Offset += sizeof (ACPI_RAS2_PCC_DESC);
2444 Subtable = ACPI_ADD_PTR (ACPI_RAS2_PCC_DESC, Subtable,
2445 sizeof (ACPI_RAS2_PCC_DESC));
2446 }
2447 }
2448
2449
2450 /*******************************************************************************
2451 *
2452 * FUNCTION: AcpiDmDumpRgrt
2453 *
2454 * PARAMETERS: Table - A RGRT table
2455 *
2456 * RETURN: None
2457 *
2458 * DESCRIPTION: Format the contents of a RGRT
2459 *
2460 ******************************************************************************/
2461
2462 void
AcpiDmDumpRgrt(ACPI_TABLE_HEADER * Table)2463 AcpiDmDumpRgrt (
2464 ACPI_TABLE_HEADER *Table)
2465 {
2466 ACPI_STATUS Status;
2467 ACPI_TABLE_RGRT *Subtable = ACPI_CAST_PTR (ACPI_TABLE_RGRT, Table);
2468 UINT32 Offset = sizeof (ACPI_TABLE_RGRT);
2469
2470
2471 /* Main table */
2472
2473 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoRgrt);
2474 if (ACPI_FAILURE (Status))
2475 {
2476 return;
2477 }
2478
2479 /* Dump the binary image as a subtable */
2480
2481 Status = AcpiDmDumpTable (Table->Length, Offset, &Subtable->Image,
2482 Table->Length - Offset, AcpiDmTableInfoRgrt0);
2483 if (ACPI_FAILURE (Status))
2484 {
2485 return;
2486 }
2487 }
2488
2489
2490 /*******************************************************************************
2491 *
2492 * FUNCTION: AcpiDmDumpRhct
2493 *
2494 * PARAMETERS: Table - A RHCT table
2495 *
2496 * RETURN: None
2497 *
2498 * DESCRIPTION: Format the contents of a RHCT.
2499 *
2500 ******************************************************************************/
2501
2502 void
AcpiDmDumpRhct(ACPI_TABLE_HEADER * Table)2503 AcpiDmDumpRhct (
2504 ACPI_TABLE_HEADER *Table)
2505 {
2506 ACPI_STATUS Status;
2507 ACPI_RHCT_NODE_HEADER *Subtable;
2508 ACPI_RHCT_HART_INFO *RhctHartInfo;
2509 ACPI_RHCT_ISA_STRING *RhctIsaString;
2510 ACPI_RHCT_CMO_NODE *RhctCmoNode;
2511 ACPI_RHCT_MMU_NODE *RhctMmuNode;
2512 UINT32 Length = Table->Length;
2513 UINT8 SubtableOffset, IsaPadOffset;
2514 UINT32 Offset = sizeof (ACPI_TABLE_RHCT);
2515 UINT32 i;
2516
2517 /* Main table */
2518
2519 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRhct);
2520 if (ACPI_FAILURE (Status))
2521 {
2522 return;
2523 }
2524
2525 /* Subtables */
2526
2527 while (Offset < Table->Length)
2528 {
2529 AcpiOsPrintf ("\n");
2530
2531 /* Common subtable header */
2532
2533 Subtable = ACPI_ADD_PTR (ACPI_RHCT_NODE_HEADER, Table, Offset);
2534 if (Subtable->Length < sizeof (ACPI_RHCT_NODE_HEADER))
2535 {
2536 AcpiOsPrintf ("Invalid subtable length\n");
2537 return;
2538 }
2539 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2540 Subtable->Length, AcpiDmTableInfoRhctNodeHdr);
2541 if (ACPI_FAILURE (Status))
2542 {
2543 return;
2544 }
2545
2546 Length = sizeof (ACPI_RHCT_NODE_HEADER);
2547
2548 if (Subtable->Length < Length)
2549 {
2550 AcpiOsPrintf ("Invalid subtable length\n");
2551 return;
2552 }
2553 SubtableOffset = (UINT8) Length;
2554
2555 switch (Subtable->Type)
2556 {
2557 case ACPI_RHCT_NODE_TYPE_HART_INFO:
2558 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2559 ACPI_ADD_PTR (ACPI_RHCT_HART_INFO, Subtable, SubtableOffset),
2560 sizeof (ACPI_RHCT_HART_INFO), AcpiDmTableInfoRhctHartInfo1);
2561
2562 RhctHartInfo = ACPI_ADD_PTR (ACPI_RHCT_HART_INFO, Subtable, SubtableOffset);
2563
2564 if ((UINT16)(Subtable->Length - SubtableOffset) <
2565 (UINT16)(RhctHartInfo->NumOffsets * 4))
2566 {
2567 AcpiOsPrintf ("Invalid number of offsets\n");
2568 return;
2569 }
2570 SubtableOffset += sizeof (ACPI_RHCT_HART_INFO);
2571 for (i = 0; i < RhctHartInfo->NumOffsets; i++)
2572 {
2573 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2574 ACPI_ADD_PTR (UINT32, Subtable, SubtableOffset),
2575 4, AcpiDmTableInfoRhctHartInfo2);
2576 if (ACPI_FAILURE (Status))
2577 {
2578 return;
2579 }
2580
2581 SubtableOffset += 4;
2582 }
2583 break;
2584
2585 case ACPI_RHCT_NODE_TYPE_ISA_STRING:
2586 RhctIsaString = ACPI_ADD_PTR (ACPI_RHCT_ISA_STRING, Subtable, SubtableOffset);
2587 IsaPadOffset = (UINT8) (SubtableOffset + 2 + RhctIsaString->IsaLength);
2588 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2589 RhctIsaString, RhctIsaString->IsaLength, AcpiDmTableInfoRhctIsa1);
2590 if (Subtable->Length > IsaPadOffset)
2591 {
2592 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2593 ACPI_ADD_PTR (UINT8, Subtable, IsaPadOffset),
2594 (Subtable->Length - IsaPadOffset), AcpiDmTableInfoRhctIsaPad);
2595 }
2596
2597 break;
2598
2599 case ACPI_RHCT_NODE_TYPE_CMO:
2600 RhctCmoNode = ACPI_ADD_PTR (ACPI_RHCT_CMO_NODE, Subtable, SubtableOffset);
2601 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2602 RhctCmoNode, 4, AcpiDmTableInfoRhctCmo1);
2603 break;
2604
2605 case ACPI_RHCT_NODE_TYPE_MMU:
2606 RhctMmuNode = ACPI_ADD_PTR (ACPI_RHCT_MMU_NODE, Subtable, SubtableOffset);
2607 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2608 RhctMmuNode, 2, AcpiDmTableInfoRhctMmu1);
2609 break;
2610
2611 default:
2612 break;
2613 }
2614
2615 /* Point to next subtable */
2616
2617 Offset += Subtable->Length;
2618 }
2619 }
2620
2621
2622 /*******************************************************************************
2623 *
2624 * FUNCTION: AcpiDmDumpS3pt
2625 *
2626 * PARAMETERS: Table - A S3PT table
2627 *
2628 * RETURN: Length of the table
2629 *
2630 * DESCRIPTION: Format the contents of a S3PT
2631 *
2632 ******************************************************************************/
2633
2634 UINT32
AcpiDmDumpS3pt(ACPI_TABLE_HEADER * Tables)2635 AcpiDmDumpS3pt (
2636 ACPI_TABLE_HEADER *Tables)
2637 {
2638 ACPI_STATUS Status;
2639 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
2640 ACPI_FPDT_HEADER *Subtable;
2641 ACPI_DMTABLE_INFO *InfoTable;
2642 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
2643
2644
2645 /* Main table */
2646
2647 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
2648 if (ACPI_FAILURE (Status))
2649 {
2650 return 0;
2651 }
2652
2653 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
2654 while (Offset < S3ptTable->Length)
2655 {
2656 /* Common subtable header */
2657
2658 AcpiOsPrintf ("\n");
2659 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
2660 Subtable->Length, AcpiDmTableInfoS3ptHdr);
2661 if (ACPI_FAILURE (Status))
2662 {
2663 return 0;
2664 }
2665
2666 switch (Subtable->Type)
2667 {
2668 case ACPI_S3PT_TYPE_RESUME:
2669
2670 InfoTable = AcpiDmTableInfoS3pt0;
2671 break;
2672
2673 case ACPI_S3PT_TYPE_SUSPEND:
2674
2675 InfoTable = AcpiDmTableInfoS3pt1;
2676 break;
2677
2678 default:
2679
2680 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
2681 Subtable->Type);
2682
2683 /* Attempt to continue */
2684
2685 if (!Subtable->Length)
2686 {
2687 AcpiOsPrintf ("Invalid zero length subtable\n");
2688 return 0;
2689 }
2690 goto NextSubtable;
2691 }
2692
2693 AcpiOsPrintf ("\n");
2694 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
2695 Subtable->Length, InfoTable);
2696 if (ACPI_FAILURE (Status))
2697 {
2698 return 0;
2699 }
2700
2701 NextSubtable:
2702 /* Point to next subtable */
2703
2704 Offset += Subtable->Length;
2705 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length);
2706 }
2707
2708 return (S3ptTable->Length);
2709 }
2710
2711
2712 /*******************************************************************************
2713 *
2714 * FUNCTION: AcpiDmDumpSdev
2715 *
2716 * PARAMETERS: Table - A SDEV table
2717 *
2718 * RETURN: None
2719 *
2720 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length
2721 * table that contains variable strings and vendor data.
2722 *
2723 ******************************************************************************/
2724
2725 void
AcpiDmDumpSdev(ACPI_TABLE_HEADER * Table)2726 AcpiDmDumpSdev (
2727 ACPI_TABLE_HEADER *Table)
2728 {
2729 ACPI_STATUS Status;
2730 ACPI_SDEV_HEADER *Subtable;
2731 ACPI_SDEV_PCIE *Pcie;
2732 ACPI_SDEV_NAMESPACE *Namesp;
2733 ACPI_DMTABLE_INFO *InfoTable;
2734 ACPI_DMTABLE_INFO *SecureComponentInfoTable;
2735 UINT32 Length = Table->Length;
2736 UINT32 Offset = sizeof (ACPI_TABLE_SDEV);
2737 UINT16 PathOffset;
2738 UINT16 PathLength;
2739 UINT16 VendorDataOffset;
2740 UINT16 VendorDataLength;
2741 ACPI_SDEV_SECURE_COMPONENT *SecureComponent = NULL;
2742 UINT32 CurrentOffset = 0;
2743
2744
2745 /* Main table */
2746
2747 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev);
2748 if (ACPI_FAILURE (Status))
2749 {
2750 return;
2751 }
2752
2753 /* Subtables */
2754
2755 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset);
2756 while (Offset < Table->Length)
2757 {
2758 /* Common subtable header */
2759
2760 AcpiOsPrintf ("\n");
2761 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2762 Subtable->Length, AcpiDmTableInfoSdevHdr);
2763 if (ACPI_FAILURE (Status))
2764 {
2765 return;
2766 }
2767
2768 switch (Subtable->Type)
2769 {
2770 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
2771
2772 InfoTable = AcpiDmTableInfoSdev0;
2773 break;
2774
2775 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
2776
2777 InfoTable = AcpiDmTableInfoSdev1;
2778 break;
2779
2780 default:
2781 goto NextSubtable;
2782 }
2783
2784 AcpiOsPrintf ("\n");
2785 Status = AcpiDmDumpTable (Table->Length, 0, Subtable,
2786 Subtable->Length, InfoTable);
2787 if (ACPI_FAILURE (Status))
2788 {
2789 return;
2790 }
2791
2792 switch (Subtable->Type)
2793 {
2794 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
2795
2796 CurrentOffset = sizeof (ACPI_SDEV_NAMESPACE);
2797 if (Subtable->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT)
2798 {
2799 SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT,
2800 ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)));
2801
2802 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2803 ACPI_ADD_PTR(UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)),
2804 sizeof (ACPI_SDEV_SECURE_COMPONENT), AcpiDmTableInfoSdev0b);
2805 if (ACPI_FAILURE (Status))
2806 {
2807 return;
2808 }
2809 CurrentOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT);
2810
2811 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2812 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
2813 sizeof (ACPI_SDEV_HEADER), AcpiDmTableInfoSdevSecCompHdr);
2814 if (ACPI_FAILURE (Status))
2815 {
2816 return;
2817 }
2818 CurrentOffset += sizeof (ACPI_SDEV_HEADER);
2819
2820 switch (Subtable->Type)
2821 {
2822 case ACPI_SDEV_TYPE_ID_COMPONENT:
2823
2824 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId;
2825 break;
2826
2827 case ACPI_SDEV_TYPE_MEM_COMPONENT:
2828
2829 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem;
2830 break;
2831
2832 default:
2833 goto NextSubtable;
2834 }
2835
2836 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2837 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
2838 SecureComponent->SecureComponentLength, SecureComponentInfoTable);
2839 CurrentOffset += SecureComponent->SecureComponentLength;
2840 }
2841
2842 /* Dump the PCIe device ID(s) */
2843
2844 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable);
2845 PathOffset = Namesp->DeviceIdOffset;
2846 PathLength = Namesp->DeviceIdLength;
2847
2848 if (PathLength)
2849 {
2850 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2851 ACPI_ADD_PTR (UINT8, Namesp, PathOffset),
2852 PathLength, AcpiDmTableInfoSdev0a);
2853 if (ACPI_FAILURE (Status))
2854 {
2855 return;
2856 }
2857 CurrentOffset += PathLength;
2858 }
2859
2860 /* Dump the vendor-specific data */
2861
2862 VendorDataLength =
2863 Namesp->VendorDataLength;
2864 VendorDataOffset =
2865 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
2866
2867 if (VendorDataLength)
2868 {
2869 Status = AcpiDmDumpTable (Table->Length, 0,
2870 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset),
2871 VendorDataLength, AcpiDmTableInfoSdev1b);
2872 if (ACPI_FAILURE (Status))
2873 {
2874 return;
2875 }
2876 }
2877 break;
2878
2879 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
2880
2881 /* PCI path substructures */
2882
2883 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable);
2884 PathOffset = Pcie->PathOffset;
2885 PathLength = Pcie->PathLength;
2886
2887 while (PathLength)
2888 {
2889 Status = AcpiDmDumpTable (Table->Length,
2890 PathOffset + Offset,
2891 ACPI_ADD_PTR (UINT8, Pcie, PathOffset),
2892 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a);
2893 if (ACPI_FAILURE (Status))
2894 {
2895 return;
2896 }
2897
2898 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH);
2899 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH);
2900 }
2901
2902 /* VendorData */
2903
2904 VendorDataLength = Pcie->VendorDataLength;
2905 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength;
2906
2907 if (VendorDataLength)
2908 {
2909 Status = AcpiDmDumpTable (Table->Length, 0,
2910 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset),
2911 VendorDataLength, AcpiDmTableInfoSdev1b);
2912 if (ACPI_FAILURE (Status))
2913 {
2914 return;
2915 }
2916 }
2917 break;
2918
2919 default:
2920 goto NextSubtable;
2921 }
2922
2923 NextSubtable:
2924 /* Point to next subtable */
2925
2926 Offset += Subtable->Length;
2927 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable,
2928 Subtable->Length);
2929 }
2930 }
2931