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 - 2018, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include "acpi.h"
153 #include "accommon.h"
154 #include "acdisasm.h"
155 #include "actables.h"
156
157 /* This module used for application-level code only */
158
159 #define _COMPONENT ACPI_CA_DISASSEMBLER
160 ACPI_MODULE_NAME ("dmtbdump2")
161
162
163 /*******************************************************************************
164 *
165 * FUNCTION: AcpiDmDumpIort
166 *
167 * PARAMETERS: Table - A IORT table
168 *
169 * RETURN: None
170 *
171 * DESCRIPTION: Format the contents of a IORT
172 *
173 ******************************************************************************/
174
175 void
AcpiDmDumpIort(ACPI_TABLE_HEADER * Table)176 AcpiDmDumpIort (
177 ACPI_TABLE_HEADER *Table)
178 {
179 ACPI_STATUS Status;
180 ACPI_TABLE_IORT *Iort;
181 ACPI_IORT_NODE *IortNode;
182 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL;
183 ACPI_IORT_SMMU *IortSmmu = NULL;
184 UINT32 Offset;
185 UINT32 NodeOffset;
186 UINT32 Length;
187 ACPI_DMTABLE_INFO *InfoTable;
188 char *String;
189 UINT32 i;
190
191
192 /* Main table */
193
194 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
195 if (ACPI_FAILURE (Status))
196 {
197 return;
198 }
199
200 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
201 Offset = sizeof (ACPI_TABLE_IORT);
202
203 /* Dump the OptionalPadding (optional) */
204
205 if (Iort->NodeOffset > Offset)
206 {
207 Status = AcpiDmDumpTable (Table->Length, Offset, Table,
208 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
209 if (ACPI_FAILURE (Status))
210 {
211 return;
212 }
213 }
214
215 Offset = Iort->NodeOffset;
216 while (Offset < Table->Length)
217 {
218 /* Common subtable header */
219
220 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
221 AcpiOsPrintf ("\n");
222 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
223 Status = AcpiDmDumpTable (Table->Length, Offset,
224 IortNode, Length, AcpiDmTableInfoIortHdr);
225 if (ACPI_FAILURE (Status))
226 {
227 return;
228 }
229
230 NodeOffset = Length;
231
232 switch (IortNode->Type)
233 {
234 case ACPI_IORT_NODE_ITS_GROUP:
235
236 InfoTable = AcpiDmTableInfoIort0;
237 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
238 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
239 break;
240
241 case ACPI_IORT_NODE_NAMED_COMPONENT:
242
243 InfoTable = AcpiDmTableInfoIort1;
244 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
245 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
246 Length += strlen (String) + 1;
247 break;
248
249 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
250
251 InfoTable = AcpiDmTableInfoIort2;
252 Length = IortNode->Length - NodeOffset;
253 break;
254
255 case ACPI_IORT_NODE_SMMU:
256
257 InfoTable = AcpiDmTableInfoIort3;
258 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
259 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
260 break;
261
262 case ACPI_IORT_NODE_SMMU_V3:
263
264 InfoTable = AcpiDmTableInfoIort4;
265 Length = IortNode->Length - NodeOffset;
266 break;
267
268 case ACPI_IORT_NODE_PMCG:
269
270 InfoTable = AcpiDmTableInfoIort5;
271 Length = IortNode->Length - NodeOffset;
272 break;
273
274 default:
275
276 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
277 IortNode->Type);
278
279 /* Attempt to continue */
280
281 if (!IortNode->Length)
282 {
283 AcpiOsPrintf ("Invalid zero length IORT node\n");
284 return;
285 }
286 goto NextSubtable;
287 }
288
289 /* Dump the node subtable header */
290
291 AcpiOsPrintf ("\n");
292 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
293 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
294 Length, InfoTable);
295 if (ACPI_FAILURE (Status))
296 {
297 return;
298 }
299
300 NodeOffset += Length;
301
302 /* Dump the node specific data */
303
304 switch (IortNode->Type)
305 {
306 case ACPI_IORT_NODE_ITS_GROUP:
307
308 /* Validate IortItsGroup to avoid compiler warnings */
309
310 if (IortItsGroup)
311 {
312 for (i = 0; i < IortItsGroup->ItsCount; i++)
313 {
314 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
315 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
316 4, AcpiDmTableInfoIort0a);
317 NodeOffset += 4;
318 }
319 }
320 break;
321
322 case ACPI_IORT_NODE_NAMED_COMPONENT:
323
324 /* Dump the Padding (optional) */
325
326 if (IortNode->Length > NodeOffset)
327 {
328 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
329 Table, IortNode->Length - NodeOffset,
330 AcpiDmTableInfoIort1a);
331 if (ACPI_FAILURE (Status))
332 {
333 return;
334 }
335 }
336 break;
337
338 case ACPI_IORT_NODE_SMMU:
339
340 AcpiOsPrintf ("\n");
341
342 /* Validate IortSmmu to avoid compiler warnings */
343
344 if (IortSmmu)
345 {
346 Length = 2 * sizeof (UINT64);
347 NodeOffset = IortSmmu->GlobalInterruptOffset;
348 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
349 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
350 Length, AcpiDmTableInfoIort3a);
351 if (ACPI_FAILURE (Status))
352 {
353 return;
354 }
355
356 NodeOffset = IortSmmu->ContextInterruptOffset;
357 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
358 {
359 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
360 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
361 8, AcpiDmTableInfoIort3b);
362 if (ACPI_FAILURE (Status))
363 {
364 return;
365 }
366
367 NodeOffset += 8;
368 }
369
370 NodeOffset = IortSmmu->PmuInterruptOffset;
371 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
372 {
373 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
374 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
375 8, AcpiDmTableInfoIort3c);
376 if (ACPI_FAILURE (Status))
377 {
378 return;
379 }
380
381 NodeOffset += 8;
382 }
383 }
384 break;
385
386 default:
387
388 break;
389 }
390
391 /* Dump the ID mappings */
392
393 NodeOffset = IortNode->MappingOffset;
394 for (i = 0; i < IortNode->MappingCount; i++)
395 {
396 AcpiOsPrintf ("\n");
397 Length = sizeof (ACPI_IORT_ID_MAPPING);
398 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
399 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
400 Length, AcpiDmTableInfoIortMap);
401 if (ACPI_FAILURE (Status))
402 {
403 return;
404 }
405
406 NodeOffset += Length;
407 }
408
409 NextSubtable:
410 /* Point to next node subtable */
411
412 Offset += IortNode->Length;
413 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length);
414 }
415 }
416
417
418 /*******************************************************************************
419 *
420 * FUNCTION: AcpiDmDumpIvrs
421 *
422 * PARAMETERS: Table - A IVRS table
423 *
424 * RETURN: None
425 *
426 * DESCRIPTION: Format the contents of a IVRS
427 *
428 ******************************************************************************/
429
430 static UINT8 EntrySizes[] = {4,8,16,32};
431
432 void
AcpiDmDumpIvrs(ACPI_TABLE_HEADER * Table)433 AcpiDmDumpIvrs (
434 ACPI_TABLE_HEADER *Table)
435 {
436 ACPI_STATUS Status;
437 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
438 UINT32 EntryOffset;
439 UINT32 EntryLength;
440 UINT32 EntryType;
441 ACPI_IVRS_DE_HEADER *DeviceEntry;
442 ACPI_IVRS_HEADER *Subtable;
443 ACPI_DMTABLE_INFO *InfoTable;
444
445
446 /* Main table */
447
448 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
449 if (ACPI_FAILURE (Status))
450 {
451 return;
452 }
453
454 /* Subtables */
455
456 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
457 while (Offset < Table->Length)
458 {
459 /* Common subtable header */
460
461 AcpiOsPrintf ("\n");
462 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
463 Subtable->Length, AcpiDmTableInfoIvrsHdr);
464 if (ACPI_FAILURE (Status))
465 {
466 return;
467 }
468
469 switch (Subtable->Type)
470 {
471 case ACPI_IVRS_TYPE_HARDWARE:
472
473 InfoTable = AcpiDmTableInfoIvrs0;
474 break;
475
476 case ACPI_IVRS_TYPE_MEMORY1:
477 case ACPI_IVRS_TYPE_MEMORY2:
478 case ACPI_IVRS_TYPE_MEMORY3:
479
480 InfoTable = AcpiDmTableInfoIvrs1;
481 break;
482
483 default:
484
485 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
486 Subtable->Type);
487
488 /* Attempt to continue */
489
490 if (!Subtable->Length)
491 {
492 AcpiOsPrintf ("Invalid zero length subtable\n");
493 return;
494 }
495 goto NextSubtable;
496 }
497
498 /* Dump the subtable */
499
500 AcpiOsPrintf ("\n");
501 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
502 Subtable->Length, InfoTable);
503 if (ACPI_FAILURE (Status))
504 {
505 return;
506 }
507
508 /* The hardware subtable can contain multiple device entries */
509
510 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE)
511 {
512 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
513 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
514 sizeof (ACPI_IVRS_HARDWARE));
515
516 while (EntryOffset < (Offset + Subtable->Length))
517 {
518 AcpiOsPrintf ("\n");
519 /*
520 * Upper 2 bits of Type encode the length of the device entry
521 *
522 * 00 = 4 byte
523 * 01 = 8 byte
524 * 10 = 16 byte - currently no entries defined
525 * 11 = 32 byte - currently no entries defined
526 */
527 EntryType = DeviceEntry->Type;
528 EntryLength = EntrySizes [EntryType >> 6];
529
530 switch (EntryType)
531 {
532 /* 4-byte device entries */
533
534 case ACPI_IVRS_TYPE_PAD4:
535 case ACPI_IVRS_TYPE_ALL:
536 case ACPI_IVRS_TYPE_SELECT:
537 case ACPI_IVRS_TYPE_START:
538 case ACPI_IVRS_TYPE_END:
539
540 InfoTable = AcpiDmTableInfoIvrs4;
541 break;
542
543 /* 8-byte entries, type A */
544
545 case ACPI_IVRS_TYPE_ALIAS_SELECT:
546 case ACPI_IVRS_TYPE_ALIAS_START:
547
548 InfoTable = AcpiDmTableInfoIvrs8a;
549 break;
550
551 /* 8-byte entries, type B */
552
553 case ACPI_IVRS_TYPE_PAD8:
554 case ACPI_IVRS_TYPE_EXT_SELECT:
555 case ACPI_IVRS_TYPE_EXT_START:
556
557 InfoTable = AcpiDmTableInfoIvrs8b;
558 break;
559
560 /* 8-byte entries, type C */
561
562 case ACPI_IVRS_TYPE_SPECIAL:
563
564 InfoTable = AcpiDmTableInfoIvrs8c;
565 break;
566
567 default:
568 InfoTable = AcpiDmTableInfoIvrs4;
569 AcpiOsPrintf (
570 "\n**** Unknown IVRS device entry type/length: "
571 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
572 EntryType, EntryLength, EntryOffset);
573 break;
574 }
575
576 /* Dump the Device Entry */
577
578 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
579 DeviceEntry, EntryLength, InfoTable);
580 if (ACPI_FAILURE (Status))
581 {
582 return;
583 }
584
585 EntryOffset += EntryLength;
586 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
587 EntryLength);
588 }
589 }
590
591 NextSubtable:
592 /* Point to next subtable */
593
594 Offset += Subtable->Length;
595 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, Subtable->Length);
596 }
597 }
598
599
600 /*******************************************************************************
601 *
602 * FUNCTION: AcpiDmDumpLpit
603 *
604 * PARAMETERS: Table - A LPIT table
605 *
606 * RETURN: None
607 *
608 * DESCRIPTION: Format the contents of a LPIT. This table type consists
609 * of an open-ended number of subtables. Note: There are no
610 * entries in the main table. An LPIT consists of the table
611 * header and then subtables only.
612 *
613 ******************************************************************************/
614
615 void
AcpiDmDumpLpit(ACPI_TABLE_HEADER * Table)616 AcpiDmDumpLpit (
617 ACPI_TABLE_HEADER *Table)
618 {
619 ACPI_STATUS Status;
620 ACPI_LPIT_HEADER *Subtable;
621 UINT32 Length = Table->Length;
622 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
623 ACPI_DMTABLE_INFO *InfoTable;
624 UINT32 SubtableLength;
625
626
627 /* Subtables */
628
629 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
630 while (Offset < Table->Length)
631 {
632 /* Common subtable header */
633
634 Status = AcpiDmDumpTable (Length, Offset, Subtable,
635 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
636 if (ACPI_FAILURE (Status))
637 {
638 return;
639 }
640
641 switch (Subtable->Type)
642 {
643 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
644
645 InfoTable = AcpiDmTableInfoLpit0;
646 SubtableLength = sizeof (ACPI_LPIT_NATIVE);
647 break;
648
649 default:
650
651 /* Cannot continue on unknown type - no length */
652
653 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
654 Subtable->Type);
655 return;
656 }
657
658 Status = AcpiDmDumpTable (Length, Offset, Subtable,
659 SubtableLength, InfoTable);
660 if (ACPI_FAILURE (Status))
661 {
662 return;
663 }
664
665 AcpiOsPrintf ("\n");
666
667 /* Point to next subtable */
668
669 Offset += SubtableLength;
670 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength);
671 }
672 }
673
674
675 /*******************************************************************************
676 *
677 * FUNCTION: AcpiDmDumpMadt
678 *
679 * PARAMETERS: Table - A MADT table
680 *
681 * RETURN: None
682 *
683 * DESCRIPTION: Format the contents of a MADT. This table type consists
684 * of an open-ended number of subtables.
685 *
686 ******************************************************************************/
687
688 void
AcpiDmDumpMadt(ACPI_TABLE_HEADER * Table)689 AcpiDmDumpMadt (
690 ACPI_TABLE_HEADER *Table)
691 {
692 ACPI_STATUS Status;
693 ACPI_SUBTABLE_HEADER *Subtable;
694 UINT32 Length = Table->Length;
695 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
696 ACPI_DMTABLE_INFO *InfoTable;
697
698
699 /* Main table */
700
701 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
702 if (ACPI_FAILURE (Status))
703 {
704 return;
705 }
706
707 /* Subtables */
708
709 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
710 while (Offset < Table->Length)
711 {
712 /* Common subtable header */
713
714 AcpiOsPrintf ("\n");
715 Status = AcpiDmDumpTable (Length, Offset, Subtable,
716 Subtable->Length, AcpiDmTableInfoMadtHdr);
717 if (ACPI_FAILURE (Status))
718 {
719 return;
720 }
721
722 switch (Subtable->Type)
723 {
724 case ACPI_MADT_TYPE_LOCAL_APIC:
725
726 InfoTable = AcpiDmTableInfoMadt0;
727 break;
728
729 case ACPI_MADT_TYPE_IO_APIC:
730
731 InfoTable = AcpiDmTableInfoMadt1;
732 break;
733
734 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
735
736 InfoTable = AcpiDmTableInfoMadt2;
737 break;
738
739 case ACPI_MADT_TYPE_NMI_SOURCE:
740
741 InfoTable = AcpiDmTableInfoMadt3;
742 break;
743
744 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
745
746 InfoTable = AcpiDmTableInfoMadt4;
747 break;
748
749 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
750
751 InfoTable = AcpiDmTableInfoMadt5;
752 break;
753
754 case ACPI_MADT_TYPE_IO_SAPIC:
755
756 InfoTable = AcpiDmTableInfoMadt6;
757 break;
758
759 case ACPI_MADT_TYPE_LOCAL_SAPIC:
760
761 InfoTable = AcpiDmTableInfoMadt7;
762 break;
763
764 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
765
766 InfoTable = AcpiDmTableInfoMadt8;
767 break;
768
769 case ACPI_MADT_TYPE_LOCAL_X2APIC:
770
771 InfoTable = AcpiDmTableInfoMadt9;
772 break;
773
774 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
775
776 InfoTable = AcpiDmTableInfoMadt10;
777 break;
778
779 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
780
781 InfoTable = AcpiDmTableInfoMadt11;
782 break;
783
784 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
785
786 InfoTable = AcpiDmTableInfoMadt12;
787 break;
788
789 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
790
791 InfoTable = AcpiDmTableInfoMadt13;
792 break;
793
794 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
795
796 InfoTable = AcpiDmTableInfoMadt14;
797 break;
798
799 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
800
801 InfoTable = AcpiDmTableInfoMadt15;
802 break;
803
804 default:
805
806 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
807 Subtable->Type);
808
809 /* Attempt to continue */
810
811 if (!Subtable->Length)
812 {
813 AcpiOsPrintf ("Invalid zero length subtable\n");
814 return;
815 }
816
817 goto NextSubtable;
818 }
819
820 Status = AcpiDmDumpTable (Length, Offset, Subtable,
821 Subtable->Length, InfoTable);
822 if (ACPI_FAILURE (Status))
823 {
824 return;
825 }
826
827 NextSubtable:
828 /* Point to next subtable */
829
830 Offset += Subtable->Length;
831 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable,
832 Subtable->Length);
833 }
834 }
835
836
837 /*******************************************************************************
838 *
839 * FUNCTION: AcpiDmDumpMcfg
840 *
841 * PARAMETERS: Table - A MCFG Table
842 *
843 * RETURN: None
844 *
845 * DESCRIPTION: Format the contents of a MCFG table
846 *
847 ******************************************************************************/
848
849 void
AcpiDmDumpMcfg(ACPI_TABLE_HEADER * Table)850 AcpiDmDumpMcfg (
851 ACPI_TABLE_HEADER *Table)
852 {
853 ACPI_STATUS Status;
854 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
855 ACPI_MCFG_ALLOCATION *Subtable;
856
857
858 /* Main table */
859
860 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
861 if (ACPI_FAILURE (Status))
862 {
863 return;
864 }
865
866 /* Subtables */
867
868 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
869 while (Offset < Table->Length)
870 {
871 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
872 {
873 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
874 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
875 return;
876 }
877
878 AcpiOsPrintf ("\n");
879 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
880 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
881 if (ACPI_FAILURE (Status))
882 {
883 return;
884 }
885
886 /* Point to next subtable (each subtable is of fixed length) */
887
888 Offset += sizeof (ACPI_MCFG_ALLOCATION);
889 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable,
890 sizeof (ACPI_MCFG_ALLOCATION));
891 }
892 }
893
894
895 /*******************************************************************************
896 *
897 * FUNCTION: AcpiDmDumpMpst
898 *
899 * PARAMETERS: Table - A MPST Table
900 *
901 * RETURN: None
902 *
903 * DESCRIPTION: Format the contents of a MPST table
904 *
905 ******************************************************************************/
906
907 void
AcpiDmDumpMpst(ACPI_TABLE_HEADER * Table)908 AcpiDmDumpMpst (
909 ACPI_TABLE_HEADER *Table)
910 {
911 ACPI_STATUS Status;
912 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
913 ACPI_MPST_POWER_NODE *Subtable0;
914 ACPI_MPST_POWER_STATE *Subtable0A;
915 ACPI_MPST_COMPONENT *Subtable0B;
916 ACPI_MPST_DATA_HDR *Subtable1;
917 ACPI_MPST_POWER_DATA *Subtable2;
918 UINT16 SubtableCount;
919 UINT32 PowerStateCount;
920 UINT32 ComponentCount;
921
922
923 /* Main table */
924
925 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
926 if (ACPI_FAILURE (Status))
927 {
928 return;
929 }
930
931 /* Subtable: Memory Power Node(s) */
932
933 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
934 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
935
936 while ((Offset < Table->Length) && SubtableCount)
937 {
938 AcpiOsPrintf ("\n");
939 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0,
940 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
941 if (ACPI_FAILURE (Status))
942 {
943 return;
944 }
945
946 /* Extract the sub-subtable counts */
947
948 PowerStateCount = Subtable0->NumPowerStates;
949 ComponentCount = Subtable0->NumPhysicalComponents;
950 Offset += sizeof (ACPI_MPST_POWER_NODE);
951
952 /* Sub-subtables - Memory Power State Structure(s) */
953
954 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0,
955 sizeof (ACPI_MPST_POWER_NODE));
956
957 while (PowerStateCount)
958 {
959 AcpiOsPrintf ("\n");
960 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A,
961 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
962 if (ACPI_FAILURE (Status))
963 {
964 return;
965 }
966
967 Subtable0A++;
968 PowerStateCount--;
969 Offset += sizeof (ACPI_MPST_POWER_STATE);
970 }
971
972 /* Sub-subtables - Physical Component ID Structure(s) */
973
974 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A);
975
976 if (ComponentCount)
977 {
978 AcpiOsPrintf ("\n");
979 }
980
981 while (ComponentCount)
982 {
983 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B,
984 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
985 if (ACPI_FAILURE (Status))
986 {
987 return;
988 }
989
990 Subtable0B++;
991 ComponentCount--;
992 Offset += sizeof (ACPI_MPST_COMPONENT);
993 }
994
995 /* Point to next Memory Power Node subtable */
996
997 SubtableCount--;
998 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0,
999 sizeof (ACPI_MPST_POWER_NODE) +
1000 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) +
1001 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents));
1002 }
1003
1004 /* Subtable: Count of Memory Power State Characteristic structures */
1005
1006 AcpiOsPrintf ("\n");
1007 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0);
1008 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1,
1009 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1010 if (ACPI_FAILURE (Status))
1011 {
1012 return;
1013 }
1014
1015 SubtableCount = Subtable1->CharacteristicsCount;
1016 Offset += sizeof (ACPI_MPST_DATA_HDR);
1017
1018 /* Subtable: Memory Power State Characteristics structure(s) */
1019
1020 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1,
1021 sizeof (ACPI_MPST_DATA_HDR));
1022
1023 while ((Offset < Table->Length) && SubtableCount)
1024 {
1025 AcpiOsPrintf ("\n");
1026 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2,
1027 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1028 if (ACPI_FAILURE (Status))
1029 {
1030 return;
1031 }
1032
1033 Subtable2++;
1034 SubtableCount--;
1035 Offset += sizeof (ACPI_MPST_POWER_DATA);
1036 }
1037 }
1038
1039
1040 /*******************************************************************************
1041 *
1042 * FUNCTION: AcpiDmDumpMsct
1043 *
1044 * PARAMETERS: Table - A MSCT table
1045 *
1046 * RETURN: None
1047 *
1048 * DESCRIPTION: Format the contents of a MSCT
1049 *
1050 ******************************************************************************/
1051
1052 void
AcpiDmDumpMsct(ACPI_TABLE_HEADER * Table)1053 AcpiDmDumpMsct (
1054 ACPI_TABLE_HEADER *Table)
1055 {
1056 ACPI_STATUS Status;
1057 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1058 ACPI_MSCT_PROXIMITY *Subtable;
1059
1060
1061 /* Main table */
1062
1063 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1064 if (ACPI_FAILURE (Status))
1065 {
1066 return;
1067 }
1068
1069 /* Subtables */
1070
1071 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1072 while (Offset < Table->Length)
1073 {
1074 /* Common subtable header */
1075
1076 AcpiOsPrintf ("\n");
1077 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1078 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1079 if (ACPI_FAILURE (Status))
1080 {
1081 return;
1082 }
1083
1084 /* Point to next subtable */
1085
1086 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1087 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable,
1088 sizeof (ACPI_MSCT_PROXIMITY));
1089 }
1090 }
1091
1092
1093 /*******************************************************************************
1094 *
1095 * FUNCTION: AcpiDmDumpMtmr
1096 *
1097 * PARAMETERS: Table - A MTMR table
1098 *
1099 * RETURN: None
1100 *
1101 * DESCRIPTION: Format the contents of a MTMR
1102 *
1103 ******************************************************************************/
1104
1105 void
AcpiDmDumpMtmr(ACPI_TABLE_HEADER * Table)1106 AcpiDmDumpMtmr (
1107 ACPI_TABLE_HEADER *Table)
1108 {
1109 ACPI_STATUS Status;
1110 UINT32 Offset = sizeof (ACPI_TABLE_MTMR);
1111 ACPI_MTMR_ENTRY *Subtable;
1112
1113
1114 /* Main table */
1115
1116 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
1117 if (ACPI_FAILURE (Status))
1118 {
1119 return;
1120 }
1121
1122 /* Subtables */
1123
1124 Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
1125 while (Offset < Table->Length)
1126 {
1127 /* Common subtable header */
1128
1129 AcpiOsPrintf ("\n");
1130 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1131 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
1132 if (ACPI_FAILURE (Status))
1133 {
1134 return;
1135 }
1136
1137 /* Point to next subtable */
1138
1139 Offset += sizeof (ACPI_MTMR_ENTRY);
1140 Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Subtable,
1141 sizeof (ACPI_MTMR_ENTRY));
1142 }
1143 }
1144
1145
1146 /*******************************************************************************
1147 *
1148 * FUNCTION: AcpiDmDumpNfit
1149 *
1150 * PARAMETERS: Table - A NFIT table
1151 *
1152 * RETURN: None
1153 *
1154 * DESCRIPTION: Format the contents of an NFIT.
1155 *
1156 ******************************************************************************/
1157
1158 void
AcpiDmDumpNfit(ACPI_TABLE_HEADER * Table)1159 AcpiDmDumpNfit (
1160 ACPI_TABLE_HEADER *Table)
1161 {
1162 ACPI_STATUS Status;
1163 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
1164 UINT32 FieldOffset = 0;
1165 UINT32 Length;
1166 ACPI_NFIT_HEADER *Subtable;
1167 ACPI_DMTABLE_INFO *InfoTable;
1168 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
1169 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
1170 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
1171 UINT32 i;
1172
1173
1174 /* Main table */
1175
1176 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
1177 if (ACPI_FAILURE (Status))
1178 {
1179 return;
1180 }
1181
1182 /* Subtables */
1183
1184 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
1185 while (Offset < Table->Length)
1186 {
1187 /* NFIT subtable header */
1188
1189 AcpiOsPrintf ("\n");
1190 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1191 Subtable->Length, AcpiDmTableInfoNfitHdr);
1192 if (ACPI_FAILURE (Status))
1193 {
1194 return;
1195 }
1196
1197 switch (Subtable->Type)
1198 {
1199 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1200
1201 InfoTable = AcpiDmTableInfoNfit0;
1202 break;
1203
1204 case ACPI_NFIT_TYPE_MEMORY_MAP:
1205
1206 InfoTable = AcpiDmTableInfoNfit1;
1207 break;
1208
1209 case ACPI_NFIT_TYPE_INTERLEAVE:
1210
1211 /* Has a variable number of 32-bit values at the end */
1212
1213 InfoTable = AcpiDmTableInfoNfit2;
1214 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable);
1215 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
1216 break;
1217
1218 case ACPI_NFIT_TYPE_SMBIOS:
1219
1220 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable);
1221 InfoTable = AcpiDmTableInfoNfit3;
1222 break;
1223
1224 case ACPI_NFIT_TYPE_CONTROL_REGION:
1225
1226 InfoTable = AcpiDmTableInfoNfit4;
1227 break;
1228
1229 case ACPI_NFIT_TYPE_DATA_REGION:
1230
1231 InfoTable = AcpiDmTableInfoNfit5;
1232 break;
1233
1234 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1235
1236 /* Has a variable number of 64-bit addresses at the end */
1237
1238 InfoTable = AcpiDmTableInfoNfit6;
1239 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable);
1240 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64);
1241 break;
1242
1243 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */
1244
1245 InfoTable = AcpiDmTableInfoNfit7;
1246 break;
1247
1248 default:
1249 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
1250 Subtable->Type);
1251
1252 /* Attempt to continue */
1253
1254 if (!Subtable->Length)
1255 {
1256 AcpiOsPrintf ("Invalid zero length subtable\n");
1257 return;
1258 }
1259 goto NextSubtable;
1260 }
1261
1262 AcpiOsPrintf ("\n");
1263 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1264 Subtable->Length, InfoTable);
1265 if (ACPI_FAILURE (Status))
1266 {
1267 return;
1268 }
1269
1270 /* Per-subtable variable-length fields */
1271
1272 switch (Subtable->Type)
1273 {
1274 case ACPI_NFIT_TYPE_INTERLEAVE:
1275
1276 for (i = 0; i < Interleave->LineCount; i++)
1277 {
1278 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1279 &Interleave->LineOffset[i],
1280 sizeof (UINT32), AcpiDmTableInfoNfit2a);
1281 if (ACPI_FAILURE (Status))
1282 {
1283 return;
1284 }
1285
1286 FieldOffset += sizeof (UINT32);
1287 }
1288 break;
1289
1290 case ACPI_NFIT_TYPE_SMBIOS:
1291
1292 Length = Subtable->Length -
1293 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
1294
1295 if (Length)
1296 {
1297 Status = AcpiDmDumpTable (Table->Length,
1298 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
1299 SmbiosInfo,
1300 Length, AcpiDmTableInfoNfit3a);
1301 if (ACPI_FAILURE (Status))
1302 {
1303 return;
1304 }
1305 }
1306
1307 break;
1308
1309 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1310
1311 for (i = 0; i < Hint->HintCount; i++)
1312 {
1313 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1314 &Hint->HintAddress[i],
1315 sizeof (UINT64), AcpiDmTableInfoNfit6a);
1316 if (ACPI_FAILURE (Status))
1317 {
1318 return;
1319 }
1320
1321 FieldOffset += sizeof (UINT64);
1322 }
1323 break;
1324
1325 default:
1326 break;
1327 }
1328
1329 NextSubtable:
1330 /* Point to next subtable */
1331
1332 Offset += Subtable->Length;
1333 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length);
1334 }
1335 }
1336
1337
1338 /*******************************************************************************
1339 *
1340 * FUNCTION: AcpiDmDumpPcct
1341 *
1342 * PARAMETERS: Table - A PCCT table
1343 *
1344 * RETURN: None
1345 *
1346 * DESCRIPTION: Format the contents of a PCCT. This table type consists
1347 * of an open-ended number of subtables.
1348 *
1349 ******************************************************************************/
1350
1351 void
AcpiDmDumpPcct(ACPI_TABLE_HEADER * Table)1352 AcpiDmDumpPcct (
1353 ACPI_TABLE_HEADER *Table)
1354 {
1355 ACPI_STATUS Status;
1356 ACPI_PCCT_SUBSPACE *Subtable;
1357 ACPI_DMTABLE_INFO *InfoTable;
1358 UINT32 Length = Table->Length;
1359 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
1360
1361
1362 /* Main table */
1363
1364 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1365 if (ACPI_FAILURE (Status))
1366 {
1367 return;
1368 }
1369
1370 /* Subtables */
1371
1372 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1373 while (Offset < Table->Length)
1374 {
1375 /* Common subtable header */
1376
1377 AcpiOsPrintf ("\n");
1378 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1379 Subtable->Header.Length, AcpiDmTableInfoPcctHdr);
1380 if (ACPI_FAILURE (Status))
1381 {
1382 return;
1383 }
1384
1385 switch (Subtable->Header.Type)
1386 {
1387 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
1388
1389 InfoTable = AcpiDmTableInfoPcct0;
1390 break;
1391
1392 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
1393
1394 InfoTable = AcpiDmTableInfoPcct1;
1395 break;
1396
1397 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
1398
1399 InfoTable = AcpiDmTableInfoPcct2;
1400 break;
1401
1402 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
1403
1404 InfoTable = AcpiDmTableInfoPcct3;
1405 break;
1406
1407 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
1408
1409 InfoTable = AcpiDmTableInfoPcct4;
1410 break;
1411
1412 default:
1413
1414 AcpiOsPrintf (
1415 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
1416 Subtable->Header.Type);
1417 return;
1418 }
1419
1420 AcpiOsPrintf ("\n");
1421 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1422 Subtable->Header.Length, InfoTable);
1423 if (ACPI_FAILURE (Status))
1424 {
1425 return;
1426 }
1427
1428 /* Point to next subtable */
1429
1430 Offset += Subtable->Header.Length;
1431 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable,
1432 Subtable->Header.Length);
1433 }
1434 }
1435
1436
1437 /*******************************************************************************
1438 *
1439 * FUNCTION: AcpiDmDumpPdtt
1440 *
1441 * PARAMETERS: Table - A PDTT table
1442 *
1443 * RETURN: None
1444 *
1445 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length
1446 * table that contains an open-ended number of IDs
1447 * at the end of the table.
1448 *
1449 ******************************************************************************/
1450
1451 void
AcpiDmDumpPdtt(ACPI_TABLE_HEADER * Table)1452 AcpiDmDumpPdtt (
1453 ACPI_TABLE_HEADER *Table)
1454 {
1455 ACPI_STATUS Status;
1456 ACPI_PDTT_CHANNEL *Subtable;
1457 UINT32 Length = Table->Length;
1458 UINT32 Offset = sizeof (ACPI_TABLE_PDTT);
1459
1460
1461 /* Main table */
1462
1463 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt);
1464 if (ACPI_FAILURE (Status))
1465 {
1466 return;
1467 }
1468
1469 /* Subtables. Currently there is only one type, but can be multiples */
1470
1471 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset);
1472 while (Offset < Table->Length)
1473 {
1474 AcpiOsPrintf ("\n");
1475 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1476 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0);
1477 if (ACPI_FAILURE (Status))
1478 {
1479 return;
1480 }
1481
1482 /* Point to next subtable */
1483
1484 Offset += sizeof (ACPI_PDTT_CHANNEL);
1485 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable,
1486 sizeof (ACPI_PDTT_CHANNEL));
1487 }
1488 }
1489
1490
1491 /*******************************************************************************
1492 *
1493 * FUNCTION: AcpiDmDumpPmtt
1494 *
1495 * PARAMETERS: Table - A PMTT table
1496 *
1497 * RETURN: None
1498 *
1499 * DESCRIPTION: Format the contents of a PMTT. This table type consists
1500 * of an open-ended number of subtables.
1501 *
1502 ******************************************************************************/
1503
1504 void
AcpiDmDumpPmtt(ACPI_TABLE_HEADER * Table)1505 AcpiDmDumpPmtt (
1506 ACPI_TABLE_HEADER *Table)
1507 {
1508 ACPI_STATUS Status;
1509 ACPI_PMTT_HEADER *Subtable;
1510 ACPI_PMTT_HEADER *MemSubtable;
1511 ACPI_PMTT_HEADER *DimmSubtable;
1512 ACPI_PMTT_DOMAIN *DomainArray;
1513 UINT32 Length = Table->Length;
1514 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
1515 UINT32 MemOffset;
1516 UINT32 DimmOffset;
1517 UINT32 DomainOffset;
1518 UINT32 DomainCount;
1519
1520
1521 /* Main table */
1522
1523 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
1524 if (ACPI_FAILURE (Status))
1525 {
1526 return;
1527 }
1528
1529 /* Subtables */
1530
1531 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
1532 while (Offset < Table->Length)
1533 {
1534 /* Common subtable header */
1535
1536 AcpiOsPrintf ("\n");
1537 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1538 Subtable->Length, AcpiDmTableInfoPmttHdr);
1539 if (ACPI_FAILURE (Status))
1540 {
1541 return;
1542 }
1543
1544 /* Only Socket subtables are expected at this level */
1545
1546 if (Subtable->Type != ACPI_PMTT_TYPE_SOCKET)
1547 {
1548 AcpiOsPrintf (
1549 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1550 Subtable->Type);
1551 return;
1552 }
1553
1554 /* Dump the fixed-length portion of the subtable */
1555
1556 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1557 Subtable->Length, AcpiDmTableInfoPmtt0);
1558 if (ACPI_FAILURE (Status))
1559 {
1560 return;
1561 }
1562
1563 /* Walk the memory controller subtables */
1564
1565 MemOffset = sizeof (ACPI_PMTT_SOCKET);
1566 MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Subtable,
1567 sizeof (ACPI_PMTT_SOCKET));
1568
1569 while (((Offset + MemOffset) < Table->Length) &&
1570 (MemOffset < Subtable->Length))
1571 {
1572 /* Common subtable header */
1573
1574 AcpiOsPrintf ("\n");
1575 Status = AcpiDmDumpTable (Length,
1576 Offset + MemOffset, MemSubtable,
1577 MemSubtable->Length, AcpiDmTableInfoPmttHdr);
1578 if (ACPI_FAILURE (Status))
1579 {
1580 return;
1581 }
1582
1583 /* Only memory controller subtables are expected at this level */
1584
1585 if (MemSubtable->Type != ACPI_PMTT_TYPE_CONTROLLER)
1586 {
1587 AcpiOsPrintf (
1588 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1589 MemSubtable->Type);
1590 return;
1591 }
1592
1593 /* Dump the fixed-length portion of the controller subtable */
1594
1595 Status = AcpiDmDumpTable (Length,
1596 Offset + MemOffset, MemSubtable,
1597 MemSubtable->Length, AcpiDmTableInfoPmtt1);
1598 if (ACPI_FAILURE (Status))
1599 {
1600 return;
1601 }
1602
1603 /* Walk the variable count of proximity domains */
1604
1605 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubtable)->DomainCount;
1606 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
1607 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubtable,
1608 sizeof (ACPI_PMTT_CONTROLLER));
1609
1610 while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
1611 ((MemOffset + DomainOffset) < Subtable->Length) &&
1612 DomainCount)
1613 {
1614 Status = AcpiDmDumpTable (Length,
1615 Offset + MemOffset + DomainOffset, DomainArray,
1616 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
1617 if (ACPI_FAILURE (Status))
1618 {
1619 return;
1620 }
1621
1622 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
1623 DomainArray++;
1624 DomainCount--;
1625 }
1626
1627 if (DomainCount)
1628 {
1629 AcpiOsPrintf (
1630 "\n**** DomainCount exceeds subtable length\n\n");
1631 }
1632
1633 /* Walk the physical component (DIMM) subtables */
1634
1635 DimmOffset = DomainOffset;
1636 DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubtable,
1637 DomainOffset);
1638
1639 while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
1640 (DimmOffset < MemSubtable->Length))
1641 {
1642 /* Common subtable header */
1643
1644 AcpiOsPrintf ("\n");
1645 Status = AcpiDmDumpTable (Length,
1646 Offset + MemOffset + DimmOffset, DimmSubtable,
1647 DimmSubtable->Length, AcpiDmTableInfoPmttHdr);
1648 if (ACPI_FAILURE (Status))
1649 {
1650 return;
1651 }
1652
1653 /* Only DIMM subtables are expected at this level */
1654
1655 if (DimmSubtable->Type != ACPI_PMTT_TYPE_DIMM)
1656 {
1657 AcpiOsPrintf (
1658 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1659 DimmSubtable->Type);
1660 return;
1661 }
1662
1663 /* Dump the fixed-length DIMM subtable */
1664
1665 Status = AcpiDmDumpTable (Length,
1666 Offset + MemOffset + DimmOffset, DimmSubtable,
1667 DimmSubtable->Length, AcpiDmTableInfoPmtt2);
1668 if (ACPI_FAILURE (Status))
1669 {
1670 return;
1671 }
1672
1673 /* Point to next DIMM subtable */
1674
1675 DimmOffset += DimmSubtable->Length;
1676 DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1677 DimmSubtable, DimmSubtable->Length);
1678 }
1679
1680 /* Point to next Controller subtable */
1681
1682 MemOffset += MemSubtable->Length;
1683 MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1684 MemSubtable, MemSubtable->Length);
1685 }
1686
1687 /* Point to next Socket subtable */
1688
1689 Offset += Subtable->Length;
1690 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1691 Subtable, Subtable->Length);
1692 }
1693 }
1694
1695
1696 /*******************************************************************************
1697 *
1698 * FUNCTION: AcpiDmDumpPptt
1699 *
1700 * PARAMETERS: Table - A PMTT table
1701 *
1702 * RETURN: None
1703 *
1704 * DESCRIPTION: Format the contents of a PPTT. This table type consists
1705 * of an open-ended number of subtables.
1706 *
1707 ******************************************************************************/
1708
1709 void
AcpiDmDumpPptt(ACPI_TABLE_HEADER * Table)1710 AcpiDmDumpPptt (
1711 ACPI_TABLE_HEADER *Table)
1712 {
1713 ACPI_STATUS Status;
1714 ACPI_SUBTABLE_HEADER *Subtable;
1715 ACPI_PPTT_PROCESSOR *PpttProcessor;
1716 UINT8 Length;
1717 UINT8 SubtableOffset;
1718 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
1719 ACPI_DMTABLE_INFO *InfoTable;
1720 UINT32 i;
1721
1722
1723 /* There is no main table (other than the standard ACPI header) */
1724
1725 /* Subtables */
1726
1727 Offset = sizeof (ACPI_TABLE_HEADER);
1728 while (Offset < Table->Length)
1729 {
1730 AcpiOsPrintf ("\n");
1731
1732 /* Common subtable header */
1733
1734 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1735 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER))
1736 {
1737 AcpiOsPrintf ("Invalid subtable length\n");
1738 return;
1739 }
1740 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1741 Subtable->Length, AcpiDmTableInfoPpttHdr);
1742 if (ACPI_FAILURE (Status))
1743 {
1744 return;
1745 }
1746
1747 switch (Subtable->Type)
1748 {
1749 case ACPI_PPTT_TYPE_PROCESSOR:
1750
1751 InfoTable = AcpiDmTableInfoPptt0;
1752 Length = sizeof (ACPI_PPTT_PROCESSOR);
1753 break;
1754
1755 case ACPI_PPTT_TYPE_CACHE:
1756
1757 InfoTable = AcpiDmTableInfoPptt1;
1758 Length = sizeof (ACPI_PPTT_CACHE);
1759 break;
1760
1761 case ACPI_PPTT_TYPE_ID:
1762
1763 InfoTable = AcpiDmTableInfoPptt2;
1764 Length = sizeof (ACPI_PPTT_ID);
1765 break;
1766
1767 default:
1768
1769 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
1770 Subtable->Type);
1771
1772 /* Attempt to continue */
1773
1774 goto NextSubtable;
1775 }
1776
1777 if (Subtable->Length < Length)
1778 {
1779 AcpiOsPrintf ("Invalid subtable length\n");
1780 return;
1781 }
1782 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1783 Subtable->Length, InfoTable);
1784 if (ACPI_FAILURE (Status))
1785 {
1786 return;
1787 }
1788 SubtableOffset = Length;
1789
1790 switch (Subtable->Type)
1791 {
1792 case ACPI_PPTT_TYPE_PROCESSOR:
1793
1794 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable);
1795
1796 /* Dump SMBIOS handles */
1797
1798 if ((UINT8)(Subtable->Length - SubtableOffset) <
1799 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
1800 {
1801 AcpiOsPrintf ("Invalid private resource number\n");
1802 return;
1803 }
1804 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
1805 {
1806 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1807 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
1808 4, AcpiDmTableInfoPptt0a);
1809 SubtableOffset += 4;
1810 }
1811 break;
1812
1813 default:
1814
1815 break;
1816 }
1817
1818 NextSubtable:
1819 /* Point to next subtable */
1820
1821 Offset += Subtable->Length;
1822 }
1823 }
1824
1825
1826 /*******************************************************************************
1827 *
1828 * FUNCTION: AcpiDmDumpS3pt
1829 *
1830 * PARAMETERS: Table - A S3PT table
1831 *
1832 * RETURN: Length of the table
1833 *
1834 * DESCRIPTION: Format the contents of a S3PT
1835 *
1836 ******************************************************************************/
1837
1838 UINT32
AcpiDmDumpS3pt(ACPI_TABLE_HEADER * Tables)1839 AcpiDmDumpS3pt (
1840 ACPI_TABLE_HEADER *Tables)
1841 {
1842 ACPI_STATUS Status;
1843 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
1844 ACPI_FPDT_HEADER *Subtable;
1845 ACPI_DMTABLE_INFO *InfoTable;
1846 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
1847
1848
1849 /* Main table */
1850
1851 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
1852 if (ACPI_FAILURE (Status))
1853 {
1854 return 0;
1855 }
1856
1857 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
1858 while (Offset < S3ptTable->Length)
1859 {
1860 /* Common subtable header */
1861
1862 AcpiOsPrintf ("\n");
1863 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
1864 Subtable->Length, AcpiDmTableInfoS3ptHdr);
1865 if (ACPI_FAILURE (Status))
1866 {
1867 return 0;
1868 }
1869
1870 switch (Subtable->Type)
1871 {
1872 case ACPI_S3PT_TYPE_RESUME:
1873
1874 InfoTable = AcpiDmTableInfoS3pt0;
1875 break;
1876
1877 case ACPI_S3PT_TYPE_SUSPEND:
1878
1879 InfoTable = AcpiDmTableInfoS3pt1;
1880 break;
1881
1882 default:
1883
1884 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
1885 Subtable->Type);
1886
1887 /* Attempt to continue */
1888
1889 if (!Subtable->Length)
1890 {
1891 AcpiOsPrintf ("Invalid zero length subtable\n");
1892 return 0;
1893 }
1894 goto NextSubtable;
1895 }
1896
1897 AcpiOsPrintf ("\n");
1898 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
1899 Subtable->Length, InfoTable);
1900 if (ACPI_FAILURE (Status))
1901 {
1902 return 0;
1903 }
1904
1905 NextSubtable:
1906 /* Point to next subtable */
1907
1908 Offset += Subtable->Length;
1909 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length);
1910 }
1911
1912 return (S3ptTable->Length);
1913 }
1914
1915
1916 /*******************************************************************************
1917 *
1918 * FUNCTION: AcpiDmDumpSdev
1919 *
1920 * PARAMETERS: Table - A SDEV table
1921 *
1922 * RETURN: None
1923 *
1924 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length
1925 * table that contains variable strings and vendor data.
1926 *
1927 ******************************************************************************/
1928
1929 void
AcpiDmDumpSdev(ACPI_TABLE_HEADER * Table)1930 AcpiDmDumpSdev (
1931 ACPI_TABLE_HEADER *Table)
1932 {
1933 ACPI_STATUS Status;
1934 ACPI_SDEV_HEADER *Subtable;
1935 ACPI_SDEV_PCIE *Pcie;
1936 ACPI_SDEV_NAMESPACE *Namesp;
1937 ACPI_DMTABLE_INFO *InfoTable;
1938 UINT32 Length = Table->Length;
1939 UINT32 Offset = sizeof (ACPI_TABLE_SDEV);
1940 UINT16 PathOffset;
1941 UINT16 PathLength;
1942 UINT16 VendorDataOffset;
1943 UINT16 VendorDataLength;
1944
1945
1946 /* Main table */
1947
1948 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev);
1949 if (ACPI_FAILURE (Status))
1950 {
1951 return;
1952 }
1953
1954 /* Subtables */
1955
1956 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset);
1957 while (Offset < Table->Length)
1958 {
1959 /* Common subtable header */
1960
1961 AcpiOsPrintf ("\n");
1962 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1963 Subtable->Length, AcpiDmTableInfoSdevHdr);
1964 if (ACPI_FAILURE (Status))
1965 {
1966 return;
1967 }
1968
1969 switch (Subtable->Type)
1970 {
1971 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1972
1973 InfoTable = AcpiDmTableInfoSdev0;
1974 break;
1975
1976 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
1977
1978 InfoTable = AcpiDmTableInfoSdev1;
1979 break;
1980
1981 default:
1982 goto NextSubtable;
1983 }
1984
1985 AcpiOsPrintf ("\n");
1986 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1987 Subtable->Length, InfoTable);
1988 if (ACPI_FAILURE (Status))
1989 {
1990 return;
1991 }
1992
1993 switch (Subtable->Type)
1994 {
1995 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1996
1997 /* Dump the PCIe device ID(s) */
1998
1999 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable);
2000 PathOffset = Namesp->DeviceIdOffset;
2001 PathLength = Namesp->DeviceIdLength;
2002
2003 if (PathLength)
2004 {
2005 Status = AcpiDmDumpTable (Table->Length, 0,
2006 ACPI_ADD_PTR (UINT8, Namesp, PathOffset),
2007 PathLength, AcpiDmTableInfoSdev0a);
2008 if (ACPI_FAILURE (Status))
2009 {
2010 return;
2011 }
2012 }
2013
2014 /* Dump the vendor-specific data */
2015
2016 VendorDataLength =
2017 Namesp->VendorDataLength;
2018 VendorDataOffset =
2019 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
2020
2021 if (VendorDataLength)
2022 {
2023 Status = AcpiDmDumpTable (Table->Length, 0,
2024 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset),
2025 VendorDataLength, AcpiDmTableInfoSdev1b);
2026 if (ACPI_FAILURE (Status))
2027 {
2028 return;
2029 }
2030 }
2031 break;
2032
2033 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
2034
2035 /* PCI path substructures */
2036
2037 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable);
2038 PathOffset = Pcie->PathOffset;
2039 PathLength = Pcie->PathLength;
2040
2041 while (PathLength)
2042 {
2043 Status = AcpiDmDumpTable (Table->Length,
2044 PathOffset + Offset,
2045 ACPI_ADD_PTR (UINT8, Pcie, PathOffset),
2046 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a);
2047 if (ACPI_FAILURE (Status))
2048 {
2049 return;
2050 }
2051
2052 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH);
2053 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH);
2054 }
2055
2056 /* VendorData */
2057
2058 VendorDataLength = Pcie->VendorDataLength;
2059 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength;
2060
2061 if (VendorDataLength)
2062 {
2063 Status = AcpiDmDumpTable (Table->Length, 0,
2064 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset),
2065 VendorDataLength, AcpiDmTableInfoSdev1b);
2066 }
2067 break;
2068
2069 default:
2070 goto NextSubtable;
2071 }
2072
2073 NextSubtable:
2074 /* Point to next subtable */
2075
2076 Offset += Subtable->Length;
2077 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable,
2078 Subtable->Length);
2079 }
2080 }
2081