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 - 2021, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include "acpi.h"
153 #include "accommon.h"
154 #include "acdisasm.h"
155 #include "actables.h"
156 #include "aslcompiler.h"
157
158 /* This module used for application-level code only */
159
160 #define _COMPONENT ACPI_CA_DISASSEMBLER
161 ACPI_MODULE_NAME ("dmtbdump2")
162
163
164 /*******************************************************************************
165 *
166 * FUNCTION: AcpiDmDumpIort
167 *
168 * PARAMETERS: Table - A IORT table
169 *
170 * RETURN: None
171 *
172 * DESCRIPTION: Format the contents of a IORT
173 *
174 ******************************************************************************/
175
176 void
AcpiDmDumpIort(ACPI_TABLE_HEADER * Table)177 AcpiDmDumpIort (
178 ACPI_TABLE_HEADER *Table)
179 {
180 ACPI_STATUS Status;
181 ACPI_TABLE_IORT *Iort;
182 ACPI_IORT_NODE *IortNode;
183 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL;
184 ACPI_IORT_SMMU *IortSmmu = NULL;
185 ACPI_IORT_RMR *IortRmr = NULL;
186 UINT32 Offset;
187 UINT32 NodeOffset;
188 UINT32 Length;
189 ACPI_DMTABLE_INFO *InfoTable;
190 char *String;
191 UINT32 i;
192 UINT32 MappingByteLength;
193 UINT8 Revision;
194
195
196 /* Main table */
197
198 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
199 if (ACPI_FAILURE (Status))
200 {
201 return;
202 }
203
204 Revision = Table->Revision;
205
206 /* Both IORT Rev E and E.a have known issues and are not supported */
207
208 if (Revision == 1 || Revision == 2)
209 {
210 AcpiOsPrintf ("\n**** Unsupported IORT revision 0x%X\n",
211 Revision);
212 return;
213 }
214
215 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
216 Offset = sizeof (ACPI_TABLE_IORT);
217
218 /* Dump the OptionalPadding (optional) */
219
220 if (Iort->NodeOffset > Offset)
221 {
222 Status = AcpiDmDumpTable (Table->Length, Offset, Table,
223 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
224 if (ACPI_FAILURE (Status))
225 {
226 return;
227 }
228 }
229
230 Offset = Iort->NodeOffset;
231 while (Offset < Table->Length)
232 {
233 /* Common subtable header */
234
235 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
236 AcpiOsPrintf ("\n");
237 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
238
239 if (Revision == 0)
240 {
241 Status = AcpiDmDumpTable (Table->Length, Offset,
242 IortNode, Length, AcpiDmTableInfoIortHdr);
243 }
244 else if (Revision >= 3)
245 {
246 Status = AcpiDmDumpTable (Table->Length, Offset,
247 IortNode, Length, AcpiDmTableInfoIortHdr3);
248 }
249
250 if (ACPI_FAILURE (Status))
251 {
252 return;
253 }
254
255 NodeOffset = Length;
256
257 switch (IortNode->Type)
258 {
259 case ACPI_IORT_NODE_ITS_GROUP:
260
261 InfoTable = AcpiDmTableInfoIort0;
262 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
263 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
264 break;
265
266 case ACPI_IORT_NODE_NAMED_COMPONENT:
267
268 InfoTable = AcpiDmTableInfoIort1;
269 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
270 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
271 Length += strlen (String) + 1;
272 break;
273
274 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
275
276 InfoTable = AcpiDmTableInfoIort2;
277 Length = IortNode->Length - NodeOffset;
278 break;
279
280 case ACPI_IORT_NODE_SMMU:
281
282 InfoTable = AcpiDmTableInfoIort3;
283 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
284 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
285 break;
286
287 case ACPI_IORT_NODE_SMMU_V3:
288
289 InfoTable = AcpiDmTableInfoIort4;
290 Length = IortNode->Length - NodeOffset;
291 break;
292
293 case ACPI_IORT_NODE_PMCG:
294
295 InfoTable = AcpiDmTableInfoIort5;
296 Length = IortNode->Length - NodeOffset;
297 break;
298
299 case ACPI_IORT_NODE_RMR:
300
301 InfoTable = AcpiDmTableInfoIort6;
302 Length = IortNode->Length - NodeOffset;
303 IortRmr = ACPI_ADD_PTR (ACPI_IORT_RMR, IortNode, NodeOffset);
304 break;
305
306 default:
307
308 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
309 IortNode->Type);
310
311 /* Attempt to continue */
312
313 if (!IortNode->Length)
314 {
315 AcpiOsPrintf ("Invalid zero length IORT node\n");
316 return;
317 }
318 goto NextSubtable;
319 }
320
321 /* Dump the node subtable header */
322
323 AcpiOsPrintf ("\n");
324 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
325 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
326 Length, InfoTable);
327 if (ACPI_FAILURE (Status))
328 {
329 return;
330 }
331
332 NodeOffset += Length;
333
334 /* Dump the node specific data */
335
336 switch (IortNode->Type)
337 {
338 case ACPI_IORT_NODE_ITS_GROUP:
339
340 /* Validate IortItsGroup to avoid compiler warnings */
341
342 if (IortItsGroup)
343 {
344 for (i = 0; i < IortItsGroup->ItsCount; i++)
345 {
346 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
347 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
348 4, AcpiDmTableInfoIort0a);
349 if (ACPI_FAILURE (Status))
350 {
351 return;
352 }
353
354 NodeOffset += 4;
355 }
356 }
357 break;
358
359 case ACPI_IORT_NODE_NAMED_COMPONENT:
360
361 /* Dump the Padding (optional) */
362
363 if (IortNode->Length > NodeOffset)
364 {
365 MappingByteLength =
366 IortNode->MappingCount * sizeof (ACPI_IORT_ID_MAPPING);
367 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
368 Table, IortNode->Length - NodeOffset - MappingByteLength,
369 AcpiDmTableInfoIort1a);
370 if (ACPI_FAILURE (Status))
371 {
372 return;
373 }
374 }
375 break;
376
377 case ACPI_IORT_NODE_SMMU:
378
379 AcpiOsPrintf ("\n");
380
381 /* Validate IortSmmu to avoid compiler warnings */
382
383 if (IortSmmu)
384 {
385 Length = 2 * sizeof (UINT64);
386 NodeOffset = IortSmmu->GlobalInterruptOffset;
387 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
388 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
389 Length, AcpiDmTableInfoIort3a);
390 if (ACPI_FAILURE (Status))
391 {
392 return;
393 }
394
395 NodeOffset = IortSmmu->ContextInterruptOffset;
396 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
397 {
398 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
399 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
400 8, AcpiDmTableInfoIort3b);
401 if (ACPI_FAILURE (Status))
402 {
403 return;
404 }
405
406 NodeOffset += 8;
407 }
408
409 NodeOffset = IortSmmu->PmuInterruptOffset;
410 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
411 {
412 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
413 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
414 8, AcpiDmTableInfoIort3c);
415 if (ACPI_FAILURE (Status))
416 {
417 return;
418 }
419
420 NodeOffset += 8;
421 }
422 }
423 break;
424
425 case ACPI_IORT_NODE_RMR:
426
427 /* Validate IortRmr to avoid compiler warnings */
428 if (IortRmr)
429 {
430 NodeOffset = IortRmr->RmrOffset;
431 Length = sizeof (ACPI_IORT_RMR_DESC);
432 for (i = 0; i < IortRmr->RmrCount; i++)
433 {
434 AcpiOsPrintf ("\n");
435 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
436 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
437 Length, AcpiDmTableInfoIort6a);
438 if (ACPI_FAILURE (Status))
439 {
440 return;
441 }
442
443 NodeOffset += Length;
444 }
445 }
446 break;
447
448 default:
449
450 break;
451 }
452
453 /* Dump the ID mappings */
454
455 NodeOffset = IortNode->MappingOffset;
456 for (i = 0; i < IortNode->MappingCount; i++)
457 {
458 AcpiOsPrintf ("\n");
459 Length = sizeof (ACPI_IORT_ID_MAPPING);
460 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
461 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
462 Length, AcpiDmTableInfoIortMap);
463 if (ACPI_FAILURE (Status))
464 {
465 return;
466 }
467
468 NodeOffset += Length;
469 }
470
471 NextSubtable:
472 /* Point to next node subtable */
473
474 Offset += IortNode->Length;
475 }
476 }
477
478
479 /*******************************************************************************
480 *
481 * FUNCTION: AcpiDmDumpIvrs
482 *
483 * PARAMETERS: Table - A IVRS table
484 *
485 * RETURN: None
486 *
487 * DESCRIPTION: Format the contents of a IVRS. Notes:
488 * The IVRS is essentially a flat table, with the following
489 * structure:
490 * <Main ACPI Table Header>
491 * <Main subtable - virtualization info>
492 * <IVHD>
493 * <Device Entries>
494 * ...
495 * <IVHD>
496 * <Device Entries>
497 * <IVMD>
498 * ...
499 *
500 ******************************************************************************/
501
502 void
AcpiDmDumpIvrs(ACPI_TABLE_HEADER * Table)503 AcpiDmDumpIvrs (
504 ACPI_TABLE_HEADER *Table)
505 {
506 ACPI_STATUS Status;
507 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
508 UINT32 EntryOffset;
509 UINT32 EntryLength;
510 UINT32 EntryType;
511 ACPI_IVRS_DEVICE_HID *HidSubtable;
512 ACPI_IVRS_DE_HEADER *DeviceEntry;
513 ACPI_IVRS_HEADER *Subtable;
514 ACPI_DMTABLE_INFO *InfoTable;
515
516
517 /* Main table */
518
519 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
520 if (ACPI_FAILURE (Status))
521 {
522 return;
523 }
524
525 /* Subtables */
526
527 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
528
529 while (Offset < Table->Length)
530 {
531 switch (Subtable->Type)
532 {
533 /* Type 10h, IVHD (I/O Virtualization Hardware Definition) */
534
535 case ACPI_IVRS_TYPE_HARDWARE1:
536
537 AcpiOsPrintf ("\n");
538 InfoTable = AcpiDmTableInfoIvrsHware1;
539 break;
540
541 /* Types 11h, 40h, IVHD (I/O Virtualization Hardware Definition) */
542
543 case ACPI_IVRS_TYPE_HARDWARE2:
544 case ACPI_IVRS_TYPE_HARDWARE3:
545
546 AcpiOsPrintf ("\n");
547 InfoTable = AcpiDmTableInfoIvrsHware23;
548 break;
549
550 /* Types 20h-22h, IVMD (I/O Virtualization Memory Definition Block) */
551
552 case ACPI_IVRS_TYPE_MEMORY1:
553 case ACPI_IVRS_TYPE_MEMORY2:
554 case ACPI_IVRS_TYPE_MEMORY3:
555
556 AcpiOsPrintf ("\n");
557 InfoTable = AcpiDmTableInfoIvrsMemory;
558 break;
559
560 default:
561
562 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
563 Subtable->Type);
564
565 /* Attempt to continue */
566
567 if (!Subtable->Length)
568 {
569 AcpiOsPrintf ("Invalid zero length subtable\n");
570 return;
571 }
572 goto NextSubtable;
573 }
574
575 /* Dump the subtable */
576
577 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
578 Subtable->Length, InfoTable);
579 if (ACPI_FAILURE (Status))
580 {
581 return;
582 }
583
584 /* The hardware subtables (IVHD) can contain multiple device entries */
585
586 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1 ||
587 Subtable->Type == ACPI_IVRS_TYPE_HARDWARE2 ||
588 Subtable->Type == ACPI_IVRS_TYPE_HARDWARE3)
589 {
590 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1)
591 {
592 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE1);
593 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
594 sizeof (ACPI_IVRS_HARDWARE1));
595 }
596 else
597 {
598 /* ACPI_IVRS_TYPE_HARDWARE2, HARDWARE3 subtable types */
599
600 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE2);
601 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
602 sizeof (ACPI_IVRS_HARDWARE2));
603 }
604
605 /* Process all of the Device Entries */
606
607 while (EntryOffset < (Offset + Subtable->Length))
608 {
609 AcpiOsPrintf ("\n");
610
611 /*
612 * Upper 2 bits of Type encode the length of the device entry
613 *
614 * 00 = 4 byte
615 * 01 = 8 byte
616 * 1x = variable length
617 */
618 EntryType = DeviceEntry->Type;
619 EntryLength = EntryType >> 6 == 1 ? 8 : 4;
620
621 switch (EntryType)
622 {
623 /* 4-byte device entries */
624
625 case ACPI_IVRS_TYPE_PAD4:
626 case ACPI_IVRS_TYPE_ALL:
627 case ACPI_IVRS_TYPE_SELECT:
628 case ACPI_IVRS_TYPE_START:
629 case ACPI_IVRS_TYPE_END:
630
631 InfoTable = AcpiDmTableInfoIvrs4;
632 break;
633
634 /* 8-byte entries, type A */
635
636 case ACPI_IVRS_TYPE_ALIAS_SELECT:
637 case ACPI_IVRS_TYPE_ALIAS_START:
638
639 InfoTable = AcpiDmTableInfoIvrs8a;
640 break;
641
642 /* 8-byte entries, type B */
643
644 case ACPI_IVRS_TYPE_PAD8:
645 case ACPI_IVRS_TYPE_EXT_SELECT:
646 case ACPI_IVRS_TYPE_EXT_START:
647
648 InfoTable = AcpiDmTableInfoIvrs8b;
649 break;
650
651 /* 8-byte entries, type C */
652
653 case ACPI_IVRS_TYPE_SPECIAL:
654
655 InfoTable = AcpiDmTableInfoIvrs8c;
656 break;
657
658 /* Variable-length entries */
659
660 case ACPI_IVRS_TYPE_HID:
661
662 EntryLength = 4;
663 InfoTable = AcpiDmTableInfoIvrsHid;
664 break;
665
666 default:
667 InfoTable = AcpiDmTableInfoIvrs4;
668 AcpiOsPrintf (
669 "\n**** Unknown IVRS device entry type/length: "
670 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
671 EntryType, EntryLength, EntryOffset);
672 break;
673 }
674
675 /* Dump the Device Entry */
676
677 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
678 DeviceEntry, EntryLength, InfoTable);
679 if (ACPI_FAILURE (Status))
680 {
681 return;
682 }
683
684 HidSubtable = ACPI_CAST_PTR (ACPI_IVRS_DEVICE_HID, DeviceEntry);
685 EntryOffset += EntryLength;
686 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, HidSubtable,
687 EntryLength);
688
689 if (EntryType == ACPI_IVRS_TYPE_HID)
690 {
691 /*
692 * Determine if the HID is an integer or a string.
693 * An integer is defined to be 32 bits, with the upper 32 bits
694 * set to zero. (from the ACPI Spec): "The HID can be a 32-bit
695 * integer or a character string. If an integer, the lower
696 * 4 bytes of the field contain the integer and the upper
697 * 4 bytes are padded with 0".
698 */
699 if (UtIsIdInteger ((UINT8 *) &HidSubtable->AcpiHid))
700 {
701 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
702 &HidSubtable->AcpiHid, 8, AcpiDmTableInfoIvrsHidInteger);
703 }
704 else
705 {
706 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
707 &HidSubtable->AcpiHid, 8, AcpiDmTableInfoIvrsHidString);
708 }
709 if (ACPI_FAILURE (Status))
710 {
711 return;
712 }
713
714 EntryOffset += 8;
715
716 /*
717 * Determine if the CID is an integer or a string. The format
718 * of the CID is the same as the HID above. From ACPI Spec:
719 * "If present, CID must be a single Compatible Device ID
720 * following the same format as the HID field."
721 */
722 if (UtIsIdInteger ((UINT8 *) &HidSubtable->AcpiCid))
723 {
724 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
725 &HidSubtable->AcpiCid, 8, AcpiDmTableInfoIvrsCidInteger);
726 }
727 else
728 {
729 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
730 &HidSubtable->AcpiCid, 8, AcpiDmTableInfoIvrsCidString);
731 }
732 if (ACPI_FAILURE (Status))
733 {
734 return;
735 }
736
737 EntryOffset += 8;
738 EntryLength = HidSubtable->UidLength;
739
740 if (EntryLength > ACPI_IVRS_UID_NOT_PRESENT)
741 {
742 /* Dump the UID based upon the UidType field (String or Integer) */
743
744 if (HidSubtable->UidType == ACPI_IVRS_UID_IS_STRING)
745 {
746 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
747 &HidSubtable->UidType, EntryLength, AcpiDmTableInfoIvrsUidString);
748 if (ACPI_FAILURE (Status))
749 {
750 return;
751 }
752 }
753 else /* ACPI_IVRS_UID_IS_INTEGER */
754 {
755 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
756 &HidSubtable->UidType, EntryLength, AcpiDmTableInfoIvrsUidInteger);
757 if (ACPI_FAILURE (Status))
758 {
759 return;
760 }
761 }
762 }
763
764 EntryOffset += EntryLength+2;
765 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER,
766 Table, EntryOffset);
767 }
768 }
769 }
770
771 NextSubtable:
772 /* Point to next subtable */
773
774 Offset += Subtable->Length;
775 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, Subtable->Length);
776 }
777 }
778
779
780 /*******************************************************************************
781 *
782 * FUNCTION: AcpiDmDumpLpit
783 *
784 * PARAMETERS: Table - A LPIT table
785 *
786 * RETURN: None
787 *
788 * DESCRIPTION: Format the contents of a LPIT. This table type consists
789 * of an open-ended number of subtables. Note: There are no
790 * entries in the main table. An LPIT consists of the table
791 * header and then subtables only.
792 *
793 ******************************************************************************/
794
795 void
AcpiDmDumpLpit(ACPI_TABLE_HEADER * Table)796 AcpiDmDumpLpit (
797 ACPI_TABLE_HEADER *Table)
798 {
799 ACPI_STATUS Status;
800 ACPI_LPIT_HEADER *Subtable;
801 UINT32 Length = Table->Length;
802 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
803 ACPI_DMTABLE_INFO *InfoTable;
804 UINT32 SubtableLength;
805
806
807 /* Subtables */
808
809 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
810 while (Offset < Table->Length)
811 {
812 /* Common subtable header */
813
814 Status = AcpiDmDumpTable (Length, Offset, Subtable,
815 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
816 if (ACPI_FAILURE (Status))
817 {
818 return;
819 }
820
821 switch (Subtable->Type)
822 {
823 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
824
825 InfoTable = AcpiDmTableInfoLpit0;
826 SubtableLength = sizeof (ACPI_LPIT_NATIVE);
827 break;
828
829 default:
830
831 /* Cannot continue on unknown type - no length */
832
833 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
834 Subtable->Type);
835 return;
836 }
837
838 Status = AcpiDmDumpTable (Length, Offset, Subtable,
839 SubtableLength, InfoTable);
840 if (ACPI_FAILURE (Status))
841 {
842 return;
843 }
844
845 AcpiOsPrintf ("\n");
846
847 /* Point to next subtable */
848
849 Offset += SubtableLength;
850 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength);
851 }
852 }
853
854
855 /*******************************************************************************
856 *
857 * FUNCTION: AcpiDmDumpMadt
858 *
859 * PARAMETERS: Table - A MADT table
860 *
861 * RETURN: None
862 *
863 * DESCRIPTION: Format the contents of a MADT. This table type consists
864 * of an open-ended number of subtables.
865 *
866 ******************************************************************************/
867
868 void
AcpiDmDumpMadt(ACPI_TABLE_HEADER * Table)869 AcpiDmDumpMadt (
870 ACPI_TABLE_HEADER *Table)
871 {
872 ACPI_STATUS Status;
873 ACPI_SUBTABLE_HEADER *Subtable;
874 UINT32 Length = Table->Length;
875 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
876 ACPI_DMTABLE_INFO *InfoTable;
877
878
879 /* Main table */
880
881 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
882 if (ACPI_FAILURE (Status))
883 {
884 return;
885 }
886
887 /* Subtables */
888
889 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
890 while (Offset < Table->Length)
891 {
892 /* Common subtable header */
893
894 AcpiOsPrintf ("\n");
895 Status = AcpiDmDumpTable (Length, Offset, Subtable,
896 Subtable->Length, AcpiDmTableInfoMadtHdr);
897 if (ACPI_FAILURE (Status))
898 {
899 return;
900 }
901
902 switch (Subtable->Type)
903 {
904 case ACPI_MADT_TYPE_LOCAL_APIC:
905
906 InfoTable = AcpiDmTableInfoMadt0;
907 break;
908
909 case ACPI_MADT_TYPE_IO_APIC:
910
911 InfoTable = AcpiDmTableInfoMadt1;
912 break;
913
914 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
915
916 InfoTable = AcpiDmTableInfoMadt2;
917 break;
918
919 case ACPI_MADT_TYPE_NMI_SOURCE:
920
921 InfoTable = AcpiDmTableInfoMadt3;
922 break;
923
924 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
925
926 InfoTable = AcpiDmTableInfoMadt4;
927 break;
928
929 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
930
931 InfoTable = AcpiDmTableInfoMadt5;
932 break;
933
934 case ACPI_MADT_TYPE_IO_SAPIC:
935
936 InfoTable = AcpiDmTableInfoMadt6;
937 break;
938
939 case ACPI_MADT_TYPE_LOCAL_SAPIC:
940
941 InfoTable = AcpiDmTableInfoMadt7;
942 break;
943
944 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
945
946 InfoTable = AcpiDmTableInfoMadt8;
947 break;
948
949 case ACPI_MADT_TYPE_LOCAL_X2APIC:
950
951 InfoTable = AcpiDmTableInfoMadt9;
952 break;
953
954 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
955
956 InfoTable = AcpiDmTableInfoMadt10;
957 break;
958
959 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
960
961 InfoTable = AcpiDmTableInfoMadt11;
962 break;
963
964 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
965
966 InfoTable = AcpiDmTableInfoMadt12;
967 break;
968
969 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
970
971 InfoTable = AcpiDmTableInfoMadt13;
972 break;
973
974 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
975
976 InfoTable = AcpiDmTableInfoMadt14;
977 break;
978
979 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
980
981 InfoTable = AcpiDmTableInfoMadt15;
982 break;
983
984 case ACPI_MADT_TYPE_MULTIPROC_WAKEUP:
985
986 InfoTable = AcpiDmTableInfoMadt16;
987 break;
988
989 default:
990
991 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
992 Subtable->Type);
993
994 /* Attempt to continue */
995
996 if (!Subtable->Length)
997 {
998 AcpiOsPrintf ("Invalid zero length subtable\n");
999 return;
1000 }
1001
1002 goto NextSubtable;
1003 }
1004
1005 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1006 Subtable->Length, InfoTable);
1007 if (ACPI_FAILURE (Status))
1008 {
1009 return;
1010 }
1011
1012 NextSubtable:
1013 /* Point to next subtable */
1014
1015 Offset += Subtable->Length;
1016 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable,
1017 Subtable->Length);
1018 }
1019 }
1020
1021
1022 /*******************************************************************************
1023 *
1024 * FUNCTION: AcpiDmDumpMcfg
1025 *
1026 * PARAMETERS: Table - A MCFG Table
1027 *
1028 * RETURN: None
1029 *
1030 * DESCRIPTION: Format the contents of a MCFG table
1031 *
1032 ******************************************************************************/
1033
1034 void
AcpiDmDumpMcfg(ACPI_TABLE_HEADER * Table)1035 AcpiDmDumpMcfg (
1036 ACPI_TABLE_HEADER *Table)
1037 {
1038 ACPI_STATUS Status;
1039 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
1040 ACPI_MCFG_ALLOCATION *Subtable;
1041
1042
1043 /* Main table */
1044
1045 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1046 if (ACPI_FAILURE (Status))
1047 {
1048 return;
1049 }
1050
1051 /* Subtables */
1052
1053 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1054 while (Offset < Table->Length)
1055 {
1056 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1057 {
1058 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1059 (UINT32) sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1060 return;
1061 }
1062
1063 AcpiOsPrintf ("\n");
1064 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1065 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1066 if (ACPI_FAILURE (Status))
1067 {
1068 return;
1069 }
1070
1071 /* Point to next subtable (each subtable is of fixed length) */
1072
1073 Offset += sizeof (ACPI_MCFG_ALLOCATION);
1074 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable,
1075 sizeof (ACPI_MCFG_ALLOCATION));
1076 }
1077 }
1078
1079
1080 /*******************************************************************************
1081 *
1082 * FUNCTION: AcpiDmDumpMpst
1083 *
1084 * PARAMETERS: Table - A MPST Table
1085 *
1086 * RETURN: None
1087 *
1088 * DESCRIPTION: Format the contents of a MPST table
1089 *
1090 ******************************************************************************/
1091
1092 void
AcpiDmDumpMpst(ACPI_TABLE_HEADER * Table)1093 AcpiDmDumpMpst (
1094 ACPI_TABLE_HEADER *Table)
1095 {
1096 ACPI_STATUS Status;
1097 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
1098 ACPI_MPST_POWER_NODE *Subtable0;
1099 ACPI_MPST_POWER_STATE *Subtable0A;
1100 ACPI_MPST_COMPONENT *Subtable0B;
1101 ACPI_MPST_DATA_HDR *Subtable1;
1102 ACPI_MPST_POWER_DATA *Subtable2;
1103 UINT16 SubtableCount;
1104 UINT32 PowerStateCount;
1105 UINT32 ComponentCount;
1106
1107
1108 /* Main table */
1109
1110 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
1111 if (ACPI_FAILURE (Status))
1112 {
1113 return;
1114 }
1115
1116 /* Subtable: Memory Power Node(s) */
1117
1118 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
1119 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
1120
1121 while ((Offset < Table->Length) && SubtableCount)
1122 {
1123 AcpiOsPrintf ("\n");
1124 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0,
1125 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
1126 if (ACPI_FAILURE (Status))
1127 {
1128 return;
1129 }
1130
1131 /* Extract the sub-subtable counts */
1132
1133 PowerStateCount = Subtable0->NumPowerStates;
1134 ComponentCount = Subtable0->NumPhysicalComponents;
1135 Offset += sizeof (ACPI_MPST_POWER_NODE);
1136
1137 /* Sub-subtables - Memory Power State Structure(s) */
1138
1139 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0,
1140 sizeof (ACPI_MPST_POWER_NODE));
1141
1142 while (PowerStateCount)
1143 {
1144 AcpiOsPrintf ("\n");
1145 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A,
1146 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
1147 if (ACPI_FAILURE (Status))
1148 {
1149 return;
1150 }
1151
1152 Subtable0A++;
1153 PowerStateCount--;
1154 Offset += sizeof (ACPI_MPST_POWER_STATE);
1155 }
1156
1157 /* Sub-subtables - Physical Component ID Structure(s) */
1158
1159 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A);
1160
1161 if (ComponentCount)
1162 {
1163 AcpiOsPrintf ("\n");
1164 }
1165
1166 while (ComponentCount)
1167 {
1168 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B,
1169 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
1170 if (ACPI_FAILURE (Status))
1171 {
1172 return;
1173 }
1174
1175 Subtable0B++;
1176 ComponentCount--;
1177 Offset += sizeof (ACPI_MPST_COMPONENT);
1178 }
1179
1180 /* Point to next Memory Power Node subtable */
1181
1182 SubtableCount--;
1183 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0,
1184 sizeof (ACPI_MPST_POWER_NODE) +
1185 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) +
1186 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents));
1187 }
1188
1189 /* Subtable: Count of Memory Power State Characteristic structures */
1190
1191 AcpiOsPrintf ("\n");
1192 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0);
1193 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1,
1194 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1195 if (ACPI_FAILURE (Status))
1196 {
1197 return;
1198 }
1199
1200 SubtableCount = Subtable1->CharacteristicsCount;
1201 Offset += sizeof (ACPI_MPST_DATA_HDR);
1202
1203 /* Subtable: Memory Power State Characteristics structure(s) */
1204
1205 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1,
1206 sizeof (ACPI_MPST_DATA_HDR));
1207
1208 while ((Offset < Table->Length) && SubtableCount)
1209 {
1210 AcpiOsPrintf ("\n");
1211 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2,
1212 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1213 if (ACPI_FAILURE (Status))
1214 {
1215 return;
1216 }
1217
1218 Subtable2++;
1219 SubtableCount--;
1220 Offset += sizeof (ACPI_MPST_POWER_DATA);
1221 }
1222 }
1223
1224
1225 /*******************************************************************************
1226 *
1227 * FUNCTION: AcpiDmDumpMsct
1228 *
1229 * PARAMETERS: Table - A MSCT table
1230 *
1231 * RETURN: None
1232 *
1233 * DESCRIPTION: Format the contents of a MSCT
1234 *
1235 ******************************************************************************/
1236
1237 void
AcpiDmDumpMsct(ACPI_TABLE_HEADER * Table)1238 AcpiDmDumpMsct (
1239 ACPI_TABLE_HEADER *Table)
1240 {
1241 ACPI_STATUS Status;
1242 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1243 ACPI_MSCT_PROXIMITY *Subtable;
1244
1245
1246 /* Main table */
1247
1248 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1249 if (ACPI_FAILURE (Status))
1250 {
1251 return;
1252 }
1253
1254 /* Subtables */
1255
1256 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1257 while (Offset < Table->Length)
1258 {
1259 /* Common subtable header */
1260
1261 AcpiOsPrintf ("\n");
1262 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1263 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1264 if (ACPI_FAILURE (Status))
1265 {
1266 return;
1267 }
1268
1269 /* Point to next subtable */
1270
1271 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1272 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable,
1273 sizeof (ACPI_MSCT_PROXIMITY));
1274 }
1275 }
1276
1277
1278 /*******************************************************************************
1279 *
1280 * FUNCTION: AcpiDmDumpNfit
1281 *
1282 * PARAMETERS: Table - A NFIT table
1283 *
1284 * RETURN: None
1285 *
1286 * DESCRIPTION: Format the contents of an NFIT.
1287 *
1288 ******************************************************************************/
1289
1290 void
AcpiDmDumpNfit(ACPI_TABLE_HEADER * Table)1291 AcpiDmDumpNfit (
1292 ACPI_TABLE_HEADER *Table)
1293 {
1294 ACPI_STATUS Status;
1295 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
1296 UINT32 FieldOffset = 0;
1297 UINT32 Length;
1298 ACPI_NFIT_HEADER *Subtable;
1299 ACPI_DMTABLE_INFO *InfoTable;
1300 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
1301 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
1302 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
1303 UINT32 i;
1304
1305
1306 /* Main table */
1307
1308 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
1309 if (ACPI_FAILURE (Status))
1310 {
1311 return;
1312 }
1313
1314 /* Subtables */
1315
1316 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
1317 while (Offset < Table->Length)
1318 {
1319 /* NFIT subtable header */
1320
1321 AcpiOsPrintf ("\n");
1322 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1323 Subtable->Length, AcpiDmTableInfoNfitHdr);
1324 if (ACPI_FAILURE (Status))
1325 {
1326 return;
1327 }
1328
1329 switch (Subtable->Type)
1330 {
1331 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1332
1333 InfoTable = AcpiDmTableInfoNfit0;
1334 break;
1335
1336 case ACPI_NFIT_TYPE_MEMORY_MAP:
1337
1338 InfoTable = AcpiDmTableInfoNfit1;
1339 break;
1340
1341 case ACPI_NFIT_TYPE_INTERLEAVE:
1342
1343 /* Has a variable number of 32-bit values at the end */
1344
1345 InfoTable = AcpiDmTableInfoNfit2;
1346 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
1347 break;
1348
1349 case ACPI_NFIT_TYPE_SMBIOS:
1350
1351 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable);
1352 InfoTable = AcpiDmTableInfoNfit3;
1353 break;
1354
1355 case ACPI_NFIT_TYPE_CONTROL_REGION:
1356
1357 InfoTable = AcpiDmTableInfoNfit4;
1358 break;
1359
1360 case ACPI_NFIT_TYPE_DATA_REGION:
1361
1362 InfoTable = AcpiDmTableInfoNfit5;
1363 break;
1364
1365 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1366
1367 /* Has a variable number of 64-bit addresses at the end */
1368
1369 InfoTable = AcpiDmTableInfoNfit6;
1370 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64);
1371 break;
1372
1373 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */
1374
1375 InfoTable = AcpiDmTableInfoNfit7;
1376 break;
1377
1378 default:
1379 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
1380 Subtable->Type);
1381
1382 /* Attempt to continue */
1383
1384 if (!Subtable->Length)
1385 {
1386 AcpiOsPrintf ("Invalid zero length subtable\n");
1387 return;
1388 }
1389 goto NextSubtable;
1390 }
1391
1392 AcpiOsPrintf ("\n");
1393 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1394 Subtable->Length, InfoTable);
1395 if (ACPI_FAILURE (Status))
1396 {
1397 return;
1398 }
1399
1400 /* Per-subtable variable-length fields */
1401
1402 switch (Subtable->Type)
1403 {
1404 case ACPI_NFIT_TYPE_INTERLEAVE:
1405
1406 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable);
1407 for (i = 0; i < Interleave->LineCount; i++)
1408 {
1409 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1410 &Interleave->LineOffset[i],
1411 sizeof (UINT32), AcpiDmTableInfoNfit2a);
1412 if (ACPI_FAILURE (Status))
1413 {
1414 return;
1415 }
1416
1417 FieldOffset += sizeof (UINT32);
1418 }
1419 break;
1420
1421 case ACPI_NFIT_TYPE_SMBIOS:
1422
1423 Length = Subtable->Length -
1424 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
1425
1426 if (Length)
1427 {
1428 Status = AcpiDmDumpTable (Table->Length,
1429 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
1430 SmbiosInfo,
1431 Length, AcpiDmTableInfoNfit3a);
1432 if (ACPI_FAILURE (Status))
1433 {
1434 return;
1435 }
1436 }
1437
1438 break;
1439
1440 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1441
1442 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable);
1443 for (i = 0; i < Hint->HintCount; i++)
1444 {
1445 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1446 &Hint->HintAddress[i],
1447 sizeof (UINT64), AcpiDmTableInfoNfit6a);
1448 if (ACPI_FAILURE (Status))
1449 {
1450 return;
1451 }
1452
1453 FieldOffset += sizeof (UINT64);
1454 }
1455 break;
1456
1457 default:
1458 break;
1459 }
1460
1461 NextSubtable:
1462 /* Point to next subtable */
1463
1464 Offset += Subtable->Length;
1465 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length);
1466 }
1467 }
1468
1469
1470 /*******************************************************************************
1471 *
1472 * FUNCTION: AcpiDmDumpNhlt
1473 *
1474 * PARAMETERS: Table - A NHLT table
1475 *
1476 * RETURN: None
1477 *
1478 * DESCRIPTION: Format the contents of an NHLT.
1479 *
1480 ******************************************************************************/
1481
1482 void
AcpiDmDumpNhlt(ACPI_TABLE_HEADER * Table)1483 AcpiDmDumpNhlt (
1484 ACPI_TABLE_HEADER *Table)
1485 {
1486 ACPI_STATUS Status;
1487 UINT32 Offset;
1488 UINT32 TableLength = Table->Length;
1489 UINT32 EndpointCount;
1490 UINT8 FormatsCount;
1491 ACPI_NHLT_ENDPOINT *Subtable;
1492 ACPI_NHLT_FORMAT_CONFIG *FormatSubtable;
1493 ACPI_TABLE_NHLT *InfoTable;
1494 UINT32 CapabilitiesSize;
1495 UINT32 i;
1496 UINT32 j;
1497 UINT32 k;
1498 UINT32 EndpointEndOffset;
1499 UINT8 ConfigType = 0;
1500 UINT8 ArrayType;
1501 ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A *DevSpecific;
1502 ACPI_NHLT_FORMATS_CONFIG *FormatsConfig;
1503 ACPI_NHLT_LINUX_SPECIFIC_COUNT *Count;
1504 ACPI_NHLT_LINUX_SPECIFIC_DATA *LinuxData;
1505
1506
1507 /* Main table */
1508
1509 AcpiOsPrintf ("/* Main table */\n");
1510
1511 Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoNhlt);
1512 if (ACPI_FAILURE (Status))
1513 {
1514 return;
1515 }
1516
1517 /* Get the Endpoint Descriptor Count */
1518
1519 InfoTable = ACPI_ADD_PTR (ACPI_TABLE_NHLT, Table, 0);
1520 EndpointCount = InfoTable->EndpointCount;
1521
1522 /* Subtables */
1523
1524 Offset = sizeof (ACPI_TABLE_NHLT);
1525
1526 while (Offset < TableLength)
1527 {
1528 /* A variable number of Endpoint Descriptors - process each */
1529
1530 for (i = 0; i < EndpointCount; i++)
1531 {
1532 /* Do the Endpoint Descriptor table */
1533
1534 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1535 if (Subtable->DescriptorLength > TableLength)
1536 {
1537 Offset += 1;
1538 AcpiOsPrintf ("\n/* Endpoint Descriptor Length larger than"
1539 " table size: %X, table %X, adjusting table offset (+1) */\n",
1540 Subtable->DescriptorLength, TableLength);
1541
1542 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1543 }
1544
1545 AcpiOsPrintf ("\n/* Endpoint Descriptor #%u */\n", i+1);
1546 Status = AcpiDmDumpTable (TableLength, Offset, Subtable,
1547 Subtable->DescriptorLength, AcpiDmTableInfoNhlt0);
1548 if (ACPI_FAILURE (Status))
1549 {
1550 return;
1551 }
1552 EndpointEndOffset = Subtable->DescriptorLength + Offset;
1553
1554 /* Check for endpoint descriptor beyond end-of-table */
1555
1556 if (Subtable->DescriptorLength > TableLength)
1557 {
1558 AcpiOsPrintf ("\n/* Endpoint Descriptor Length larger than table size: %X, table %X */\n",
1559 Subtable->DescriptorLength, TableLength);
1560 }
1561 Offset += sizeof (ACPI_NHLT_ENDPOINT);
1562 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset);
1563
1564 /* Do the Device Specific table */
1565
1566 AcpiOsPrintf ("\n/* Endpoint Device_Specific_Config table */\n");
1567 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable);
1568 CapabilitiesSize = DevSpecific->CapabilitiesSize;
1569
1570 /* Different subtables based upon capabilities_size */
1571
1572 switch (CapabilitiesSize)
1573 {
1574 case 0:
1575 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1576 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b);
1577 if (ACPI_FAILURE (Status))
1578 {
1579 return;
1580 }
1581 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B);
1582 break;
1583
1584 case 1:
1585 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1586 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C), AcpiDmTableInfoNhlt5c);
1587 if (ACPI_FAILURE (Status))
1588 {
1589 return;
1590 }
1591 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C);
1592 break;
1593
1594 case 2:
1595 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1596 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt5);
1597 if (ACPI_FAILURE (Status))
1598 {
1599 return;
1600 }
1601 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG);
1602 break;
1603
1604 case 3:
1605 ConfigType = DevSpecific->ConfigType;
1606 ArrayType = DevSpecific->ArrayType;
1607
1608 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1609 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A), AcpiDmTableInfoNhlt5a);
1610 if (ACPI_FAILURE (Status))
1611 {
1612 return;
1613 }
1614
1615 /* Capabilities Size == 3 */
1616 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A);
1617
1618 /* Check for a vendor-defined mic array */
1619
1620 if ((ConfigType == ACPI_NHLT_TYPE_MIC_ARRAY) && ((ArrayType & ARRAY_TYPE_MASK) == VENDOR_DEFINED))
1621 {
1622 /* Vendor-defined microphone array */
1623
1624 AcpiOsPrintf ("\n/* Vendor-defined microphone array */\n");
1625
1626 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1627 sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG), AcpiDmTableInfoNhlt6);
1628 if (ACPI_FAILURE (Status))
1629 {
1630 return;
1631 }
1632 Offset += sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG);
1633 }
1634 break;
1635
1636 default:
1637 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1638 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b);
1639 if (ACPI_FAILURE (Status))
1640 {
1641 return;
1642 }
1643
1644 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B);
1645 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific,
1646 CapabilitiesSize, AcpiDmTableInfoNhlt3a);
1647 if (ACPI_FAILURE (Status))
1648 {
1649 return;
1650 }
1651 Offset += CapabilitiesSize;
1652 break;
1653 }
1654
1655 /* Do the Formats_Config table */
1656
1657 FormatsConfig = ACPI_ADD_PTR (ACPI_NHLT_FORMATS_CONFIG, Table, Offset);
1658 FormatsCount = FormatsConfig->FormatsCount;
1659
1660 AcpiOsPrintf ("\n/* Formats_Config table */\n");
1661
1662 Status = AcpiDmDumpTable (TableLength, Offset, FormatsConfig,
1663 sizeof (ACPI_NHLT_FORMATS_CONFIG), AcpiDmTableInfoNhlt4);
1664 if (ACPI_FAILURE (Status))
1665 {
1666 return;
1667 }
1668 Offset += sizeof (ACPI_NHLT_FORMATS_CONFIG);
1669
1670 /* A variable number of Format_Config Descriptors - process each */
1671
1672 for (j = 0; j < FormatsCount; j++)
1673 {
1674 FormatSubtable = ACPI_ADD_PTR (ACPI_NHLT_FORMAT_CONFIG, Table, Offset);
1675 CapabilitiesSize = FormatSubtable->CapabilitySize;
1676
1677 /* Do the Wave_extensible struct */
1678
1679 AcpiOsPrintf ("\n/* Wave_Format_Extensible table #%u */\n", j+1);
1680 Status = AcpiDmDumpTable (TableLength, Offset, FormatSubtable,
1681 sizeof (ACPI_NHLT_FORMAT_CONFIG), AcpiDmTableInfoNhlt3);
1682 if (ACPI_FAILURE (Status))
1683 {
1684 return;
1685 }
1686 Offset += sizeof (ACPI_NHLT_WAVE_EXTENSIBLE);
1687
1688 /* Do the Capabilities array */
1689
1690 Offset += sizeof (UINT32);
1691 AcpiOsPrintf ("\n/* Specific_Config table #%u */\n", j+1);
1692 FormatSubtable = ACPI_ADD_PTR (ACPI_NHLT_FORMAT_CONFIG, Table, Offset);
1693 Status = AcpiDmDumpTable (TableLength, Offset, FormatSubtable,
1694 CapabilitiesSize, AcpiDmTableInfoNhlt3a);
1695 if (ACPI_FAILURE (Status))
1696 {
1697 return;
1698 }
1699 Offset += CapabilitiesSize;
1700 }
1701
1702 /*
1703 * If we are not done with the Endpoint(s) yet, then there must be
1704 * some Linux-specific structure(s) yet to be processed.
1705 */
1706 if (Offset < EndpointEndOffset)
1707 {
1708 AcpiOsPrintf ("\n");
1709 Count = ACPI_ADD_PTR (ACPI_NHLT_LINUX_SPECIFIC_COUNT, Table, Offset);
1710 Status = AcpiDmDumpTable (TableLength, Offset, Count,
1711 sizeof (ACPI_NHLT_LINUX_SPECIFIC_COUNT), AcpiDmTableInfoNhlt7);
1712 if (ACPI_FAILURE (Status))
1713 {
1714 return;
1715 }
1716 Offset += sizeof (ACPI_NHLT_LINUX_SPECIFIC_COUNT);
1717
1718 /* Variable number of linux-specific structures */
1719
1720 for (k = 0; k < Count->StructureCount; k++)
1721 {
1722 LinuxData = ACPI_ADD_PTR (ACPI_NHLT_LINUX_SPECIFIC_DATA, Table, Offset);
1723
1724 AcpiOsPrintf ("\n/* Linux-specific structure #%u */\n", k+1);
1725
1726 Status = AcpiDmDumpTable (TableLength, Offset, LinuxData,
1727 sizeof (ACPI_NHLT_LINUX_SPECIFIC_DATA), AcpiDmTableInfoNhlt7a);
1728 if (ACPI_FAILURE (Status))
1729 {
1730 return;
1731 }
1732
1733 Offset += sizeof (ACPI_NHLT_LINUX_SPECIFIC_DATA);
1734 }
1735
1736 /* Should be at the end of the Endpoint structure. Skip any extra bytes */
1737
1738 if (Offset < EndpointEndOffset)
1739 {
1740 AcpiOsPrintf ("\n/* Endpoint descriptor ended before endpoint size was reached. "
1741 "skipped %X input bytes, current offset: %X, Endpoint End Offset: %X */\n",
1742 EndpointEndOffset - Offset, Offset, EndpointEndOffset);
1743 AcpiUtDumpBuffer (((UINT8 *)Table)+Offset,
1744 EndpointEndOffset - Offset, DB_BYTE_DISPLAY, Offset);
1745 Offset = EndpointEndOffset;
1746 }
1747 }
1748 }
1749
1750 /* Emit the table terminator (if present) */
1751
1752 if (Offset == TableLength - sizeof (ACPI_NHLT_TABLE_TERMINATOR))
1753 {
1754 LinuxData = ACPI_ADD_PTR (ACPI_NHLT_LINUX_SPECIFIC_DATA, Table, Offset);
1755 AcpiOsPrintf ("\n/* Table terminator structure */\n");
1756
1757 Status = AcpiDmDumpTable (TableLength, Offset, LinuxData,
1758 sizeof (ACPI_NHLT_TABLE_TERMINATOR), AcpiDmTableInfoNhlt8);
1759 if (ACPI_FAILURE (Status))
1760 {
1761 return;
1762 }
1763 }
1764
1765 return;
1766 }
1767 }
1768
1769
1770 /*******************************************************************************
1771 *
1772 * FUNCTION: AcpiDmDumpPcct
1773 *
1774 * PARAMETERS: Table - A PCCT table
1775 *
1776 * RETURN: None
1777 *
1778 * DESCRIPTION: Format the contents of a PCCT. This table type consists
1779 * of an open-ended number of subtables.
1780 *
1781 ******************************************************************************/
1782
1783 void
AcpiDmDumpPcct(ACPI_TABLE_HEADER * Table)1784 AcpiDmDumpPcct (
1785 ACPI_TABLE_HEADER *Table)
1786 {
1787 ACPI_STATUS Status;
1788 ACPI_PCCT_SUBSPACE *Subtable;
1789 ACPI_DMTABLE_INFO *InfoTable;
1790 UINT32 Length = Table->Length;
1791 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
1792
1793
1794 /* Main table */
1795
1796 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1797 if (ACPI_FAILURE (Status))
1798 {
1799 return;
1800 }
1801
1802 /* Subtables */
1803
1804 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1805 while (Offset < Table->Length)
1806 {
1807 /* Common subtable header */
1808
1809 AcpiOsPrintf ("\n");
1810 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1811 Subtable->Header.Length, AcpiDmTableInfoPcctHdr);
1812 if (ACPI_FAILURE (Status))
1813 {
1814 return;
1815 }
1816
1817 switch (Subtable->Header.Type)
1818 {
1819 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
1820
1821 InfoTable = AcpiDmTableInfoPcct0;
1822 break;
1823
1824 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
1825
1826 InfoTable = AcpiDmTableInfoPcct1;
1827 break;
1828
1829 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
1830
1831 InfoTable = AcpiDmTableInfoPcct2;
1832 break;
1833
1834 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
1835
1836 InfoTable = AcpiDmTableInfoPcct3;
1837 break;
1838
1839 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
1840
1841 InfoTable = AcpiDmTableInfoPcct4;
1842 break;
1843
1844 case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE:
1845
1846 InfoTable = AcpiDmTableInfoPcct5;
1847 break;
1848
1849 default:
1850
1851 AcpiOsPrintf (
1852 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
1853 Subtable->Header.Type);
1854 return;
1855 }
1856
1857 AcpiOsPrintf ("\n");
1858 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1859 Subtable->Header.Length, InfoTable);
1860 if (ACPI_FAILURE (Status))
1861 {
1862 return;
1863 }
1864
1865 /* Point to next subtable */
1866
1867 Offset += Subtable->Header.Length;
1868 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable,
1869 Subtable->Header.Length);
1870 }
1871 }
1872
1873
1874 /*******************************************************************************
1875 *
1876 * FUNCTION: AcpiDmDumpPdtt
1877 *
1878 * PARAMETERS: Table - A PDTT table
1879 *
1880 * RETURN: None
1881 *
1882 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length
1883 * table that contains an open-ended number of IDs
1884 * at the end of the table.
1885 *
1886 ******************************************************************************/
1887
1888 void
AcpiDmDumpPdtt(ACPI_TABLE_HEADER * Table)1889 AcpiDmDumpPdtt (
1890 ACPI_TABLE_HEADER *Table)
1891 {
1892 ACPI_STATUS Status;
1893 ACPI_PDTT_CHANNEL *Subtable;
1894 UINT32 Length = Table->Length;
1895 UINT32 Offset = sizeof (ACPI_TABLE_PDTT);
1896
1897
1898 /* Main table */
1899
1900 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt);
1901 if (ACPI_FAILURE (Status))
1902 {
1903 return;
1904 }
1905
1906 /* Subtables. Currently there is only one type, but can be multiples */
1907
1908 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset);
1909 while (Offset < Table->Length)
1910 {
1911 AcpiOsPrintf ("\n");
1912 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1913 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0);
1914 if (ACPI_FAILURE (Status))
1915 {
1916 return;
1917 }
1918
1919 /* Point to next subtable */
1920
1921 Offset += sizeof (ACPI_PDTT_CHANNEL);
1922 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable,
1923 sizeof (ACPI_PDTT_CHANNEL));
1924 }
1925 }
1926
1927
1928 /*******************************************************************************
1929 *
1930 * FUNCTION: AcpiDmDumpPhat
1931 *
1932 * PARAMETERS: Table - A PHAT table
1933 *
1934 * RETURN: None
1935 *
1936 * DESCRIPTION: Format the contents of a PHAT.
1937 *
1938 ******************************************************************************/
1939
1940 void
AcpiDmDumpPhat(ACPI_TABLE_HEADER * Table)1941 AcpiDmDumpPhat (
1942 ACPI_TABLE_HEADER *Table)
1943 {
1944 ACPI_STATUS Status;
1945 ACPI_DMTABLE_INFO *InfoTable;
1946 ACPI_PHAT_HEADER *Subtable;
1947 ACPI_PHAT_VERSION_DATA *VersionData;
1948 UINT32 RecordCount;
1949 UINT32 Length = Table->Length;
1950 UINT32 Offset = sizeof (ACPI_TABLE_PHAT);
1951 UINT32 SubtableLength;
1952 UINT32 PathLength;
1953 UINT32 VendorLength;
1954
1955
1956 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, sizeof (ACPI_TABLE_PHAT));
1957
1958 while (Offset < Table->Length)
1959 {
1960 /* Common subtable header */
1961
1962 AcpiOsPrintf ("\n");
1963 Status = AcpiDmDumpTable (Length, 0, Subtable,
1964 sizeof (ACPI_PHAT_HEADER), AcpiDmTableInfoPhatHdr);
1965 if (ACPI_FAILURE (Status))
1966 {
1967 return;
1968 }
1969
1970 switch (Subtable->Type)
1971 {
1972 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
1973
1974 InfoTable = AcpiDmTableInfoPhat0;
1975 SubtableLength = sizeof (ACPI_PHAT_VERSION_DATA);
1976 break;
1977
1978 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
1979
1980 InfoTable = AcpiDmTableInfoPhat1;
1981 SubtableLength = sizeof (ACPI_PHAT_HEALTH_DATA);
1982 break;
1983
1984 default:
1985
1986 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n",
1987 Subtable->Type);
1988
1989 return;
1990 }
1991
1992 Status = AcpiDmDumpTable (Length, 0, Subtable,
1993 SubtableLength, InfoTable);
1994 if (ACPI_FAILURE (Status))
1995 {
1996 return;
1997 }
1998
1999 switch (Subtable->Type)
2000 {
2001 case ACPI_PHAT_TYPE_FW_VERSION_DATA:
2002
2003 VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, Subtable);
2004 RecordCount = VersionData->ElementCount;
2005 while (RecordCount)
2006 {
2007 Status = AcpiDmDumpTable (Length, Offset,
2008 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_VERSION_DATA)),
2009 sizeof (ACPI_PHAT_VERSION_ELEMENT), AcpiDmTableInfoPhat0a);
2010 if (ACPI_FAILURE (Status))
2011 {
2012 return;
2013 }
2014
2015 RecordCount--;
2016 }
2017
2018 break;
2019
2020 case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
2021
2022 /* account for the null terminator */
2023
2024 PathLength = strlen (ACPI_ADD_PTR (char, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA))) + 1;
2025 Status = AcpiDmDumpTable (Length, Offset,
2026 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA)),
2027 PathLength, AcpiDmTableInfoPhat1a);
2028 if (ACPI_FAILURE (Status))
2029 {
2030 return;
2031 }
2032
2033 /* Get vendor data - data length is the remaining subtable length */
2034
2035 VendorLength =
2036 Subtable->Length - sizeof (ACPI_PHAT_HEALTH_DATA) - PathLength;
2037 Status = AcpiDmDumpTable (Length, 0,
2038 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA) + PathLength),
2039 VendorLength, AcpiDmTableInfoPhat1b);
2040 if (ACPI_FAILURE (Status))
2041 {
2042 return;
2043 }
2044 break;
2045
2046 default:
2047
2048 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n",
2049 Subtable->Type);
2050 return;
2051 }
2052
2053 /* Next subtable */
2054
2055 Offset += Subtable->Length;
2056 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable,
2057 Subtable->Length);
2058 }
2059 }
2060
2061
2062 /*******************************************************************************
2063 *
2064 * FUNCTION: AcpiDmDumpPmtt
2065 *
2066 * PARAMETERS: Table - A PMTT table
2067 *
2068 * RETURN: None
2069 *
2070 * DESCRIPTION: Format the contents of a PMTT. This table type consists
2071 * of an open-ended number of subtables.
2072 *
2073 ******************************************************************************/
2074
2075 void
AcpiDmDumpPmtt(ACPI_TABLE_HEADER * Table)2076 AcpiDmDumpPmtt (
2077 ACPI_TABLE_HEADER *Table)
2078 {
2079 ACPI_STATUS Status;
2080 ACPI_PMTT_HEADER *Subtable;
2081 UINT32 Length = Table->Length;
2082 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
2083
2084
2085 /* Main table */
2086
2087 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
2088 if (ACPI_FAILURE (Status))
2089 {
2090 return;
2091 }
2092
2093 /* Subtables */
2094
2095 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
2096 while (Offset < Table->Length)
2097 {
2098 /* Each of the types below contain the common subtable header */
2099
2100 AcpiOsPrintf ("\n");
2101 switch (Subtable->Type)
2102 {
2103 case ACPI_PMTT_TYPE_SOCKET:
2104
2105 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2106 Subtable->Length, AcpiDmTableInfoPmtt0);
2107 if (ACPI_FAILURE (Status))
2108 {
2109 return;
2110 }
2111 break;
2112
2113 case ACPI_PMTT_TYPE_CONTROLLER:
2114 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2115 Subtable->Length, AcpiDmTableInfoPmtt1);
2116 if (ACPI_FAILURE (Status))
2117 {
2118 return;
2119 }
2120 break;
2121
2122 case ACPI_PMTT_TYPE_DIMM:
2123 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2124 Subtable->Length, AcpiDmTableInfoPmtt2);
2125 if (ACPI_FAILURE (Status))
2126 {
2127 return;
2128 }
2129 break;
2130
2131 case ACPI_PMTT_TYPE_VENDOR:
2132 Status = AcpiDmDumpTable (Length, Offset, Subtable,
2133 Subtable->Length, AcpiDmTableInfoPmttVendor);
2134 if (ACPI_FAILURE (Status))
2135 {
2136 return;
2137 }
2138 break;
2139
2140 default:
2141 AcpiOsPrintf (
2142 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2143 Subtable->Type);
2144 return;
2145 }
2146
2147 /* Point to next subtable */
2148
2149 Offset += Subtable->Length;
2150 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2151 Subtable, Subtable->Length);
2152 }
2153 }
2154
2155
2156 /*******************************************************************************
2157 *
2158 * FUNCTION: AcpiDmDumpPptt
2159 *
2160 * PARAMETERS: Table - A PMTT table
2161 *
2162 * RETURN: None
2163 *
2164 * DESCRIPTION: Format the contents of a PPTT. This table type consists
2165 * of an open-ended number of subtables.
2166 *
2167 ******************************************************************************/
2168
2169 void
AcpiDmDumpPptt(ACPI_TABLE_HEADER * Table)2170 AcpiDmDumpPptt (
2171 ACPI_TABLE_HEADER *Table)
2172 {
2173 ACPI_STATUS Status;
2174 ACPI_SUBTABLE_HEADER *Subtable;
2175 ACPI_PPTT_PROCESSOR *PpttProcessor;
2176 UINT8 Length;
2177 UINT8 SubtableOffset;
2178 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
2179 ACPI_DMTABLE_INFO *InfoTable;
2180 UINT32 i;
2181
2182
2183 /* There is no main table (other than the standard ACPI header) */
2184
2185 /* Subtables */
2186
2187 Offset = sizeof (ACPI_TABLE_HEADER);
2188 while (Offset < Table->Length)
2189 {
2190 AcpiOsPrintf ("\n");
2191
2192 /* Common subtable header */
2193
2194 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2195 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER))
2196 {
2197 AcpiOsPrintf ("Invalid subtable length\n");
2198 return;
2199 }
2200 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2201 Subtable->Length, AcpiDmTableInfoPpttHdr);
2202 if (ACPI_FAILURE (Status))
2203 {
2204 return;
2205 }
2206
2207 switch (Subtable->Type)
2208 {
2209 case ACPI_PPTT_TYPE_PROCESSOR:
2210
2211 InfoTable = AcpiDmTableInfoPptt0;
2212 Length = sizeof (ACPI_PPTT_PROCESSOR);
2213 break;
2214
2215 case ACPI_PPTT_TYPE_CACHE:
2216
2217 InfoTable = AcpiDmTableInfoPptt1;
2218 Length = sizeof (ACPI_PPTT_CACHE);
2219 break;
2220
2221 case ACPI_PPTT_TYPE_ID:
2222
2223 InfoTable = AcpiDmTableInfoPptt2;
2224 Length = sizeof (ACPI_PPTT_ID);
2225 break;
2226
2227 default:
2228
2229 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
2230 Subtable->Type);
2231
2232 /* Attempt to continue */
2233
2234 goto NextSubtable;
2235 }
2236
2237 if (Subtable->Length < Length)
2238 {
2239 AcpiOsPrintf ("Invalid subtable length\n");
2240 return;
2241 }
2242 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2243 Subtable->Length, InfoTable);
2244 if (ACPI_FAILURE (Status))
2245 {
2246 return;
2247 }
2248 SubtableOffset = Length;
2249
2250 switch (Subtable->Type)
2251 {
2252 case ACPI_PPTT_TYPE_PROCESSOR:
2253
2254 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable);
2255
2256 /* Dump SMBIOS handles */
2257
2258 if ((UINT8)(Subtable->Length - SubtableOffset) <
2259 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
2260 {
2261 AcpiOsPrintf ("Invalid private resource number\n");
2262 return;
2263 }
2264 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
2265 {
2266 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2267 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2268 4, AcpiDmTableInfoPptt0a);
2269 if (ACPI_FAILURE (Status))
2270 {
2271 return;
2272 }
2273
2274 SubtableOffset += 4;
2275 }
2276 break;
2277
2278 case ACPI_PPTT_TYPE_CACHE:
2279
2280 if (Table->Revision < 3)
2281 {
2282 break;
2283 }
2284 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2285 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
2286 sizeof (ACPI_PPTT_CACHE_V1), AcpiDmTableInfoPptt1a);
2287 if (ACPI_FAILURE (Status))
2288 {
2289 return;
2290 }
2291 break;
2292
2293 default:
2294
2295 break;
2296 }
2297
2298 NextSubtable:
2299 /* Point to next subtable */
2300
2301 Offset += Subtable->Length;
2302 }
2303 }
2304
2305
2306 /*******************************************************************************
2307 *
2308 * FUNCTION: AcpiDmDumpPrmt
2309 *
2310 * PARAMETERS: Table - A PRMT table
2311 *
2312 * RETURN: None
2313 *
2314 * DESCRIPTION: Format the contents of a PRMT. This table type consists
2315 * of an open-ended number of subtables.
2316 *
2317 ******************************************************************************/
2318
2319 void
AcpiDmDumpPrmt(ACPI_TABLE_HEADER * Table)2320 AcpiDmDumpPrmt (
2321 ACPI_TABLE_HEADER *Table)
2322 {
2323 UINT32 CurrentOffset = sizeof (ACPI_TABLE_HEADER);
2324 ACPI_TABLE_PRMT_HEADER *PrmtHeader;
2325 ACPI_PRMT_MODULE_INFO *PrmtModuleInfo;
2326 ACPI_PRMT_HANDLER_INFO *PrmtHandlerInfo;
2327 ACPI_STATUS Status;
2328 UINT32 i, j;
2329
2330
2331 /* Main table header */
2332
2333 PrmtHeader = ACPI_ADD_PTR (ACPI_TABLE_PRMT_HEADER, Table, CurrentOffset);
2334 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHeader,
2335 sizeof (ACPI_TABLE_PRMT_HEADER), AcpiDmTableInfoPrmtHdr);
2336 if (ACPI_FAILURE (Status))
2337 {
2338 AcpiOsPrintf ("Invalid PRMT header\n");
2339 return;
2340 }
2341
2342 CurrentOffset += sizeof (ACPI_TABLE_PRMT_HEADER);
2343
2344 /* PRM Module Information Structure array */
2345
2346 for (i = 0; i < PrmtHeader->ModuleInfoCount; ++i)
2347 {
2348 PrmtModuleInfo = ACPI_ADD_PTR (ACPI_PRMT_MODULE_INFO, Table, CurrentOffset);
2349 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtModuleInfo,
2350 sizeof (ACPI_PRMT_MODULE_INFO), AcpiDmTableInfoPrmtModule);
2351
2352 CurrentOffset += sizeof (ACPI_PRMT_MODULE_INFO);
2353
2354 /* PRM handler information structure array */
2355
2356 for (j = 0; j < PrmtModuleInfo->HandlerInfoCount; ++j)
2357 {
2358 PrmtHandlerInfo = ACPI_ADD_PTR (ACPI_PRMT_HANDLER_INFO, Table, CurrentOffset);
2359 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHandlerInfo,
2360 sizeof (ACPI_PRMT_HANDLER_INFO), AcpiDmTableInfoPrmtHandler);
2361
2362 CurrentOffset += sizeof (ACPI_PRMT_HANDLER_INFO);
2363 }
2364 }
2365 }
2366
2367
2368 /*******************************************************************************
2369 *
2370 * FUNCTION: AcpiDmDumpRgrt
2371 *
2372 * PARAMETERS: Table - A RGRT table
2373 *
2374 * RETURN: None
2375 *
2376 * DESCRIPTION: Format the contents of a RGRT
2377 *
2378 ******************************************************************************/
2379
2380 void
AcpiDmDumpRgrt(ACPI_TABLE_HEADER * Table)2381 AcpiDmDumpRgrt (
2382 ACPI_TABLE_HEADER *Table)
2383 {
2384 ACPI_STATUS Status;
2385 ACPI_TABLE_RGRT *Subtable = ACPI_CAST_PTR (ACPI_TABLE_RGRT, Table);
2386 UINT32 Offset = sizeof (ACPI_TABLE_RGRT);
2387
2388
2389 /* Main table */
2390
2391 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoRgrt);
2392 if (ACPI_FAILURE (Status))
2393 {
2394 return;
2395 }
2396
2397 /* Dump the binary image as a subtable */
2398
2399 Status = AcpiDmDumpTable (Table->Length, Offset, &Subtable->Image,
2400 Table->Length - Offset, AcpiDmTableInfoRgrt0);
2401 if (ACPI_FAILURE (Status))
2402 {
2403 return;
2404 }
2405 }
2406
2407
2408 /*******************************************************************************
2409 *
2410 * FUNCTION: AcpiDmDumpS3pt
2411 *
2412 * PARAMETERS: Table - A S3PT table
2413 *
2414 * RETURN: Length of the table
2415 *
2416 * DESCRIPTION: Format the contents of a S3PT
2417 *
2418 ******************************************************************************/
2419
2420 UINT32
AcpiDmDumpS3pt(ACPI_TABLE_HEADER * Tables)2421 AcpiDmDumpS3pt (
2422 ACPI_TABLE_HEADER *Tables)
2423 {
2424 ACPI_STATUS Status;
2425 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
2426 ACPI_FPDT_HEADER *Subtable;
2427 ACPI_DMTABLE_INFO *InfoTable;
2428 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
2429
2430
2431 /* Main table */
2432
2433 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
2434 if (ACPI_FAILURE (Status))
2435 {
2436 return 0;
2437 }
2438
2439 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
2440 while (Offset < S3ptTable->Length)
2441 {
2442 /* Common subtable header */
2443
2444 AcpiOsPrintf ("\n");
2445 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
2446 Subtable->Length, AcpiDmTableInfoS3ptHdr);
2447 if (ACPI_FAILURE (Status))
2448 {
2449 return 0;
2450 }
2451
2452 switch (Subtable->Type)
2453 {
2454 case ACPI_S3PT_TYPE_RESUME:
2455
2456 InfoTable = AcpiDmTableInfoS3pt0;
2457 break;
2458
2459 case ACPI_S3PT_TYPE_SUSPEND:
2460
2461 InfoTable = AcpiDmTableInfoS3pt1;
2462 break;
2463
2464 default:
2465
2466 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
2467 Subtable->Type);
2468
2469 /* Attempt to continue */
2470
2471 if (!Subtable->Length)
2472 {
2473 AcpiOsPrintf ("Invalid zero length subtable\n");
2474 return 0;
2475 }
2476 goto NextSubtable;
2477 }
2478
2479 AcpiOsPrintf ("\n");
2480 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
2481 Subtable->Length, InfoTable);
2482 if (ACPI_FAILURE (Status))
2483 {
2484 return 0;
2485 }
2486
2487 NextSubtable:
2488 /* Point to next subtable */
2489
2490 Offset += Subtable->Length;
2491 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length);
2492 }
2493
2494 return (S3ptTable->Length);
2495 }
2496
2497
2498 /*******************************************************************************
2499 *
2500 * FUNCTION: AcpiDmDumpSdev
2501 *
2502 * PARAMETERS: Table - A SDEV table
2503 *
2504 * RETURN: None
2505 *
2506 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length
2507 * table that contains variable strings and vendor data.
2508 *
2509 ******************************************************************************/
2510
2511 void
AcpiDmDumpSdev(ACPI_TABLE_HEADER * Table)2512 AcpiDmDumpSdev (
2513 ACPI_TABLE_HEADER *Table)
2514 {
2515 ACPI_STATUS Status;
2516 ACPI_SDEV_HEADER *Subtable;
2517 ACPI_SDEV_PCIE *Pcie;
2518 ACPI_SDEV_NAMESPACE *Namesp;
2519 ACPI_DMTABLE_INFO *InfoTable;
2520 ACPI_DMTABLE_INFO *SecureComponentInfoTable;
2521 UINT32 Length = Table->Length;
2522 UINT32 Offset = sizeof (ACPI_TABLE_SDEV);
2523 UINT16 PathOffset;
2524 UINT16 PathLength;
2525 UINT16 VendorDataOffset;
2526 UINT16 VendorDataLength;
2527 ACPI_SDEV_SECURE_COMPONENT *SecureComponent = NULL;
2528 UINT32 CurrentOffset = 0;
2529
2530
2531 /* Main table */
2532
2533 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev);
2534 if (ACPI_FAILURE (Status))
2535 {
2536 return;
2537 }
2538
2539 /* Subtables */
2540
2541 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset);
2542 while (Offset < Table->Length)
2543 {
2544 /* Common subtable header */
2545
2546 AcpiOsPrintf ("\n");
2547 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
2548 Subtable->Length, AcpiDmTableInfoSdevHdr);
2549 if (ACPI_FAILURE (Status))
2550 {
2551 return;
2552 }
2553
2554 switch (Subtable->Type)
2555 {
2556 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
2557
2558 InfoTable = AcpiDmTableInfoSdev0;
2559 break;
2560
2561 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
2562
2563 InfoTable = AcpiDmTableInfoSdev1;
2564 break;
2565
2566 default:
2567 goto NextSubtable;
2568 }
2569
2570 AcpiOsPrintf ("\n");
2571 Status = AcpiDmDumpTable (Table->Length, 0, Subtable,
2572 Subtable->Length, InfoTable);
2573 if (ACPI_FAILURE (Status))
2574 {
2575 return;
2576 }
2577
2578 switch (Subtable->Type)
2579 {
2580 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
2581
2582 CurrentOffset = sizeof (ACPI_SDEV_NAMESPACE);
2583 if (Subtable->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT)
2584 {
2585 SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT,
2586 ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)));
2587
2588 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2589 ACPI_ADD_PTR(UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)),
2590 sizeof (ACPI_SDEV_SECURE_COMPONENT), AcpiDmTableInfoSdev0b);
2591 if (ACPI_FAILURE (Status))
2592 {
2593 return;
2594 }
2595 CurrentOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT);
2596
2597 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2598 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
2599 sizeof (ACPI_SDEV_HEADER), AcpiDmTableInfoSdevSecCompHdr);
2600 if (ACPI_FAILURE (Status))
2601 {
2602 return;
2603 }
2604 CurrentOffset += sizeof (ACPI_SDEV_HEADER);
2605
2606 switch (Subtable->Type)
2607 {
2608 case ACPI_SDEV_TYPE_ID_COMPONENT:
2609
2610 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId;
2611 break;
2612
2613 case ACPI_SDEV_TYPE_MEM_COMPONENT:
2614
2615 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem;
2616 break;
2617
2618 default:
2619 goto NextSubtable;
2620 }
2621
2622 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2623 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
2624 SecureComponent->SecureComponentLength, SecureComponentInfoTable);
2625 CurrentOffset += SecureComponent->SecureComponentLength;
2626 }
2627
2628 /* Dump the PCIe device ID(s) */
2629
2630 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable);
2631 PathOffset = Namesp->DeviceIdOffset;
2632 PathLength = Namesp->DeviceIdLength;
2633
2634 if (PathLength)
2635 {
2636 Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
2637 ACPI_ADD_PTR (UINT8, Namesp, PathOffset),
2638 PathLength, AcpiDmTableInfoSdev0a);
2639 if (ACPI_FAILURE (Status))
2640 {
2641 return;
2642 }
2643 CurrentOffset += PathLength;
2644 }
2645
2646 /* Dump the vendor-specific data */
2647
2648 VendorDataLength =
2649 Namesp->VendorDataLength;
2650 VendorDataOffset =
2651 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
2652
2653 if (VendorDataLength)
2654 {
2655 Status = AcpiDmDumpTable (Table->Length, 0,
2656 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset),
2657 VendorDataLength, AcpiDmTableInfoSdev1b);
2658 if (ACPI_FAILURE (Status))
2659 {
2660 return;
2661 }
2662 }
2663 break;
2664
2665 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
2666
2667 /* PCI path substructures */
2668
2669 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable);
2670 PathOffset = Pcie->PathOffset;
2671 PathLength = Pcie->PathLength;
2672
2673 while (PathLength)
2674 {
2675 Status = AcpiDmDumpTable (Table->Length,
2676 PathOffset + Offset,
2677 ACPI_ADD_PTR (UINT8, Pcie, PathOffset),
2678 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a);
2679 if (ACPI_FAILURE (Status))
2680 {
2681 return;
2682 }
2683
2684 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH);
2685 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH);
2686 }
2687
2688 /* VendorData */
2689
2690 VendorDataLength = Pcie->VendorDataLength;
2691 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength;
2692
2693 if (VendorDataLength)
2694 {
2695 Status = AcpiDmDumpTable (Table->Length, 0,
2696 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset),
2697 VendorDataLength, AcpiDmTableInfoSdev1b);
2698 if (ACPI_FAILURE (Status))
2699 {
2700 return;
2701 }
2702 }
2703 break;
2704
2705 default:
2706 goto NextSubtable;
2707 }
2708
2709 NextSubtable:
2710 /* Point to next subtable */
2711
2712 Offset += Subtable->Length;
2713 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable,
2714 Subtable->Length);
2715 }
2716 }
2717