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 - 2023, 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 "acpi.h"
154 #include "accommon.h"
155 #include "acdisasm.h"
156 #include "actables.h"
157 #include "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
879
880 /* Main table */
881
882 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
883 if (ACPI_FAILURE (Status))
884 {
885 return;
886 }
887
888 /* Subtables */
889
890 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
891 DbgPrint (ASL_PARSE_OUTPUT, "//0B) Offset %X, from table start: 0x%8.8X%8.8X\n",
892 Offset, ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table)));
893 while (Offset < Table->Length)
894 {
895 /* Common subtable header */
896
897 AcpiOsPrintf ("\n");
898 Status = AcpiDmDumpTable (Length, Offset, Subtable,
899 Subtable->Length, AcpiDmTableInfoMadtHdr);
900 if (ACPI_FAILURE (Status))
901 {
902 return;
903 }
904
905 DbgPrint (ASL_PARSE_OUTPUT, "subtableType: %X\n", Subtable->Type);
906 switch (Subtable->Type)
907 {
908 case ACPI_MADT_TYPE_LOCAL_APIC:
909
910 InfoTable = AcpiDmTableInfoMadt0;
911 break;
912
913 case ACPI_MADT_TYPE_IO_APIC:
914
915 InfoTable = AcpiDmTableInfoMadt1;
916 break;
917
918 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
919
920 InfoTable = AcpiDmTableInfoMadt2;
921 break;
922
923 case ACPI_MADT_TYPE_NMI_SOURCE:
924
925 InfoTable = AcpiDmTableInfoMadt3;
926 break;
927
928 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
929
930 InfoTable = AcpiDmTableInfoMadt4;
931 break;
932
933 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
934
935 InfoTable = AcpiDmTableInfoMadt5;
936 break;
937
938 case ACPI_MADT_TYPE_IO_SAPIC:
939
940 InfoTable = AcpiDmTableInfoMadt6;
941 break;
942
943 case ACPI_MADT_TYPE_LOCAL_SAPIC:
944
945 InfoTable = AcpiDmTableInfoMadt7;
946 break;
947
948 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
949
950 InfoTable = AcpiDmTableInfoMadt8;
951 break;
952
953 case ACPI_MADT_TYPE_LOCAL_X2APIC:
954
955 InfoTable = AcpiDmTableInfoMadt9;
956 break;
957
958 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
959
960 InfoTable = AcpiDmTableInfoMadt10;
961 break;
962
963 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
964
965 InfoTable = AcpiDmTableInfoMadt11;
966 break;
967
968 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
969
970 InfoTable = AcpiDmTableInfoMadt12;
971 break;
972
973 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
974
975 InfoTable = AcpiDmTableInfoMadt13;
976 break;
977
978 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
979
980 InfoTable = AcpiDmTableInfoMadt14;
981 break;
982
983 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
984
985 InfoTable = AcpiDmTableInfoMadt15;
986 break;
987
988 case ACPI_MADT_TYPE_MULTIPROC_WAKEUP:
989
990 InfoTable = AcpiDmTableInfoMadt16;
991 break;
992
993 case ACPI_MADT_TYPE_CORE_PIC:
994
995 InfoTable = AcpiDmTableInfoMadt17;
996 break;
997
998 case ACPI_MADT_TYPE_LIO_PIC:
999
1000 InfoTable = AcpiDmTableInfoMadt18;
1001 break;
1002
1003 case ACPI_MADT_TYPE_HT_PIC:
1004
1005 InfoTable = AcpiDmTableInfoMadt19;
1006 break;
1007
1008 case ACPI_MADT_TYPE_EIO_PIC:
1009
1010 InfoTable = AcpiDmTableInfoMadt20;
1011 break;
1012
1013 case ACPI_MADT_TYPE_MSI_PIC:
1014
1015 InfoTable = AcpiDmTableInfoMadt21;
1016 break;
1017
1018 case ACPI_MADT_TYPE_BIO_PIC:
1019
1020 InfoTable = AcpiDmTableInfoMadt22;
1021 break;
1022
1023 case ACPI_MADT_TYPE_LPC_PIC:
1024
1025 InfoTable = AcpiDmTableInfoMadt23;
1026 break;
1027
1028 case ACPI_MADT_TYPE_RINTC:
1029
1030 InfoTable = AcpiDmTableInfoMadt24;
1031 break;
1032
1033 case ACPI_MADT_TYPE_IMSIC:
1034
1035 InfoTable = AcpiDmTableInfoMadt25;
1036 break;
1037
1038 case ACPI_MADT_TYPE_APLIC:
1039
1040 InfoTable = AcpiDmTableInfoMadt26;
1041 break;
1042
1043 case ACPI_MADT_TYPE_PLIC:
1044
1045 InfoTable = AcpiDmTableInfoMadt27;
1046 break;
1047
1048 default:
1049
1050 if ((Subtable->Type >= ACPI_MADT_TYPE_RESERVED) &&
1051 (Subtable->Type < ACPI_MADT_TYPE_OEM_RESERVED))
1052 {
1053 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
1054 Subtable->Type);
1055 goto NextSubtable;
1056 }
1057 else if (Subtable->Type >= ACPI_MADT_TYPE_OEM_RESERVED)
1058 {
1059 DbgPrint (ASL_PARSE_OUTPUT, "//[Found an OEM structure, type = %0x]\n",
1060 Subtable->Type);
1061 Offset += sizeof (ACPI_SUBTABLE_HEADER);
1062 DbgPrint (ASL_PARSE_OUTPUT, "//[0) Subtable->Length = %X, Subtable = %p, Offset = %X]\n",
1063 Subtable->Length, Subtable, Offset);
1064 DbgPrint (ASL_PARSE_OUTPUT, "//[0A) Offset from table start: 0x%8.8X%8.8X]\n",
1065 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table)));
1066 }
1067
1068 /* Attempt to continue */
1069
1070 if (!Subtable->Length)
1071 {
1072 AcpiOsPrintf ("Invalid zero length subtable\n");
1073 return;
1074 }
1075
1076 /* Dump the OEM data */
1077
1078 Status = AcpiDmDumpTable (Length, Offset, ACPI_CAST_PTR (UINT8, Table) + Offset,
1079 Subtable->Length - sizeof (ACPI_SUBTABLE_HEADER), AcpiDmTableInfoMadt128);
1080 if (ACPI_FAILURE (Status))
1081 {
1082 return;
1083 }
1084
1085 DbgPrint (ASL_PARSE_OUTPUT, "//[1) Subtable->Length = %X, Offset = %X]\n",
1086 Subtable->Length, Offset);
1087 Offset -= sizeof (ACPI_SUBTABLE_HEADER);
1088
1089 goto NextSubtable;
1090 }
1091
1092 DbgPrint (ASL_PARSE_OUTPUT, "//[2) Subtable->Length = %X, Offset = %X]\n",
1093 Subtable->Length, Offset);
1094 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1095 Subtable->Length, InfoTable);
1096 if (ACPI_FAILURE (Status))
1097 {
1098 return;
1099 }
1100
1101 NextSubtable:
1102 /* Point to next subtable */
1103
1104 DbgPrint (ASL_PARSE_OUTPUT, "//[3) Subtable->Length = %X, Offset = %X]\n",
1105 Subtable->Length, Offset);
1106 DbgPrint (ASL_PARSE_OUTPUT, "//[4) Offset from table start: 0x%8.8X%8.8X (%p) %p]\n",
1107 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (UINT8, Subtable) - ACPI_CAST_PTR (UINT8, Table)), Subtable, Table);
1108 if (Offset > Table->Length)
1109 {
1110 return;
1111 }
1112
1113 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable,
1114 Subtable->Length);
1115
1116 Offset = ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table);
1117 if (Offset >= Table->Length)
1118 {
1119 return;
1120 }
1121
1122 DbgPrint (ASL_PARSE_OUTPUT, "//[5) Next Subtable %p, length %X]\n",
1123 Subtable, Subtable->Length);
1124 DbgPrint (ASL_PARSE_OUTPUT, "//[5B) Offset from table start: 0x%8.8X%8.8X (%p)]\n",
1125 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table)), Subtable);
1126 }
1127 }
1128
1129
1130 /*******************************************************************************
1131 *
1132 * FUNCTION: AcpiDmDumpMcfg
1133 *
1134 * PARAMETERS: Table - A MCFG Table
1135 *
1136 * RETURN: None
1137 *
1138 * DESCRIPTION: Format the contents of a MCFG table
1139 *
1140 ******************************************************************************/
1141
1142 void
AcpiDmDumpMcfg(ACPI_TABLE_HEADER * Table)1143 AcpiDmDumpMcfg (
1144 ACPI_TABLE_HEADER *Table)
1145 {
1146 ACPI_STATUS Status;
1147 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
1148 ACPI_MCFG_ALLOCATION *Subtable;
1149
1150
1151 /* Main table */
1152
1153 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1154 if (ACPI_FAILURE (Status))
1155 {
1156 return;
1157 }
1158
1159 /* Subtables */
1160
1161 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1162 while (Offset < Table->Length)
1163 {
1164 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1165 {
1166 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1167 (UINT32) sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1168 return;
1169 }
1170
1171 AcpiOsPrintf ("\n");
1172 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1173 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1174 if (ACPI_FAILURE (Status))
1175 {
1176 return;
1177 }
1178
1179 /* Point to next subtable (each subtable is of fixed length) */
1180
1181 Offset += sizeof (ACPI_MCFG_ALLOCATION);
1182 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable,
1183 sizeof (ACPI_MCFG_ALLOCATION));
1184 }
1185 }
1186
1187 /*******************************************************************************
1188 *
1189 * FUNCTION: AcpiDmDumpMpam
1190 *
1191 * PARAMETERS: Table - A MPAM table
1192 *
1193 * RETURN: None
1194 *
1195 * DESCRIPTION: Format the contents of a MPAM table
1196 *
1197 ******************************************************************************/
1198
1199 void
AcpiDmDumpMpam(ACPI_TABLE_HEADER * Table)1200 AcpiDmDumpMpam (
1201 ACPI_TABLE_HEADER *Table)
1202 {
1203 ACPI_STATUS Status;
1204 ACPI_MPAM_MSC_NODE *MpamMscNode;
1205 ACPI_MPAM_RESOURCE_NODE *MpamResourceNode;
1206 ACPI_DMTABLE_INFO *InfoTable;
1207 UINT32 Offset = sizeof(ACPI_TABLE_HEADER);
1208 UINT32 MpamResourceNodeLength = 0;
1209
1210 while (Offset < Table->Length)
1211 {
1212 MpamMscNode = ACPI_ADD_PTR (ACPI_MPAM_MSC_NODE, Table, Offset);
1213
1214 /* Subtable: MSC */
1215 Status = AcpiDmDumpTable (MpamMscNode->Length, 0, MpamMscNode, 0,
1216 AcpiDmTableInfoMpam0);
1217 if (ACPI_FAILURE (Status))
1218 {
1219 return;
1220 }
1221
1222 /* Offset the start of the array of resources */
1223 Offset += sizeof(ACPI_MPAM_MSC_NODE);
1224
1225 /* Subtable: MSC RIS(es) */
1226 for (UINT32 ResourceIdx = 0; ResourceIdx < MpamMscNode->NumResouceNodes; ResourceIdx++)
1227 {
1228 MpamResourceNode = ACPI_ADD_PTR (ACPI_MPAM_RESOURCE_NODE, Table, Offset);
1229
1230 MpamResourceNodeLength = sizeof(ACPI_MPAM_RESOURCE_NODE) +
1231 MpamResourceNode->NumFunctionalDeps * sizeof(ACPI_MPAM_FUNC_DEPS);
1232
1233 Offset += MpamResourceNodeLength;
1234
1235 /* Subtable: MSC RIS */
1236 Status = AcpiDmDumpTable (MpamResourceNodeLength, 0, MpamResourceNode, 0,
1237 AcpiDmTableInfoMpam1);
1238 if (ACPI_FAILURE (Status))
1239 {
1240 return;
1241 }
1242
1243 switch (MpamResourceNode->LocatorType)
1244 {
1245 case ACPI_MPAM_LOCATION_TYPE_PROCESSOR_CACHE:
1246 InfoTable = AcpiDmTableInfoMpam1A;
1247 break;
1248 case ACPI_MPAM_LOCATION_TYPE_MEMORY:
1249 InfoTable = AcpiDmTableInfoMpam1B;
1250 break;
1251 case ACPI_MPAM_LOCATION_TYPE_SMMU:
1252 InfoTable = AcpiDmTableInfoMpam1C;
1253 break;
1254 case ACPI_MPAM_LOCATION_TYPE_MEMORY_CACHE:
1255 InfoTable = AcpiDmTableInfoMpam1D;
1256 break;
1257 case ACPI_MPAM_LOCATION_TYPE_ACPI_DEVICE:
1258 InfoTable = AcpiDmTableInfoMpam1E;
1259 break;
1260 case ACPI_MPAM_LOCATION_TYPE_INTERCONNECT:
1261 InfoTable = AcpiDmTableInfoMpam1F;
1262 break;
1263 case ACPI_MPAM_LOCATION_TYPE_UNKNOWN:
1264 InfoTable = AcpiDmTableInfoMpam1G;
1265 default:
1266 AcpiOsPrintf ("\n**** Unknown MPAM locator type 0x%X\n",
1267 MpamResourceNode->LocatorType);
1268 return;
1269 }
1270
1271 /* Subtable: MSC Resource Locator(s) */
1272 Status = AcpiDmDumpTable (sizeof(ACPI_MPAM_RESOURCE_LOCATOR), 0,
1273 &MpamResourceNode->Locator, 0, InfoTable);
1274 if (ACPI_FAILURE (Status))
1275 {
1276 return;
1277 }
1278
1279 /* Get the number of functional dependencies of an RIS */
1280 Status = AcpiDmDumpTable (sizeof(UINT32), 0, &MpamResourceNode->NumFunctionalDeps, 0,
1281 AcpiDmTableInfoMpam1Deps);
1282 if (ACPI_FAILURE (Status))
1283 {
1284 return;
1285 }
1286
1287 /* Subtable: MSC functional dependencies */
1288 for (UINT32 funcDep = 0; funcDep < MpamResourceNode->NumFunctionalDeps; funcDep++)
1289 {
1290 Status = AcpiDmDumpTable (sizeof(ACPI_MPAM_FUNC_DEPS), 0,
1291 &MpamResourceNode->NumFunctionalDeps, 0, AcpiDmTableInfoMpam2);
1292 if (ACPI_FAILURE (Status))
1293 {
1294 return;
1295 }
1296 }
1297
1298 AcpiOsPrintf ("\n\n");
1299 }
1300
1301 }
1302
1303 return;
1304 }
1305
1306 /*******************************************************************************
1307 *
1308 * FUNCTION: AcpiDmDumpMpst
1309 *
1310 * PARAMETERS: Table - A MPST Table
1311 *
1312 * RETURN: None
1313 *
1314 * DESCRIPTION: Format the contents of a MPST table
1315 *
1316 ******************************************************************************/
1317
1318 void
AcpiDmDumpMpst(ACPI_TABLE_HEADER * Table)1319 AcpiDmDumpMpst (
1320 ACPI_TABLE_HEADER *Table)
1321 {
1322 ACPI_STATUS Status;
1323 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
1324 ACPI_MPST_POWER_NODE *Subtable0;
1325 ACPI_MPST_POWER_STATE *Subtable0A;
1326 ACPI_MPST_COMPONENT *Subtable0B;
1327 ACPI_MPST_DATA_HDR *Subtable1;
1328 ACPI_MPST_POWER_DATA *Subtable2;
1329 UINT16 SubtableCount;
1330 UINT32 PowerStateCount;
1331 UINT32 ComponentCount;
1332
1333
1334 /* Main table */
1335
1336 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
1337 if (ACPI_FAILURE (Status))
1338 {
1339 return;
1340 }
1341
1342 /* Subtable: Memory Power Node(s) */
1343
1344 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
1345 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
1346
1347 while ((Offset < Table->Length) && SubtableCount)
1348 {
1349 AcpiOsPrintf ("\n");
1350 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0,
1351 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
1352 if (ACPI_FAILURE (Status))
1353 {
1354 return;
1355 }
1356
1357 /* Extract the sub-subtable counts */
1358
1359 PowerStateCount = Subtable0->NumPowerStates;
1360 ComponentCount = Subtable0->NumPhysicalComponents;
1361 Offset += sizeof (ACPI_MPST_POWER_NODE);
1362
1363 /* Sub-subtables - Memory Power State Structure(s) */
1364
1365 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0,
1366 sizeof (ACPI_MPST_POWER_NODE));
1367
1368 while (PowerStateCount)
1369 {
1370 AcpiOsPrintf ("\n");
1371 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A,
1372 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
1373 if (ACPI_FAILURE (Status))
1374 {
1375 return;
1376 }
1377
1378 Subtable0A++;
1379 PowerStateCount--;
1380 Offset += sizeof (ACPI_MPST_POWER_STATE);
1381 }
1382
1383 /* Sub-subtables - Physical Component ID Structure(s) */
1384
1385 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A);
1386
1387 if (ComponentCount)
1388 {
1389 AcpiOsPrintf ("\n");
1390 }
1391
1392 while (ComponentCount)
1393 {
1394 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B,
1395 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
1396 if (ACPI_FAILURE (Status))
1397 {
1398 return;
1399 }
1400
1401 Subtable0B++;
1402 ComponentCount--;
1403 Offset += sizeof (ACPI_MPST_COMPONENT);
1404 }
1405
1406 /* Point to next Memory Power Node subtable */
1407
1408 SubtableCount--;
1409 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0,
1410 sizeof (ACPI_MPST_POWER_NODE) +
1411 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) +
1412 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents));
1413 }
1414
1415 /* Subtable: Count of Memory Power State Characteristic structures */
1416
1417 AcpiOsPrintf ("\n");
1418 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0);
1419 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1,
1420 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1421 if (ACPI_FAILURE (Status))
1422 {
1423 return;
1424 }
1425
1426 SubtableCount = Subtable1->CharacteristicsCount;
1427 Offset += sizeof (ACPI_MPST_DATA_HDR);
1428
1429 /* Subtable: Memory Power State Characteristics structure(s) */
1430
1431 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1,
1432 sizeof (ACPI_MPST_DATA_HDR));
1433
1434 while ((Offset < Table->Length) && SubtableCount)
1435 {
1436 AcpiOsPrintf ("\n");
1437 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2,
1438 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1439 if (ACPI_FAILURE (Status))
1440 {
1441 return;
1442 }
1443
1444 Subtable2++;
1445 SubtableCount--;
1446 Offset += sizeof (ACPI_MPST_POWER_DATA);
1447 }
1448 }
1449
1450
1451 /*******************************************************************************
1452 *
1453 * FUNCTION: AcpiDmDumpMsct
1454 *
1455 * PARAMETERS: Table - A MSCT table
1456 *
1457 * RETURN: None
1458 *
1459 * DESCRIPTION: Format the contents of a MSCT
1460 *
1461 ******************************************************************************/
1462
1463 void
AcpiDmDumpMsct(ACPI_TABLE_HEADER * Table)1464 AcpiDmDumpMsct (
1465 ACPI_TABLE_HEADER *Table)
1466 {
1467 ACPI_STATUS Status;
1468 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1469 ACPI_MSCT_PROXIMITY *Subtable;
1470
1471
1472 /* Main table */
1473
1474 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1475 if (ACPI_FAILURE (Status))
1476 {
1477 return;
1478 }
1479
1480 /* Subtables */
1481
1482 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1483 while (Offset < Table->Length)
1484 {
1485 /* Common subtable header */
1486
1487 AcpiOsPrintf ("\n");
1488 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1489 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1490 if (ACPI_FAILURE (Status))
1491 {
1492 return;
1493 }
1494
1495 /* Point to next subtable */
1496
1497 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1498 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable,
1499 sizeof (ACPI_MSCT_PROXIMITY));
1500 }
1501 }
1502
1503
1504 /*******************************************************************************
1505 *
1506 * FUNCTION: AcpiDmDumpNfit
1507 *
1508 * PARAMETERS: Table - A NFIT table
1509 *
1510 * RETURN: None
1511 *
1512 * DESCRIPTION: Format the contents of an NFIT.
1513 *
1514 ******************************************************************************/
1515
1516 void
AcpiDmDumpNfit(ACPI_TABLE_HEADER * Table)1517 AcpiDmDumpNfit (
1518 ACPI_TABLE_HEADER *Table)
1519 {
1520 ACPI_STATUS Status;
1521 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
1522 UINT32 FieldOffset = 0;
1523 UINT32 Length;
1524 ACPI_NFIT_HEADER *Subtable;
1525 ACPI_DMTABLE_INFO *InfoTable;
1526 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
1527 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
1528 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
1529 UINT32 i;
1530
1531
1532 /* Main table */
1533
1534 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
1535 if (ACPI_FAILURE (Status))
1536 {
1537 return;
1538 }
1539
1540 /* Subtables */
1541
1542 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
1543 while (Offset < Table->Length)
1544 {
1545 /* NFIT subtable header */
1546
1547 AcpiOsPrintf ("\n");
1548 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1549 Subtable->Length, AcpiDmTableInfoNfitHdr);
1550 if (ACPI_FAILURE (Status))
1551 {
1552 return;
1553 }
1554
1555 switch (Subtable->Type)
1556 {
1557 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1558
1559 InfoTable = AcpiDmTableInfoNfit0;
1560 break;
1561
1562 case ACPI_NFIT_TYPE_MEMORY_MAP:
1563
1564 InfoTable = AcpiDmTableInfoNfit1;
1565 break;
1566
1567 case ACPI_NFIT_TYPE_INTERLEAVE:
1568
1569 /* Has a variable number of 32-bit values at the end */
1570
1571 InfoTable = AcpiDmTableInfoNfit2;
1572 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
1573 break;
1574
1575 case ACPI_NFIT_TYPE_SMBIOS:
1576
1577 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable);
1578 InfoTable = AcpiDmTableInfoNfit3;
1579 break;
1580
1581 case ACPI_NFIT_TYPE_CONTROL_REGION:
1582
1583 InfoTable = AcpiDmTableInfoNfit4;
1584 break;
1585
1586 case ACPI_NFIT_TYPE_DATA_REGION:
1587
1588 InfoTable = AcpiDmTableInfoNfit5;
1589 break;
1590
1591 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1592
1593 /* Has a variable number of 64-bit addresses at the end */
1594
1595 InfoTable = AcpiDmTableInfoNfit6;
1596 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS);
1597 break;
1598
1599 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */
1600
1601 InfoTable = AcpiDmTableInfoNfit7;
1602 break;
1603
1604 default:
1605 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
1606 Subtable->Type);
1607
1608 /* Attempt to continue */
1609
1610 if (!Subtable->Length)
1611 {
1612 AcpiOsPrintf ("Invalid zero length subtable\n");
1613 return;
1614 }
1615 goto NextSubtable;
1616 }
1617
1618 AcpiOsPrintf ("\n");
1619 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1620 Subtable->Length, InfoTable);
1621 if (ACPI_FAILURE (Status))
1622 {
1623 return;
1624 }
1625
1626 /* Per-subtable variable-length fields */
1627
1628 switch (Subtable->Type)
1629 {
1630 case ACPI_NFIT_TYPE_INTERLEAVE:
1631
1632 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable);
1633 for (i = 0; i < Interleave->LineCount; i++)
1634 {
1635 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1636 &Interleave->LineOffset[i],
1637 sizeof (UINT32), AcpiDmTableInfoNfit2a);
1638 if (ACPI_FAILURE (Status))
1639 {
1640 return;
1641 }
1642
1643 FieldOffset += sizeof (UINT32);
1644 }
1645 break;
1646
1647 case ACPI_NFIT_TYPE_SMBIOS:
1648
1649 Length = Subtable->Length -
1650 sizeof (ACPI_NFIT_SMBIOS);
1651
1652 if (Length)
1653 {
1654 Status = AcpiDmDumpTable (Table->Length,
1655 sizeof (ACPI_NFIT_SMBIOS),
1656 SmbiosInfo,
1657 Length, AcpiDmTableInfoNfit3a);
1658 if (ACPI_FAILURE (Status))
1659 {
1660 return;
1661 }
1662 }
1663
1664 break;
1665
1666 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1667
1668 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable);
1669 for (i = 0; i < Hint->HintCount; i++)
1670 {
1671 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1672 &Hint->HintAddress[i],
1673 sizeof (UINT64), AcpiDmTableInfoNfit6a);
1674 if (ACPI_FAILURE (Status))
1675 {
1676 return;
1677 }
1678
1679 FieldOffset += sizeof (UINT64);
1680 }
1681 break;
1682
1683 default:
1684 break;
1685 }
1686
1687 NextSubtable:
1688 /* Point to next subtable */
1689
1690 Offset += Subtable->Length;
1691 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length);
1692 }
1693 }
1694
1695
1696 /*******************************************************************************
1697 *
1698 * FUNCTION: AcpiDmDumpNhlt
1699 *
1700 * PARAMETERS: Table - A NHLT table
1701 *
1702 * RETURN: None
1703 *
1704 * DESCRIPTION: Format the contents of an NHLT.
1705 *
1706 ******************************************************************************/
1707
1708 void
AcpiDmDumpNhlt(ACPI_TABLE_HEADER * Table)1709 AcpiDmDumpNhlt (
1710 ACPI_TABLE_HEADER *Table)
1711 {
1712 ACPI_STATUS Status;
1713 UINT32 Offset;
1714 UINT32 TableLength = Table->Length;
1715 UINT32 EndpointCount;
1716 UINT8 FormatsCount;
1717 ACPI_NHLT_ENDPOINT *Subtable;
1718 ACPI_NHLT_FORMAT_CONFIG *FormatSubtable;
1719 ACPI_TABLE_NHLT *InfoTable;
1720 UINT32 CapabilitiesSize;
1721 UINT32 i;
1722 UINT32 j;
1723 UINT32 EndpointEndOffset;
1724 UINT8 ConfigType = 0;
1725 UINT8 ArrayType;
1726 UINT8 MicrophoneCount;
1727 ACPI_NHLT_VENDOR_MIC_COUNT *MicCount;
1728 ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A *DevSpecific;
1729 ACPI_NHLT_FORMATS_CONFIG *FormatsConfig;
1730 ACPI_NHLT_DEVICE_INFO_COUNT *Count;
1731 ACPI_NHLT_DEVICE_INFO *DeviceInfo;
1732 ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B *Capabilities;
1733
1734
1735 /* Main table */
1736
1737 AcpiOsPrintf (" /* Main table */\n");
1738
1739 Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoNhlt);
1740 if (ACPI_FAILURE (Status))
1741 {
1742 return;
1743 }
1744
1745 /* Get the Endpoint Descriptor Count */
1746
1747 InfoTable = ACPI_ADD_PTR (ACPI_TABLE_NHLT, Table, 0);
1748 EndpointCount = InfoTable->EndpointCount;
1749
1750 /* Subtables */
1751
1752 Offset = sizeof (ACPI_TABLE_NHLT);
1753
1754 while (Offset < TableLength)
1755 {
1756 /* A variable number of Endpoint Descriptors - process each */
1757
1758 for (i = 0; i < EndpointCount; i++)
1759 {
1760 /* Do the Endpoint Descriptor table */
1761
1762 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1763
1764 /* Check for endpoint descriptor length beyond end-of-table */
1765
1766 if (Subtable->DescriptorLength > TableLength)
1767 {
1768 Offset += 1;
1769 AcpiOsPrintf ("\n /* Endpoint Descriptor Length larger than"
1770 " table size: %X, table %X, adjusting table offset (+1) */\n",
1771 Subtable->DescriptorLength, TableLength);
1772
1773 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1774 }
1775
1776 AcpiOsPrintf ("\n /* Endpoint Descriptor #%u */\n", i+1);
1777 Status = AcpiDmDumpTable (TableLength, Offset, Subtable,
1778 Subtable->DescriptorLength, AcpiDmTableInfoNhlt0);
1779 if (ACPI_FAILURE (Status))
1780 {
1781 return;
1782 }
1783
1784 EndpointEndOffset = Subtable->DescriptorLength + Offset;
1785
1786 /* Check for endpoint descriptor beyond end-of-table */
1787
1788 if (Subtable->DescriptorLength > TableLength)
1789 {
1790 AcpiOsPrintf ("\n /* Endpoint Descriptor Length larger than table size: %X, table %X */\n",
1791 Subtable->DescriptorLength, TableLength);
1792 }
1793
1794 Offset += sizeof (ACPI_NHLT_ENDPOINT);
1795 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1796
1797 /* Do the Device Specific table */
1798
1799 AcpiOsPrintf ("\n /* Endpoint Device_Specific_Config table */\n");
1800 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable);
1801 CapabilitiesSize = DevSpecific->CapabilitiesSize;
1802 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1803 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b);
1804 if (ACPI_FAILURE (Status))
1805 {
1806 return;
1807 }
1808
1809 ArrayType = 0;
1810
1811 /* Different subtables based upon capabilities_size */
1812
1813 switch (CapabilitiesSize)
1814 {
1815 case 0:
1816 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B);
1817 break;
1818
1819 case 1:
1820 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1821 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C), AcpiDmTableInfoNhlt5c);
1822 if (ACPI_FAILURE (Status))
1823 {
1824 return;
1825 }
1826 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C);
1827 break;
1828
1829 case 2:
1830 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1831 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt5);
1832 if (ACPI_FAILURE (Status))
1833 {
1834 return;
1835 }
1836 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG);
1837 break;
1838
1839 case 3:
1840 default:
1841 /* Extract the ConfigType and ArrayType */
1842
1843 ConfigType = DevSpecific->ConfigType;
1844 ArrayType = DevSpecific->ArrayType;
1845
1846 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1847 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A), AcpiDmTableInfoNhlt5a);
1848 if (ACPI_FAILURE (Status))
1849 {
1850 return;
1851 }
1852
1853 /* Capabilities Size == 3 */
1854 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A);
1855 break;
1856
1857 case 7:
1858 ConfigType = DevSpecific->ConfigType;
1859 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1860 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable);
1861
1862 AcpiOsPrintf ("\n /* Render Feedback Device-Specific table */\n");
1863 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1864 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt5);
1865 if (ACPI_FAILURE (Status))
1866 {
1867 return;
1868 }
1869
1870 /* Capabilities Size = 7 */
1871 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG);
1872
1873 if (ConfigType == ACPI_NHLT_CONFIG_TYPE_RENDER_FEEDBACK)
1874 {
1875 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1876 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable);
1877
1878 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1879 sizeof (ACPI_NHLT_RENDER_FEEDBACK_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt6b);
1880 if (ACPI_FAILURE (Status))
1881 {
1882 return;
1883 }
1884 Offset += sizeof (ACPI_NHLT_RENDER_FEEDBACK_DEVICE_SPECIFIC_CONFIG);
1885 }
1886 break;
1887 }
1888
1889 /* Check for a vendor-defined mic array */
1890
1891 if (ConfigType == ACPI_NHLT_CONFIG_TYPE_MIC_ARRAY)
1892 {
1893 if ((ArrayType & ACPI_NHLT_ARRAY_TYPE_MASK) == ACPI_NHLT_VENDOR_DEFINED)
1894 {
1895 /* Vendor-defined microphone array; get the microphone count first */
1896
1897 AcpiOsPrintf ("\n /* Vendor-defined microphone count */\n");
1898 MicCount = ACPI_ADD_PTR (ACPI_NHLT_VENDOR_MIC_COUNT, Table, Offset);
1899 MicrophoneCount = MicCount->MicrophoneCount;
1900
1901 Status = AcpiDmDumpTable (TableLength, Offset, MicCount,
1902 sizeof (ACPI_NHLT_VENDOR_MIC_COUNT), AcpiDmTableInfoNhlt6a);
1903 Offset += sizeof (ACPI_NHLT_VENDOR_MIC_COUNT);
1904 if (ACPI_FAILURE (Status))
1905 {
1906 return;
1907 }
1908
1909 /* Get the vendor microphone config structure(s) */
1910
1911 for (j = 0; j < MicrophoneCount; j++)
1912 {
1913 AcpiOsPrintf ("\n /* Vendor-defined microphone array #%u*/\n", j+1);
1914 DevSpecific = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Table, Offset);
1915
1916 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1917 sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG), AcpiDmTableInfoNhlt6);
1918 if (ACPI_FAILURE (Status))
1919 {
1920 return;
1921 }
1922
1923 Offset += sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG);
1924 }
1925
1926 /* Check for Microphone SNR and sensitivity extension */
1927
1928 if ((ArrayType & ACPI_NHLT_ARRAY_TYPE_EXT_MASK) == ACPI_NHLT_MIC_SNR_SENSITIVITY_EXT)
1929 {
1930 AcpiOsPrintf ("\n /* Microphone SNR and sensitivity array */\n");
1931 DevSpecific = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Table, Offset);
1932
1933 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1934 sizeof (ACPI_NHLT_MIC_SNR_SENSITIVITY_EXTENSION), AcpiDmTableInfoNhlt9);
1935 if (ACPI_FAILURE (Status))
1936 {
1937 return;
1938 }
1939
1940 Offset += sizeof (ACPI_NHLT_MIC_SNR_SENSITIVITY_EXTENSION);
1941 }
1942 }
1943 }
1944
1945 /* Do the Formats_Config table - starts with the FormatsCount field */
1946
1947 FormatsConfig = ACPI_ADD_PTR (ACPI_NHLT_FORMATS_CONFIG, Table, Offset);
1948 FormatsCount = FormatsConfig->FormatsCount;
1949
1950 AcpiOsPrintf ("\n /* Formats_Config table */\n");
1951
1952 /* Dump the FormatsCount value */
1953
1954 if (FormatsCount > 0)
1955 {
1956 Status = AcpiDmDumpTable (TableLength, Offset, FormatsConfig,
1957 sizeof (ACPI_NHLT_FORMATS_CONFIG), AcpiDmTableInfoNhlt4);
1958 if (ACPI_FAILURE (Status))
1959 {
1960 return;
1961 }
1962 }
1963 Offset += sizeof (ACPI_NHLT_FORMATS_CONFIG);
1964
1965 /* A variable number of Format_Config Descriptors - process each */
1966
1967 for (j = 0; j < FormatsCount; j++)
1968 {
1969 FormatSubtable = ACPI_ADD_PTR (ACPI_NHLT_FORMAT_CONFIG, Table, Offset);
1970 CapabilitiesSize = FormatSubtable->CapabilitySize;
1971
1972 /* Do the Wave_extensible struct */
1973
1974 AcpiOsPrintf ("\n /* Wave_Format_Extensible table #%u */\n", j+1);
1975 Status = AcpiDmDumpTable (TableLength, Offset, FormatSubtable,
1976 sizeof (ACPI_NHLT_FORMAT_CONFIG), AcpiDmTableInfoNhlt3);
1977 if (ACPI_FAILURE (Status))
1978 {
1979 return;
1980 }
1981
1982 Offset += sizeof (ACPI_NHLT_FORMAT_CONFIG);
1983
1984 if (CapabilitiesSize > 0)
1985 {
1986 UINT8* CapabilitiesBuf = ACPI_ADD_PTR (UINT8, Table, Offset);
1987 /* Do the Capabilities array (of bytes) */
1988
1989 AcpiOsPrintf ("\n /* Specific_Config table #%u */\n", j+1);
1990
1991 Status = AcpiDmDumpTable (TableLength, Offset, CapabilitiesBuf,
1992 CapabilitiesSize, AcpiDmTableInfoNhlt3a);
1993 if (ACPI_FAILURE (Status))
1994 {
1995 return;
1996 }
1997
1998 Offset += CapabilitiesSize; /* + sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B); */
1999 }
2000
2001 } /* for (j = 0; j < FormatsCount; j++) */
2002
2003 /*
2004 * If we are not done with the current Endpoint yet, then there must be
2005 * some non documented structure(s) yet to be processed. First, get
2006 * the count of such structure(s).
2007 */
2008 if (Offset < EndpointEndOffset)
2009 {
2010 AcpiOsPrintf ("\n /* Structures that are not part of NHLT spec */\n");
2011 Count = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_INFO_COUNT, Table, Offset);
2012 Status = AcpiDmDumpTable (TableLength, Offset, Count,
2013 sizeof (ACPI_NHLT_DEVICE_INFO_COUNT), AcpiDmTableInfoNhlt7);
2014 if (ACPI_FAILURE (Status))
2015 {
2016 return;
2017 }
2018 Offset += sizeof (ACPI_NHLT_DEVICE_INFO_COUNT);
2019
2020 /* Variable number of device structures */
2021
2022 for (j = 0; j < Count->StructureCount; j++)
2023 {
2024 DeviceInfo = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_INFO, Table, Offset);
2025 AcpiOsPrintf ("\n /* Device Info structure #%u (not part of NHLT spec) */\n", j+1);
2026
2027 /*
2028 * Dump the following Device Info fields:
2029 * 1) Device ID
2030 * 2) Device Instance ID
2031 * 3) Device Port ID
2032 */
2033 Status = AcpiDmDumpTable (TableLength, Offset, DeviceInfo,
2034 sizeof (ACPI_NHLT_DEVICE_INFO), AcpiDmTableInfoNhlt7a);
2035 if (ACPI_FAILURE (Status))
2036 {
2037 return;
2038 }
2039
2040 Offset += sizeof (ACPI_NHLT_DEVICE_INFO);
2041 }
2042
2043 /*
2044 * Check that the current offset is not beyond the end of
2045 * this endpoint descriptor. If it is not, print those
2046 * undocumented bytes.
2047 */
2048 if (Offset < EndpointEndOffset)
2049 {
2050 /* Unknown data at the end of the Endpoint */
2051 UINT32 size = EndpointEndOffset - Offset;
2052 UINT8* buffer = ACPI_ADD_PTR (UINT8, Table, Offset);
2053 AcpiOsPrintf ("\n /* Unknown data at the end of the Endpoint, size: %X */\n", size);
2054 Status = AcpiDmDumpTable (TableLength, Offset, buffer,
2055 size, AcpiDmTableInfoNhlt7b);
2056 Offset = EndpointEndOffset;
2057 }
2058
2059 /* Should be at the end of the Endpoint structure. */
2060 }
2061
2062 } /* for (i = 0; i < EndpointCount; i++) */
2063
2064
2065 /*
2066 * Done with all of the Endpoint Descriptors, Emit the table terminator
2067 * (if such a legacy structure is present -- not in NHLT specification)
2068 */
2069 if (Offset < TableLength)
2070 {
2071 Capabilities = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B, Table, Offset);
2072 AcpiOsPrintf ("\n/* Terminating specific config (not part of NHLT spec) */\n");
2073
2074 Status = AcpiDmDumpTable (TableLength, Offset, Capabilities,
2075 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b);
2076 if (ACPI_FAILURE (Status))
2077 {
2078 return;
2079 }
2080 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B);
2081
2082 if (Capabilities->CapabilitiesSize > 0)
2083 {
2084 UINT32 remainingBytes = TableLength - Offset;
2085 UINT8* buffer = ACPI_ADD_PTR (UINT8, Table, Offset);
2086
2087 if (remainingBytes != Capabilities->CapabilitiesSize)
2088 AcpiOsPrintf ("\n/* Incorrect config size, should be %X, is %X */\n",
2089 Capabilities->CapabilitiesSize, remainingBytes);
2090 Status = AcpiDmDumpTable (TableLength, Offset, buffer,
2091 remainingBytes, AcpiDmTableInfoNhlt3a);
2092 }
2093 }
2094
2095 return;
2096 }
2097 }
2098
2099
2100 /*******************************************************************************
2101 *
2102 * FUNCTION: AcpiDmDumpPcct
2103 *
2104 * PARAMETERS: Table - A PCCT table
2105 *
2106 * RETURN: None
2107 *
2108 * DESCRIPTION: Format the contents of a PCCT. This table type consists
2109 * of an open-ended number of subtables.
2110 *
2111 ******************************************************************************/
2112
2113 void
AcpiDmDumpPcct(ACPI_TABLE_HEADER * Table)2114 AcpiDmDumpPcct (
2115 ACPI_TABLE_HEADER *Table)
2116 {
2117 ACPI_STATUS Status;
2118 ACPI_PCCT_SUBSPACE *Subtable;
2119 ACPI_DMTABLE_INFO *InfoTable;
2120 UINT32 Length = Table->Length;
2121 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
2122
2123
2124 /* Main table */
2125
2126 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
2127 if (ACPI_FAILURE (Status))
2128 {
2129 return;
2130 }
2131
2132 /* Subtables */
2133
2134 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
2135 while (Offset < Table->Length)
2136 {
2137 /* Common subtable header */
2138
2139 AcpiOsPrintf ("\n");
2140 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2141 Subtable->Header.Length, AcpiDmTableInfoPcctHdr);
2142 if (ACPI_FAILURE (Status))
2143 {
2144 return;
2145 }
2146
2147 switch (Subtable->Header.Type)
2148 {
2149 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
2150
2151 InfoTable = AcpiDmTableInfoPcct0;
2152 break;
2153
2154 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
2155
2156 InfoTable = AcpiDmTableInfoPcct1;
2157 break;
2158
2159 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
2160
2161 InfoTable = AcpiDmTableInfoPcct2;
2162 break;
2163
2164 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
2165
2166 InfoTable = AcpiDmTableInfoPcct3;
2167 break;
2168
2169 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
2170
2171 InfoTable = AcpiDmTableInfoPcct4;
2172 break;
2173
2174 case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE:
2175
2176 InfoTable = AcpiDmTableInfoPcct5;
2177 break;
2178
2179 default:
2180
2181 AcpiOsPrintf (
2182 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
2183 Subtable->Header.Type);
2184 return;
2185 }
2186
2187 AcpiOsPrintf ("\n");
2188 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2189 Subtable->Header.Length, InfoTable);
2190 if (ACPI_FAILURE (Status))
2191 {
2192 return;
2193 }
2194
2195 /* Point to next subtable */
2196
2197 Offset += Subtable->Header.Length;
2198 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable,
2199 Subtable->Header.Length);
2200 }
2201 }
2202
2203
2204 /*******************************************************************************
2205 *
2206 * FUNCTION: AcpiDmDumpPdtt
2207 *
2208 * PARAMETERS: Table - A PDTT table
2209 *
2210 * RETURN: None
2211 *
2212 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length
2213 * table that contains an open-ended number of IDs
2214 * at the end of the table.
2215 *
2216 ******************************************************************************/
2217
2218 void
AcpiDmDumpPdtt(ACPI_TABLE_HEADER * Table)2219 AcpiDmDumpPdtt (
2220 ACPI_TABLE_HEADER *Table)
2221 {
2222 ACPI_STATUS Status;
2223 ACPI_PDTT_CHANNEL *Subtable;
2224 UINT32 Length = Table->Length;
2225 UINT32 Offset = sizeof (ACPI_TABLE_PDTT);
2226
2227
2228 /* Main table */
2229
2230 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt);
2231 if (ACPI_FAILURE (Status))
2232 {
2233 return;
2234 }
2235
2236 /* Subtables. Currently there is only one type, but can be multiples */
2237
2238 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset);
2239 while (Offset < Table->Length)
2240 {
2241 AcpiOsPrintf ("\n");
2242 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2243 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0);
2244 if (ACPI_FAILURE (Status))
2245 {
2246 return;
2247 }
2248
2249 /* Point to next subtable */
2250
2251 Offset += sizeof (ACPI_PDTT_CHANNEL);
2252 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable,
2253 sizeof (ACPI_PDTT_CHANNEL));
2254 }
2255 }
2256
2257
2258 /*******************************************************************************
2259 *
2260 * FUNCTION: AcpiDmDumpPhat
2261 *
2262 * PARAMETERS: Table - A PHAT table
2263 *
2264 * RETURN: None
2265 *
2266 * DESCRIPTION: Format the contents of a PHAT.
2267 *
2268 ******************************************************************************/
2269
2270 void
AcpiDmDumpPhat(ACPI_TABLE_HEADER * Table)2271 AcpiDmDumpPhat (
2272 ACPI_TABLE_HEADER *Table)
2273 {
2274 ACPI_STATUS Status;
2275 ACPI_DMTABLE_INFO *InfoTable;
2276 ACPI_PHAT_HEADER *Subtable;
2277 ACPI_PHAT_VERSION_DATA *VersionData;
2278 UINT32 RecordCount;
2279 UINT32 Length = Table->Length;
2280 UINT32 Offset = sizeof (ACPI_TABLE_PHAT);
2281 UINT32 OriginalOffset;
2282 UINT32 SubtableLength;
2283 UINT32 PathLength;
2284 UINT32 VendorLength;
2285 UINT16 RecordType;
2286 const wchar_t *WideString;
2287
2288
2289 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, sizeof (ACPI_TABLE_PHAT));
2290
2291 while (Offset < Table->Length)
2292 {
2293 /* Common subtable header */
2294
2295 AcpiOsPrintf ("\n");
2296 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2297 sizeof (ACPI_PHAT_HEADER), AcpiDmTableInfoPhatHdr);
2298 if (ACPI_FAILURE (Status))
2299 {
2300 return;
2301 }
2302
2303 DbgPrint (ASL_DEBUG_OUTPUT, "\n/* %u, Subtable->Type %X */\n",
2304 __LINE__, Subtable->Type);
2305
2306 switch (Subtable->Type)
2307 {
2308 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
2309
2310 InfoTable = AcpiDmTableInfoPhat0;
2311 SubtableLength = Offset += sizeof (ACPI_PHAT_VERSION_DATA);
2312 break;
2313
2314 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
2315
2316 InfoTable = AcpiDmTableInfoPhat1;
2317 SubtableLength = Offset += sizeof (ACPI_PHAT_TYPE_FW_HEALTH_DATA);
2318 break;
2319
2320 default:
2321
2322 DbgPrint (ASL_DEBUG_OUTPUT, "\n**** Unknown PHAT subtable type 0x%X\n\n",
2323 Subtable->Type);
2324
2325 return;
2326 }
2327
2328 Status = AcpiDmDumpTable (Length, SubtableLength, Subtable,
2329 SubtableLength, InfoTable);
2330 if (ACPI_FAILURE (Status))
2331 {
2332 return;
2333 }
2334
2335 OriginalOffset = Offset;
2336 switch (Subtable->Type)
2337 {
2338 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
2339
2340 VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, Subtable);
2341 RecordCount = VersionData->ElementCount;
2342 RecordType = *ACPI_CAST_PTR (UINT8, Subtable);
2343
2344 /*
2345 * Skip past a zero-valued block (not part of the ACPI PHAT specification).
2346 * First, check for a zero length record and a zero element count
2347 */
2348 if (!VersionData->Header.Length && !VersionData->ElementCount)
2349 {
2350 while (RecordType == 0)
2351 {
2352 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, Offset);
2353 RecordType = *ACPI_CAST_PTR (UINT8, Subtable);
2354 RecordCount = VersionData->ElementCount;
2355 Offset += 1;
2356 }
2357
2358 Offset -= 1;
2359 AcpiOsPrintf ("\n/* Warning: Block of zeros found above starting at Offset %X Length %X */\n"
2360 "/* (not compliant to PHAT specification -- ignoring block) */\n",
2361 OriginalOffset - 12, Offset - OriginalOffset + 12);
2362 }
2363
2364 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, RecordCount: %X, Offset %X, SubtableLength %X */\n",
2365 __LINE__, RecordCount, Offset, SubtableLength);
2366
2367 /* Emit each of the version elements */
2368
2369 while (RecordCount && VersionData->Header.Length)
2370 {
2371 AcpiOsPrintf ("\n/* Version Element #%Xh Offset %Xh */\n\n",
2372 VersionData->ElementCount - RecordCount + 1, Offset);
2373
2374 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, Offset);
2375 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2376 sizeof (ACPI_PHAT_VERSION_ELEMENT), AcpiDmTableInfoPhat0a);
2377 if (ACPI_FAILURE (Status))
2378 {
2379 return;
2380 }
2381
2382 Offset += sizeof (ACPI_PHAT_VERSION_ELEMENT);
2383 RecordCount--;
2384 }
2385
2386 break;
2387
2388 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
2389
2390 /*
2391 * Get the length of the Device Path (UEFI wide string).
2392 * Include the wide null terminator (+2),
2393 */
2394 WideString = ACPI_ADD_PTR (wchar_t, Subtable,
2395 sizeof (ACPI_PHAT_HEALTH_DATA));
2396
2397 PathLength = (wcslen (WideString) * 2) + 2;
2398 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, PathLength %X, Offset %X, Table->Length %X */\n",
2399 __LINE__, PathLength, Offset, Length);
2400
2401 Status = AcpiDmDumpTable (Length, Offset,
2402 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA)),
2403 PathLength, AcpiDmTableInfoPhat1a);
2404 Offset += PathLength;
2405 if (ACPI_FAILURE (Status))
2406 {
2407 return;
2408 }
2409
2410 /* Get Device-Specific Data - length of which is the remaining subtable length. */
2411
2412 VendorLength =
2413 Subtable->Length - sizeof (ACPI_PHAT_HEALTH_DATA) - PathLength;
2414 DbgPrint (ASL_DEBUG_OUTPUT, "%u, Subtable->Length %X, VendorLength %X, Offset %X PathLength: %X\n",
2415 __LINE__, Subtable->Length, VendorLength, Offset, PathLength);
2416
2417 if (VendorLength)
2418 {
2419 /* Point past the Device Path, Compile the Device-Specific Data */
2420
2421 Status = AcpiDmDumpTable (Length, Offset,
2422 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA) + PathLength),
2423 VendorLength, AcpiDmTableInfoPhat1b);
2424 if (ACPI_FAILURE (Status))
2425 {
2426 return;
2427 }
2428
2429 Offset += VendorLength;
2430 }
2431
2432 if (ACPI_FAILURE (Status))
2433 {
2434 return;
2435 }
2436 break;
2437
2438 default:
2439
2440 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n",
2441 Subtable->Type);
2442 return;
2443 }
2444
2445 /* Next subtable */
2446
2447 DbgPrint (ASL_DEBUG_OUTPUT, "/* %u, Bottom of main loop: Offset %X, "
2448 "Subtable->Length %X, Table->Length %X */\n",
2449 __LINE__, Offset, Subtable->Length, Table->Length);
2450
2451 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table,
2452 Offset);
2453 }
2454 }
2455
2456
2457 /*******************************************************************************
2458 *
2459 * FUNCTION: AcpiDmDumpPmtt
2460 *
2461 * PARAMETERS: Table - A PMTT table
2462 *
2463 * RETURN: None
2464 *
2465 * DESCRIPTION: Format the contents of a PMTT. This table type consists
2466 * of an open-ended number of subtables.
2467 *
2468 ******************************************************************************/
2469
2470 void
AcpiDmDumpPmtt(ACPI_TABLE_HEADER * Table)2471 AcpiDmDumpPmtt (
2472 ACPI_TABLE_HEADER *Table)
2473 {
2474 ACPI_STATUS Status;
2475 ACPI_PMTT_HEADER *Subtable;
2476 UINT32 Length = Table->Length;
2477 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
2478
2479
2480 /* Main table */
2481
2482 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
2483 if (ACPI_FAILURE (Status))
2484 {
2485 return;
2486 }
2487
2488 /* Subtables */
2489
2490 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
2491 while (Offset < Table->Length)
2492 {
2493 /* Each of the types below contain the common subtable header */
2494
2495 AcpiOsPrintf ("\n");
2496 switch (Subtable->Type)
2497 {
2498 case ACPI_PMTT_TYPE_SOCKET:
2499
2500 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2501 Subtable->Length, AcpiDmTableInfoPmtt0);
2502 if (ACPI_FAILURE (Status))
2503 {
2504 return;
2505 }
2506 break;
2507
2508 case ACPI_PMTT_TYPE_CONTROLLER:
2509 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2510 Subtable->Length, AcpiDmTableInfoPmtt1);
2511 if (ACPI_FAILURE (Status))
2512 {
2513 return;
2514 }
2515 break;
2516
2517 case ACPI_PMTT_TYPE_DIMM:
2518 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2519 Subtable->Length, AcpiDmTableInfoPmtt2);
2520 if (ACPI_FAILURE (Status))
2521 {
2522 return;
2523 }
2524 break;
2525
2526 case ACPI_PMTT_TYPE_VENDOR:
2527 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2528 Subtable->Length, AcpiDmTableInfoPmttVendor);
2529 if (ACPI_FAILURE (Status))
2530 {
2531 return;
2532 }
2533 break;
2534
2535 default:
2536 AcpiOsPrintf (
2537 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2538 Subtable->Type);
2539 return;
2540 }
2541
2542 /* Point to next subtable */
2543
2544 Offset += Subtable->Length;
2545 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2546 Subtable, Subtable->Length);
2547 }
2548 }
2549
2550
2551 /*******************************************************************************
2552 *
2553 * FUNCTION: AcpiDmDumpPptt
2554 *
2555 * PARAMETERS: Table - A PMTT table
2556 *
2557 * RETURN: None
2558 *
2559 * DESCRIPTION: Format the contents of a PPTT. This table type consists
2560 * of an open-ended number of subtables.
2561 *
2562 ******************************************************************************/
2563
2564 void
AcpiDmDumpPptt(ACPI_TABLE_HEADER * Table)2565 AcpiDmDumpPptt (
2566 ACPI_TABLE_HEADER *Table)
2567 {
2568 ACPI_STATUS Status;
2569 ACPI_SUBTABLE_HEADER *Subtable;
2570 ACPI_PPTT_PROCESSOR *PpttProcessor;
2571 UINT8 Length;
2572 UINT8 SubtableOffset;
2573 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
2574 ACPI_DMTABLE_INFO *InfoTable;
2575 UINT32 i;
2576
2577
2578 /* There is no main table (other than the standard ACPI header) */
2579
2580 /* Subtables */
2581
2582 Offset = sizeof (ACPI_TABLE_HEADER);
2583 while (Offset < Table->Length)
2584 {
2585 AcpiOsPrintf ("\n");
2586
2587 /* Common subtable header */
2588
2589 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2590 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER))
2591 {
2592 AcpiOsPrintf ("Invalid subtable length\n");
2593 return;
2594 }
2595 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2596 Subtable->Length, AcpiDmTableInfoPpttHdr);
2597 if (ACPI_FAILURE (Status))
2598 {
2599 return;
2600 }
2601
2602 switch (Subtable->Type)
2603 {
2604 case ACPI_PPTT_TYPE_PROCESSOR:
2605
2606 InfoTable = AcpiDmTableInfoPptt0;
2607 Length = sizeof (ACPI_PPTT_PROCESSOR);
2608 break;
2609
2610 case ACPI_PPTT_TYPE_CACHE:
2611
2612 InfoTable = AcpiDmTableInfoPptt1;
2613 Length = sizeof (ACPI_PPTT_CACHE);
2614 break;
2615
2616 case ACPI_PPTT_TYPE_ID:
2617
2618 InfoTable = AcpiDmTableInfoPptt2;
2619 Length = sizeof (ACPI_PPTT_ID);
2620 break;
2621
2622 default:
2623
2624 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
2625 Subtable->Type);
2626
2627 /* Attempt to continue */
2628
2629 goto NextSubtable;
2630 }
2631
2632 if (Subtable->Length < Length)
2633 {
2634 AcpiOsPrintf ("Invalid subtable length\n");
2635 return;
2636 }
2637 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2638 Subtable->Length, InfoTable);
2639 if (ACPI_FAILURE (Status))
2640 {
2641 return;
2642 }
2643 SubtableOffset = Length;
2644
2645 switch (Subtable->Type)
2646 {
2647 case ACPI_PPTT_TYPE_PROCESSOR:
2648
2649 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable);
2650
2651 /* Dump SMBIOS handles */
2652
2653 if ((UINT8)(Subtable->Length - SubtableOffset) <
2654 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
2655 {
2656 AcpiOsPrintf ("Invalid private resource number\n");
2657 return;
2658 }
2659 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
2660 {
2661 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2662 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2663 4, AcpiDmTableInfoPptt0a);
2664 if (ACPI_FAILURE (Status))
2665 {
2666 return;
2667 }
2668
2669 SubtableOffset += 4;
2670 }
2671 break;
2672
2673 case ACPI_PPTT_TYPE_CACHE:
2674
2675 if (Table->Revision < 3)
2676 {
2677 break;
2678 }
2679 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2680 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2681 sizeof (ACPI_PPTT_CACHE_V1), AcpiDmTableInfoPptt1a);
2682 if (ACPI_FAILURE (Status))
2683 {
2684 return;
2685 }
2686 break;
2687
2688 default:
2689
2690 break;
2691 }
2692
2693 NextSubtable:
2694 /* Point to next subtable */
2695
2696 Offset += Subtable->Length;
2697 }
2698 }
2699
2700
2701 /*******************************************************************************
2702 *
2703 * FUNCTION: AcpiDmDumpPrmt
2704 *
2705 * PARAMETERS: Table - A PRMT table
2706 *
2707 * RETURN: None
2708 *
2709 * DESCRIPTION: Format the contents of a PRMT. This table type consists
2710 * of an open-ended number of subtables.
2711 *
2712 ******************************************************************************/
2713
2714 void
AcpiDmDumpPrmt(ACPI_TABLE_HEADER * Table)2715 AcpiDmDumpPrmt (
2716 ACPI_TABLE_HEADER *Table)
2717 {
2718 UINT32 CurrentOffset = sizeof (ACPI_TABLE_HEADER);
2719 ACPI_TABLE_PRMT_HEADER *PrmtHeader;
2720 ACPI_PRMT_MODULE_INFO *PrmtModuleInfo;
2721 ACPI_PRMT_HANDLER_INFO *PrmtHandlerInfo;
2722 ACPI_STATUS Status;
2723 UINT32 i, j;
2724
2725
2726 /* Main table header */
2727
2728 PrmtHeader = ACPI_ADD_PTR (ACPI_TABLE_PRMT_HEADER, Table, CurrentOffset);
2729 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHeader,
2730 sizeof (ACPI_TABLE_PRMT_HEADER), AcpiDmTableInfoPrmtHdr);
2731 if (ACPI_FAILURE (Status))
2732 {
2733 AcpiOsPrintf ("Invalid PRMT header\n");
2734 return;
2735 }
2736
2737 CurrentOffset += sizeof (ACPI_TABLE_PRMT_HEADER);
2738
2739 /* PRM Module Information Structure array */
2740
2741 for (i = 0; i < PrmtHeader->ModuleInfoCount; ++i)
2742 {
2743 PrmtModuleInfo = ACPI_ADD_PTR (ACPI_PRMT_MODULE_INFO, Table, CurrentOffset);
2744 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtModuleInfo,
2745 sizeof (ACPI_PRMT_MODULE_INFO), AcpiDmTableInfoPrmtModule);
2746
2747 CurrentOffset += sizeof (ACPI_PRMT_MODULE_INFO);
2748
2749 /* PRM handler information structure array */
2750
2751 for (j = 0; j < PrmtModuleInfo->HandlerInfoCount; ++j)
2752 {
2753 PrmtHandlerInfo = ACPI_ADD_PTR (ACPI_PRMT_HANDLER_INFO, Table, CurrentOffset);
2754 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHandlerInfo,
2755 sizeof (ACPI_PRMT_HANDLER_INFO), AcpiDmTableInfoPrmtHandler);
2756
2757 CurrentOffset += sizeof (ACPI_PRMT_HANDLER_INFO);
2758 }
2759 }
2760 }
2761
2762
2763 /*******************************************************************************
2764 *
2765 * FUNCTION: AcpiDmDumpRgrt
2766 *
2767 * PARAMETERS: Table - A RGRT table
2768 *
2769 * RETURN: None
2770 *
2771 * DESCRIPTION: Format the contents of a RGRT
2772 *
2773 ******************************************************************************/
2774
2775 void
AcpiDmDumpRgrt(ACPI_TABLE_HEADER * Table)2776 AcpiDmDumpRgrt (
2777 ACPI_TABLE_HEADER *Table)
2778 {
2779 ACPI_STATUS Status;
2780 ACPI_TABLE_RGRT *Subtable = ACPI_CAST_PTR (ACPI_TABLE_RGRT, Table);
2781 UINT32 Offset = sizeof (ACPI_TABLE_RGRT);
2782
2783
2784 /* Main table */
2785
2786 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoRgrt);
2787 if (ACPI_FAILURE (Status))
2788 {
2789 return;
2790 }
2791
2792 /* Dump the binary image as a subtable */
2793
2794 Status = AcpiDmDumpTable (Table->Length, Offset, &Subtable->Image,
2795 Table->Length - Offset, AcpiDmTableInfoRgrt0);
2796 if (ACPI_FAILURE (Status))
2797 {
2798 return;
2799 }
2800 }
2801
2802
2803 /*******************************************************************************
2804 *
2805 * FUNCTION: AcpiDmDumpRhct
2806 *
2807 * PARAMETERS: Table - A RHCT table
2808 *
2809 * RETURN: None
2810 *
2811 * DESCRIPTION: Format the contents of a RHCT.
2812 *
2813 ******************************************************************************/
2814
2815 void
AcpiDmDumpRhct(ACPI_TABLE_HEADER * Table)2816 AcpiDmDumpRhct (
2817 ACPI_TABLE_HEADER *Table)
2818 {
2819 ACPI_STATUS Status;
2820 ACPI_RHCT_NODE_HEADER *Subtable;
2821 ACPI_RHCT_HART_INFO *RhctHartInfo;
2822 ACPI_RHCT_ISA_STRING *RhctIsaString;
2823 ACPI_RHCT_CMO_NODE *RhctCmoNode;
2824 ACPI_RHCT_MMU_NODE *RhctMmuNode;
2825 UINT32 Length = Table->Length;
2826 UINT8 SubtableOffset, IsaPadOffset;
2827 UINT32 Offset = sizeof (ACPI_TABLE_RHCT);
2828 UINT32 i;
2829
2830 /* Main table */
2831
2832 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRhct);
2833 if (ACPI_FAILURE (Status))
2834 {
2835 return;
2836 }
2837
2838 /* Subtables */
2839
2840 while (Offset < Table->Length)
2841 {
2842 AcpiOsPrintf ("\n");
2843
2844 /* Common subtable header */
2845
2846 Subtable = ACPI_ADD_PTR (ACPI_RHCT_NODE_HEADER, Table, Offset);
2847 if (Subtable->Length < sizeof (ACPI_RHCT_NODE_HEADER))
2848 {
2849 AcpiOsPrintf ("Invalid subtable length\n");
2850 return;
2851 }
2852 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2853 Subtable->Length, AcpiDmTableInfoRhctNodeHdr);
2854 if (ACPI_FAILURE (Status))
2855 {
2856 return;
2857 }
2858
2859 Length = sizeof (ACPI_RHCT_NODE_HEADER);
2860
2861 if (Subtable->Length < Length)
2862 {
2863 AcpiOsPrintf ("Invalid subtable length\n");
2864 return;
2865 }
2866 SubtableOffset = (UINT8) Length;
2867
2868 switch (Subtable->Type)
2869 {
2870 case ACPI_RHCT_NODE_TYPE_HART_INFO:
2871 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2872 ACPI_ADD_PTR (ACPI_RHCT_HART_INFO, Subtable, SubtableOffset),
2873 sizeof (ACPI_RHCT_HART_INFO), AcpiDmTableInfoRhctHartInfo1);
2874
2875 RhctHartInfo = ACPI_ADD_PTR (ACPI_RHCT_HART_INFO, Subtable, SubtableOffset);
2876
2877 if ((UINT16)(Subtable->Length - SubtableOffset) <
2878 (UINT16)(RhctHartInfo->NumOffsets * 4))
2879 {
2880 AcpiOsPrintf ("Invalid number of offsets\n");
2881 return;
2882 }
2883 SubtableOffset += sizeof (ACPI_RHCT_HART_INFO);
2884 for (i = 0; i < RhctHartInfo->NumOffsets; i++)
2885 {
2886 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2887 ACPI_ADD_PTR (UINT32, Subtable, SubtableOffset),
2888 4, AcpiDmTableInfoRhctHartInfo2);
2889 if (ACPI_FAILURE (Status))
2890 {
2891 return;
2892 }
2893
2894 SubtableOffset += 4;
2895 }
2896 break;
2897
2898 case ACPI_RHCT_NODE_TYPE_ISA_STRING:
2899 RhctIsaString = ACPI_ADD_PTR (ACPI_RHCT_ISA_STRING, Subtable, SubtableOffset);
2900 IsaPadOffset = (UINT8) (SubtableOffset + 2 + RhctIsaString->IsaLength);
2901 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2902 RhctIsaString, RhctIsaString->IsaLength, AcpiDmTableInfoRhctIsa1);
2903 if (Subtable->Length > IsaPadOffset)
2904 {
2905 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2906 ACPI_ADD_PTR (UINT8, Subtable, IsaPadOffset),
2907 (Subtable->Length - IsaPadOffset), AcpiDmTableInfoRhctIsaPad);
2908 }
2909
2910 break;
2911
2912 case ACPI_RHCT_NODE_TYPE_CMO:
2913 RhctCmoNode = ACPI_ADD_PTR (ACPI_RHCT_CMO_NODE, Subtable, SubtableOffset);
2914 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2915 RhctCmoNode, 4, AcpiDmTableInfoRhctCmo1);
2916 break;
2917
2918 case ACPI_RHCT_NODE_TYPE_MMU:
2919 RhctMmuNode = ACPI_ADD_PTR (ACPI_RHCT_MMU_NODE, Subtable, SubtableOffset);
2920 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2921 RhctMmuNode, 2, AcpiDmTableInfoRhctMmu1);
2922 break;
2923
2924 default:
2925 break;
2926 }
2927
2928 /* Point to next subtable */
2929
2930 Offset += Subtable->Length;
2931 }
2932 }
2933
2934
2935 /*******************************************************************************
2936 *
2937 * FUNCTION: AcpiDmDumpS3pt
2938 *
2939 * PARAMETERS: Table - A S3PT table
2940 *
2941 * RETURN: Length of the table
2942 *
2943 * DESCRIPTION: Format the contents of a S3PT
2944 *
2945 ******************************************************************************/
2946
2947 UINT32
AcpiDmDumpS3pt(ACPI_TABLE_HEADER * Tables)2948 AcpiDmDumpS3pt (
2949 ACPI_TABLE_HEADER *Tables)
2950 {
2951 ACPI_STATUS Status;
2952 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
2953 ACPI_FPDT_HEADER *Subtable;
2954 ACPI_DMTABLE_INFO *InfoTable;
2955 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
2956
2957
2958 /* Main table */
2959
2960 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
2961 if (ACPI_FAILURE (Status))
2962 {
2963 return 0;
2964 }
2965
2966 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
2967 while (Offset < S3ptTable->Length)
2968 {
2969 /* Common subtable header */
2970
2971 AcpiOsPrintf ("\n");
2972 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
2973 Subtable->Length, AcpiDmTableInfoS3ptHdr);
2974 if (ACPI_FAILURE (Status))
2975 {
2976 return 0;
2977 }
2978
2979 switch (Subtable->Type)
2980 {
2981 case ACPI_S3PT_TYPE_RESUME:
2982
2983 InfoTable = AcpiDmTableInfoS3pt0;
2984 break;
2985
2986 case ACPI_S3PT_TYPE_SUSPEND:
2987
2988 InfoTable = AcpiDmTableInfoS3pt1;
2989 break;
2990
2991 default:
2992
2993 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
2994 Subtable->Type);
2995
2996 /* Attempt to continue */
2997
2998 if (!Subtable->Length)
2999 {
3000 AcpiOsPrintf ("Invalid zero length subtable\n");
3001 return 0;
3002 }
3003 goto NextSubtable;
3004 }
3005
3006 AcpiOsPrintf ("\n");
3007 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
3008 Subtable->Length, InfoTable);
3009 if (ACPI_FAILURE (Status))
3010 {
3011 return 0;
3012 }
3013
3014 NextSubtable:
3015 /* Point to next subtable */
3016
3017 Offset += Subtable->Length;
3018 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length);
3019 }
3020
3021 return (S3ptTable->Length);
3022 }
3023
3024
3025 /*******************************************************************************
3026 *
3027 * FUNCTION: AcpiDmDumpSdev
3028 *
3029 * PARAMETERS: Table - A SDEV table
3030 *
3031 * RETURN: None
3032 *
3033 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length
3034 * table that contains variable strings and vendor data.
3035 *
3036 ******************************************************************************/
3037
3038 void
AcpiDmDumpSdev(ACPI_TABLE_HEADER * Table)3039 AcpiDmDumpSdev (
3040 ACPI_TABLE_HEADER *Table)
3041 {
3042 ACPI_STATUS Status;
3043 ACPI_SDEV_HEADER *Subtable;
3044 ACPI_SDEV_PCIE *Pcie;
3045 ACPI_SDEV_NAMESPACE *Namesp;
3046 ACPI_DMTABLE_INFO *InfoTable;
3047 ACPI_DMTABLE_INFO *SecureComponentInfoTable;
3048 UINT32 Length = Table->Length;
3049 UINT32 Offset = sizeof (ACPI_TABLE_SDEV);
3050 UINT16 PathOffset;
3051 UINT16 PathLength;
3052 UINT16 VendorDataOffset;
3053 UINT16 VendorDataLength;
3054 ACPI_SDEV_SECURE_COMPONENT *SecureComponent = NULL;
3055 UINT32 CurrentOffset = 0;
3056
3057
3058 /* Main table */
3059
3060 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev);
3061 if (ACPI_FAILURE (Status))
3062 {
3063 return;
3064 }
3065
3066 /* Subtables */
3067
3068 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset);
3069 while (Offset < Table->Length)
3070 {
3071 /* Common subtable header */
3072
3073 AcpiOsPrintf ("\n");
3074 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
3075 Subtable->Length, AcpiDmTableInfoSdevHdr);
3076 if (ACPI_FAILURE (Status))
3077 {
3078 return;
3079 }
3080
3081 switch (Subtable->Type)
3082 {
3083 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
3084
3085 InfoTable = AcpiDmTableInfoSdev0;
3086 break;
3087
3088 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
3089
3090 InfoTable = AcpiDmTableInfoSdev1;
3091 break;
3092
3093 default:
3094 goto NextSubtable;
3095 }
3096
3097 AcpiOsPrintf ("\n");
3098 Status = AcpiDmDumpTable (Table->Length, 0, Subtable,
3099 Subtable->Length, InfoTable);
3100 if (ACPI_FAILURE (Status))
3101 {
3102 return;
3103 }
3104
3105 switch (Subtable->Type)
3106 {
3107 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
3108
3109 CurrentOffset = sizeof (ACPI_SDEV_NAMESPACE);
3110 if (Subtable->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT)
3111 {
3112 SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT,
3113 ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)));
3114
3115 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
3116 ACPI_ADD_PTR(UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)),
3117 sizeof (ACPI_SDEV_SECURE_COMPONENT), AcpiDmTableInfoSdev0b);
3118 if (ACPI_FAILURE (Status))
3119 {
3120 return;
3121 }
3122 CurrentOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT);
3123
3124 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
3125 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
3126 sizeof (ACPI_SDEV_HEADER), AcpiDmTableInfoSdevSecCompHdr);
3127 if (ACPI_FAILURE (Status))
3128 {
3129 return;
3130 }
3131 CurrentOffset += sizeof (ACPI_SDEV_HEADER);
3132
3133 switch (Subtable->Type)
3134 {
3135 case ACPI_SDEV_TYPE_ID_COMPONENT:
3136
3137 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId;
3138 break;
3139
3140 case ACPI_SDEV_TYPE_MEM_COMPONENT:
3141
3142 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem;
3143 break;
3144
3145 default:
3146 goto NextSubtable;
3147 }
3148
3149 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
3150 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
3151 SecureComponent->SecureComponentLength, SecureComponentInfoTable);
3152 CurrentOffset += SecureComponent->SecureComponentLength;
3153 }
3154
3155 /* Dump the PCIe device ID(s) */
3156
3157 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable);
3158 PathOffset = Namesp->DeviceIdOffset;
3159 PathLength = Namesp->DeviceIdLength;
3160
3161 if (PathLength)
3162 {
3163 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
3164 ACPI_ADD_PTR (UINT8, Namesp, PathOffset),
3165 PathLength, AcpiDmTableInfoSdev0a);
3166 if (ACPI_FAILURE (Status))
3167 {
3168 return;
3169 }
3170 CurrentOffset += PathLength;
3171 }
3172
3173 /* Dump the vendor-specific data */
3174
3175 VendorDataLength =
3176 Namesp->VendorDataLength;
3177 VendorDataOffset =
3178 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
3179
3180 if (VendorDataLength)
3181 {
3182 Status = AcpiDmDumpTable (Table->Length, 0,
3183 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset),
3184 VendorDataLength, AcpiDmTableInfoSdev1b);
3185 if (ACPI_FAILURE (Status))
3186 {
3187 return;
3188 }
3189 }
3190 break;
3191
3192 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
3193
3194 /* PCI path substructures */
3195
3196 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable);
3197 PathOffset = Pcie->PathOffset;
3198 PathLength = Pcie->PathLength;
3199
3200 while (PathLength)
3201 {
3202 Status = AcpiDmDumpTable (Table->Length,
3203 PathOffset + Offset,
3204 ACPI_ADD_PTR (UINT8, Pcie, PathOffset),
3205 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a);
3206 if (ACPI_FAILURE (Status))
3207 {
3208 return;
3209 }
3210
3211 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH);
3212 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH);
3213 }
3214
3215 /* VendorData */
3216
3217 VendorDataLength = Pcie->VendorDataLength;
3218 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength;
3219
3220 if (VendorDataLength)
3221 {
3222 Status = AcpiDmDumpTable (Table->Length, 0,
3223 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset),
3224 VendorDataLength, AcpiDmTableInfoSdev1b);
3225 if (ACPI_FAILURE (Status))
3226 {
3227 return;
3228 }
3229 }
3230 break;
3231
3232 default:
3233 goto NextSubtable;
3234 }
3235
3236 NextSubtable:
3237 /* Point to next subtable */
3238
3239 Offset += Subtable->Length;
3240 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable,
3241 Subtable->Length);
3242 }
3243 }
3244
