1 /******************************************************************************
2 *
3 * Module Name: dmtbdump1 - 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 - 2022, 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 <contrib/dev/acpica/include/acpi.h>
153 #include <contrib/dev/acpica/include/accommon.h>
154 #include <contrib/dev/acpica/include/acdisasm.h>
155 #include <contrib/dev/acpica/include/actables.h>
156 #include <contrib/dev/acpica/compiler/aslcompiler.h>
157
158 /* This module used for application-level code only */
159
160 #define _COMPONENT ACPI_CA_DISASSEMBLER
161 ACPI_MODULE_NAME ("dmtbdump1")
162
163
164 /*******************************************************************************
165 *
166 * FUNCTION: AcpiDmDumpAest
167 *
168 * PARAMETERS: Table - A AEST table
169 *
170 * RETURN: None
171 *
172 * DESCRIPTION: Format the contents of a AEST table
173 *
174 * NOTE: Assumes the following table structure:
175 * For all AEST Error Nodes:
176 * 1) An AEST Error Node, followed immediately by:
177 * 2) Any node-specific data
178 * 3) An Interface Structure (one)
179 * 4) A list (array) of Interrupt Structures
180 *
181 * AEST - ARM Error Source table. Conforms to:
182 * ACPI for the Armv8 RAS Extensions 1.1 Platform Design Document Sep 2020
183 *
184 ******************************************************************************/
185
186 void
187 AcpiDmDumpAest (
188 ACPI_TABLE_HEADER *Table)
189 {
190 ACPI_STATUS Status;
191 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
192 ACPI_AEST_HEADER *Subtable;
193 ACPI_AEST_HEADER *NodeHeader;
194 ACPI_AEST_PROCESSOR *ProcessorSubtable;
195 ACPI_DMTABLE_INFO *InfoTable;
196 ACPI_SIZE Length;
197 UINT8 Type;
198
199
200 /* Very small, generic main table. AEST consists of mostly subtables */
201
202 while (Offset < Table->Length)
203 {
204 NodeHeader = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
205
206 /* Dump the common error node (subtable) header */
207
208 Status = AcpiDmDumpTable (Table->Length, Offset, NodeHeader,
209 NodeHeader->Length, AcpiDmTableInfoAestHdr);
210 if (ACPI_FAILURE (Status))
211 {
212 return;
213 }
214
215 Type = NodeHeader->Type;
216
217 /* Setup the node-specific subtable based on the header Type field */
218
219 switch (Type)
220 {
221 case ACPI_AEST_PROCESSOR_ERROR_NODE:
222 InfoTable = AcpiDmTableInfoAestProcError;
223 Length = sizeof (ACPI_AEST_PROCESSOR);
224 break;
225
226 case ACPI_AEST_MEMORY_ERROR_NODE:
227 InfoTable = AcpiDmTableInfoAestMemError;
228 Length = sizeof (ACPI_AEST_MEMORY);
229 break;
230
231 case ACPI_AEST_SMMU_ERROR_NODE:
232 InfoTable = AcpiDmTableInfoAestSmmuError;
233 Length = sizeof (ACPI_AEST_SMMU);
234 break;
235
236 case ACPI_AEST_VENDOR_ERROR_NODE:
237 InfoTable = AcpiDmTableInfoAestVendorError;
238 Length = sizeof (ACPI_AEST_VENDOR);
239 break;
240
241 case ACPI_AEST_GIC_ERROR_NODE:
242 InfoTable = AcpiDmTableInfoAestGicError;
243 Length = sizeof (ACPI_AEST_GIC);
244 break;
245
246 /* Error case below */
247 default:
248
249 AcpiOsPrintf ("\n**** Unknown AEST Error Subtable type 0x%X\n",
250 Type);
251 return;
252 }
253
254 /* Point past the common header (to the node-specific data) */
255
256 Offset += sizeof (ACPI_AEST_HEADER);
257 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
258 AcpiOsPrintf ("\n");
259
260 /* Dump the node-specific subtable */
261
262 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length,
263 InfoTable);
264 if (ACPI_FAILURE (Status))
265 {
266 return;
267 }
268 AcpiOsPrintf ("\n");
269
270 if (Type == ACPI_AEST_PROCESSOR_ERROR_NODE)
271 {
272 /*
273 * Special handling for PROCESSOR_ERROR_NODE subtables
274 * (to handle the Resource Substructure via the ResourceType
275 * field).
276 */
277
278 /* Point past the node-specific data */
279
280 Offset += Length;
281 ProcessorSubtable = ACPI_CAST_PTR (ACPI_AEST_PROCESSOR, Subtable);
282
283 switch (ProcessorSubtable->ResourceType)
284 {
285 /* Setup the Resource Substructure subtable */
286
287 case ACPI_AEST_CACHE_RESOURCE:
288 InfoTable = AcpiDmTableInfoAestCacheRsrc;
289 Length = sizeof (ACPI_AEST_PROCESSOR_CACHE);
290 break;
291
292 case ACPI_AEST_TLB_RESOURCE:
293 InfoTable = AcpiDmTableInfoAestTlbRsrc;
294 Length = sizeof (ACPI_AEST_PROCESSOR_TLB);
295 break;
296
297 case ACPI_AEST_GENERIC_RESOURCE:
298 InfoTable = AcpiDmTableInfoAestGenRsrc;
299 Length = sizeof (ACPI_AEST_PROCESSOR_GENERIC);
300 break;
301
302 /* Error case below */
303 default:
304 AcpiOsPrintf ("\n**** Unknown AEST Processor Resource type 0x%X\n",
305 ProcessorSubtable->ResourceType);
306 return;
307 }
308
309 ProcessorSubtable = ACPI_ADD_PTR (ACPI_AEST_PROCESSOR, Table,
310 Offset);
311
312 /* Dump the resource substructure subtable */
313
314 Status = AcpiDmDumpTable (Table->Length, Offset, ProcessorSubtable,
315 Length, InfoTable);
316 if (ACPI_FAILURE (Status))
317 {
318 return;
319 }
320
321 AcpiOsPrintf ("\n");
322 }
323
324 /* Point past the resource substructure or the node-specific data */
325
326 Offset += Length;
327
328 /* Dump the interface structure, required to be present */
329
330 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
331 if (Subtable->Type >= ACPI_AEST_XFACE_RESERVED)
332 {
333 AcpiOsPrintf ("\n**** Unknown AEST Node Interface type 0x%X\n",
334 Subtable->Type);
335 return;
336 }
337
338 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
339 sizeof (ACPI_AEST_NODE_INTERFACE), AcpiDmTableInfoAestXface);
340 if (ACPI_FAILURE (Status))
341 {
342 return;
343 }
344
345 /* Point past the interface structure */
346
347 AcpiOsPrintf ("\n");
348 Offset += sizeof (ACPI_AEST_NODE_INTERFACE);
349
350 /* Dump the entire interrupt structure array, if present */
351
352 if (NodeHeader->NodeInterruptOffset)
353 {
354 Length = NodeHeader->NodeInterruptCount;
355 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
356
357 while (Length)
358 {
359 /* Dump the interrupt structure */
360
361 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
362 sizeof (ACPI_AEST_NODE_INTERRUPT),
363 AcpiDmTableInfoAestXrupt);
364 if (ACPI_FAILURE (Status))
365 {
366 return;
367 }
368
369 /* Point to the next interrupt structure */
370
371 Offset += sizeof (ACPI_AEST_NODE_INTERRUPT);
372 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset);
373 Length--;
374 AcpiOsPrintf ("\n");
375 }
376 }
377 }
378 }
379
380 /*******************************************************************************
381 *
382 * FUNCTION: AcpiDmDumpApmt
383 *
384 * PARAMETERS: Table - A APMT table
385 *
386 * RETURN: None
387 *
388 * DESCRIPTION: Format the contents of a APMT. This table type consists
389 * of an open-ended number of subtables.
390 *
391 *
392 * APMT - ARM Performance Monitoring Unit table. Conforms to:
393 * ARM Performance Monitoring Unit Architecture 1.0 Platform Design Document
394 * ARM DEN0117 v1.0 November 25, 2021
395 *
396 ******************************************************************************/
397
398 void
399 AcpiDmDumpApmt (
400 ACPI_TABLE_HEADER *Table)
401 {
402 ACPI_STATUS Status;
403 ACPI_APMT_NODE *Subtable;
404 UINT32 Length = Table->Length;
405 UINT32 Offset = sizeof (ACPI_TABLE_APMT);
406 UINT32 NodeNum = 0;
407
408 /* There is no main table (other than the standard ACPI header) */
409
410 /* Subtables */
411
412 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Table, Offset);
413 while (Offset < Table->Length)
414 {
415 AcpiOsPrintf ("\n");
416
417 if (Subtable->Type >= ACPI_APMT_NODE_TYPE_COUNT)
418 {
419 AcpiOsPrintf ("\n**** Unknown APMT subtable type 0x%X\n",
420 Subtable->Type);
421 return;
422 }
423
424 AcpiOsPrintf ("/* APMT Node-%u */\n", NodeNum++);
425
426 Status = AcpiDmDumpTable (Length, Offset, Subtable,
427 Subtable->Length, AcpiDmTableInfoApmtNode);
428 if (ACPI_FAILURE (Status))
429 {
430 return;
431 }
432
433 /* Point to next subtable */
434
435 Offset += Subtable->Length;
436 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Subtable,
437 Subtable->Length);
438 AcpiOsPrintf ("\n");
439 }
440 }
441
442
443 /*******************************************************************************
444 *
445 * FUNCTION: AcpiDmDumpAsf
446 *
447 * PARAMETERS: Table - A ASF table
448 *
449 * RETURN: None
450 *
451 * DESCRIPTION: Format the contents of a ASF table
452 *
453 ******************************************************************************/
454
455 void
456 AcpiDmDumpAsf (
457 ACPI_TABLE_HEADER *Table)
458 {
459 ACPI_STATUS Status;
460 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
461 ACPI_ASF_INFO *Subtable;
462 ACPI_DMTABLE_INFO *InfoTable;
463 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
464 UINT8 *DataTable = NULL;
465 UINT32 DataCount = 0;
466 UINT32 DataLength = 0;
467 UINT32 DataOffset = 0;
468 UINT32 i;
469 UINT8 Type;
470
471
472 /* No main table, only subtables */
473
474 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
475 while (Offset < Table->Length)
476 {
477 /* Common subtable header */
478
479 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
480 Subtable->Header.Length, AcpiDmTableInfoAsfHdr);
481 if (ACPI_FAILURE (Status))
482 {
483 return;
484 }
485
486 /* The actual type is the lower 7 bits of Type */
487
488 Type = (UINT8) (Subtable->Header.Type & 0x7F);
489
490 switch (Type)
491 {
492 case ACPI_ASF_TYPE_INFO:
493
494 InfoTable = AcpiDmTableInfoAsf0;
495 break;
496
497 case ACPI_ASF_TYPE_ALERT:
498
499 InfoTable = AcpiDmTableInfoAsf1;
500 DataInfoTable = AcpiDmTableInfoAsf1a;
501 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT));
502 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts;
503 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength;
504 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
505 break;
506
507 case ACPI_ASF_TYPE_CONTROL:
508
509 InfoTable = AcpiDmTableInfoAsf2;
510 DataInfoTable = AcpiDmTableInfoAsf2a;
511 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE));
512 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls;
513 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength;
514 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
515 break;
516
517 case ACPI_ASF_TYPE_BOOT:
518
519 InfoTable = AcpiDmTableInfoAsf3;
520 break;
521
522 case ACPI_ASF_TYPE_ADDRESS:
523
524 InfoTable = AcpiDmTableInfoAsf4;
525 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS));
526 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices;
527 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
528 break;
529
530 default:
531
532 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
533 Subtable->Header.Type);
534 return;
535 }
536
537 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
538 Subtable->Header.Length, InfoTable);
539 if (ACPI_FAILURE (Status))
540 {
541 return;
542 }
543
544 /* Dump variable-length extra data */
545
546 switch (Type)
547 {
548 case ACPI_ASF_TYPE_ALERT:
549 case ACPI_ASF_TYPE_CONTROL:
550
551 for (i = 0; i < DataCount; i++)
552 {
553 AcpiOsPrintf ("\n");
554 Status = AcpiDmDumpTable (Table->Length, DataOffset,
555 DataTable, DataLength, DataInfoTable);
556 if (ACPI_FAILURE (Status))
557 {
558 return;
559 }
560
561 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
562 DataOffset += DataLength;
563 }
564 break;
565
566 case ACPI_ASF_TYPE_ADDRESS:
567
568 for (i = 0; i < DataLength; i++)
569 {
570 if (!(i % 16))
571 {
572 AcpiDmLineHeader (DataOffset, 1, "Addresses");
573 }
574
575 AcpiOsPrintf ("%2.2X ", *DataTable);
576 DataTable++;
577 DataOffset++;
578
579 if (DataOffset > Table->Length)
580 {
581 AcpiOsPrintf (
582 "**** ACPI table terminates in the middle of a "
583 "data structure! (ASF! table)\n");
584 return;
585 }
586 }
587
588 AcpiOsPrintf ("\n");
589 break;
590
591 default:
592
593 break;
594 }
595
596 AcpiOsPrintf ("\n");
597
598 /* Point to next subtable */
599
600 if (!Subtable->Header.Length)
601 {
602 AcpiOsPrintf ("Invalid zero subtable header length\n");
603 return;
604 }
605
606 Offset += Subtable->Header.Length;
607 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable,
608 Subtable->Header.Length);
609 }
610 }
611
612
613 /*******************************************************************************
614 *
615 * FUNCTION: AcpiDmDumpCdat
616 *
617 * PARAMETERS: InTable - A CDAT table
618 *
619 * RETURN: None
620 *
621 * DESCRIPTION: Format the contents of a CDAT. This table type consists
622 * of an open-ended number of subtables.
623 *
624 ******************************************************************************/
625
626 void
627 AcpiDmDumpCdat (
628 ACPI_TABLE_HEADER *InTable)
629 {
630 ACPI_TABLE_CDAT *Table = ACPI_CAST_PTR (ACPI_TABLE_CDAT, InTable);
631 ACPI_STATUS Status;
632 ACPI_CDAT_HEADER *Subtable;
633 ACPI_TABLE_CDAT *CdatTable = ACPI_CAST_PTR (ACPI_TABLE_CDAT, Table);
634 ACPI_DMTABLE_INFO *InfoTable;
635 UINT32 Length = CdatTable->Length;
636 UINT32 Offset = sizeof (ACPI_TABLE_CDAT);
637 UINT32 SubtableLength;
638 UINT32 SubtableType;
639 INT32 EntriesLength;
640
641
642 /* Main table */
643
644 Status = AcpiDmDumpTable (Offset, 0, CdatTable, 0,
645 AcpiDmTableInfoCdatTableHdr);
646 if (ACPI_FAILURE (Status))
647 {
648 return;
649 }
650
651 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, sizeof (ACPI_TABLE_CDAT));
652 while (Offset < Table->Length)
653 {
654 /* Dump the common subtable header */
655
656 DbgPrint (ASL_DEBUG_OUTPUT, "0) HeaderOffset: %X\n", Offset);
657 AcpiOsPrintf ("\n");
658 Status = AcpiDmDumpTable (Length, Offset, Subtable,
659 sizeof (ACPI_CDAT_HEADER), AcpiDmTableInfoCdatHeader);
660 if (ACPI_FAILURE (Status))
661 {
662 return;
663 }
664
665 /* Point past the common subtable header, decode the subtable type */
666
667 Offset += sizeof (ACPI_CDAT_HEADER);
668 SubtableType = Subtable->Type;
669
670 switch (Subtable->Type)
671 {
672 case ACPI_CDAT_TYPE_DSMAS:
673 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
674 SubtableLength = sizeof (ACPI_CDAT_DSMAS);
675
676 InfoTable = AcpiDmTableInfoCdat0;
677 break;
678
679 case ACPI_CDAT_TYPE_DSLBIS:
680 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
681 SubtableLength = sizeof (ACPI_CDAT_DSLBIS);
682 DbgPrint (ASL_DEBUG_OUTPUT, "1) Offset: %X\n", Offset);
683
684 InfoTable = AcpiDmTableInfoCdat1;
685 break;
686
687 case ACPI_CDAT_TYPE_DSMSCIS:
688 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
689 SubtableLength = sizeof (ACPI_CDAT_DSMSCIS);
690
691 InfoTable = AcpiDmTableInfoCdat2;
692 break;
693
694 case ACPI_CDAT_TYPE_DSIS:
695 DbgPrint (ASL_DEBUG_OUTPUT, "2) Offset: %X ", Offset);
696 SubtableLength = sizeof (ACPI_CDAT_DSIS);
697 DbgPrint (ASL_DEBUG_OUTPUT, "1) input pointer: %p\n", Table);
698 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
699 DbgPrint (ASL_DEBUG_OUTPUT, "1) output pointers: %p, %p, Offset: %X\n",
700 Table, Subtable, Offset);
701 DbgPrint (ASL_DEBUG_OUTPUT, "3) Offset: %X\n", Offset);
702
703 InfoTable = AcpiDmTableInfoCdat3;
704 break;
705
706 case ACPI_CDAT_TYPE_DSEMTS:
707 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
708 SubtableLength = sizeof (ACPI_CDAT_DSEMTS);
709
710 InfoTable = AcpiDmTableInfoCdat4;
711 break;
712
713 case ACPI_CDAT_TYPE_SSLBIS:
714 SubtableLength = Subtable->Length;
715
716 InfoTable = AcpiDmTableInfoCdat5;
717 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
718 break;
719
720 default:
721 fprintf (stderr, "ERROR: Unknown SubtableType: %X\n", Subtable->Type);
722 return;
723 }
724
725 DbgPrint (ASL_DEBUG_OUTPUT, "SubtableType: %X, Length: %X Actual "
726 "Length: %X Offset: %X tableptr: %p\n", SubtableType,
727 Subtable->Length, SubtableLength, Offset, Table);
728
729 /*
730 * Do the subtable-specific fields
731 */
732 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset, InfoTable);
733 if (ACPI_FAILURE (Status))
734 {
735 return;
736 }
737
738 DbgPrint (ASL_DEBUG_OUTPUT, "Subtable Type: %X, Offset: %X, SubtableLength: %X\n",
739 SubtableType, Offset, SubtableLength);
740
741 /* Additional sub-subtables, dependent on the main subtable type */
742
743 switch (SubtableType)
744 {
745 case ACPI_CDAT_TYPE_SSLBIS:
746 Offset += sizeof (ACPI_CDAT_SSLBIS);
747 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table,
748 Offset);
749
750 DbgPrint (ASL_DEBUG_OUTPUT, "Case SSLBIS, Offset: %X, SubtableLength: %X "
751 "Subtable->Length %X\n", Offset, SubtableLength, Subtable->Length);
752
753 /* Generate the total length of all the SSLBE entries */
754
755 EntriesLength = SubtableLength - sizeof (ACPI_CDAT_HEADER) -
756 sizeof (ACPI_CDAT_SSLBIS);
757 DbgPrint (ASL_DEBUG_OUTPUT, "EntriesLength: %X, Offset: %X, Table->Length: %X\n",
758 EntriesLength, Offset, Table->Length);
759
760 /* Do each of the SSLBE Entries */
761
762 while ((EntriesLength > 0) && (Offset < Table->Length))
763 {
764 AcpiOsPrintf ("\n");
765
766 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset,
767 AcpiDmTableInfoCdatEntries);
768 if (ACPI_FAILURE (Status))
769 {
770 return;
771 }
772
773 EntriesLength -= sizeof (ACPI_CDAT_SSLBE);
774 Offset += sizeof (ACPI_CDAT_SSLBE);
775 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
776 }
777
778 SubtableLength = 0;
779 break;
780
781 default:
782 break;
783 }
784
785 DbgPrint (ASL_DEBUG_OUTPUT, "Offset: %X, Subtable Length: %X\n",
786 Offset, SubtableLength);
787
788 /* Point to next subtable */
789
790 Offset += SubtableLength;
791 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset);
792 }
793
794 return;
795 }
796
797
798 /*******************************************************************************
799 *
800 * FUNCTION: AcpiDmDumpCedt
801 *
802 * PARAMETERS: Table - A CEDT table
803 *
804 * RETURN: None
805 *
806 * DESCRIPTION: Format the contents of a CEDT. This table type consists
807 * of an open-ended number of subtables.
808 *
809 ******************************************************************************/
810
811 void
812 AcpiDmDumpCedt (
813 ACPI_TABLE_HEADER *Table)
814 {
815 ACPI_STATUS Status;
816 ACPI_CEDT_HEADER *Subtable;
817 UINT32 Length = Table->Length;
818 UINT32 Offset = sizeof (ACPI_TABLE_CEDT);
819
820
821 /* There is no main table (other than the standard ACPI header) */
822
823 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset);
824 while (Offset < Table->Length)
825 {
826 /* Common subtable header */
827
828 AcpiOsPrintf ("\n");
829 Status = AcpiDmDumpTable (Length, Offset, Subtable,
830 Subtable->Length, AcpiDmTableInfoCedtHdr);
831 if (ACPI_FAILURE (Status))
832 {
833 return;
834 }
835
836 switch (Subtable->Type)
837 {
838 case ACPI_CEDT_TYPE_CHBS:
839 Status = AcpiDmDumpTable (Length, Offset, Subtable,
840 Subtable->Length, AcpiDmTableInfoCedt0);
841 if (ACPI_FAILURE (Status))
842 {
843 return;
844 }
845 break;
846
847 case ACPI_CEDT_TYPE_CFMWS:
848 {
849 ACPI_CEDT_CFMWS *ptr = (ACPI_CEDT_CFMWS *) Subtable;
850 unsigned int i, max = 0x01 << (ptr->InterleaveWays);
851
852 /* print out table with first "Interleave target" */
853
854 Status = AcpiDmDumpTable (Length, Offset, Subtable,
855 Subtable->Length, AcpiDmTableInfoCedt1);
856 if (ACPI_FAILURE (Status))
857 {
858 return;
859 }
860
861 /* Now, print out any interleave targets beyond the first. */
862
863 for (i = 1; i < max; i++)
864 {
865 unsigned int loc_offset = Offset + (i * 4) + ACPI_OFFSET (ACPI_CEDT_CFMWS, InterleaveTargets);
866 unsigned int *trg = &(ptr->InterleaveTargets[i]);
867
868 Status = AcpiDmDumpTable (Length, loc_offset, trg,
869 Subtable->Length, AcpiDmTableInfoCedt1_te);
870 if (ACPI_FAILURE (Status))
871 {
872 return;
873 }
874 }
875 break;
876 }
877
878 default:
879 AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n",
880 Subtable->Type);
881
882 /* Attempt to continue */
883 if (!Subtable->Length)
884 {
885 AcpiOsPrintf ("Invalid zero length subtable\n");
886 return;
887 }
888 }
889
890 /* Point to next subtable */
891 Offset += Subtable->Length;
892 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable,
893 Subtable->Length);
894 }
895 }
896
897 /*******************************************************************************
898 *
899 * FUNCTION: AcpiDmDumpCpep
900 *
901 * PARAMETERS: Table - A CPEP table
902 *
903 * RETURN: None
904 *
905 * DESCRIPTION: Format the contents of a CPEP. This table type consists
906 * of an open-ended number of subtables.
907 *
908 ******************************************************************************/
909
910 void
911 AcpiDmDumpCpep (
912 ACPI_TABLE_HEADER *Table)
913 {
914 ACPI_STATUS Status;
915 ACPI_CPEP_POLLING *Subtable;
916 UINT32 Length = Table->Length;
917 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
918
919
920 /* Main table */
921
922 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
923 if (ACPI_FAILURE (Status))
924 {
925 return;
926 }
927
928 /* Subtables */
929
930 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
931 while (Offset < Table->Length)
932 {
933 AcpiOsPrintf ("\n");
934 Status = AcpiDmDumpTable (Length, Offset, Subtable,
935 Subtable->Header.Length, AcpiDmTableInfoCpep0);
936 if (ACPI_FAILURE (Status))
937 {
938 return;
939 }
940
941 /* Point to next subtable */
942
943 Offset += Subtable->Header.Length;
944 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable,
945 Subtable->Header.Length);
946 }
947 }
948
949
950 /*******************************************************************************
951 *
952 * FUNCTION: AcpiDmDumpCsrt
953 *
954 * PARAMETERS: Table - A CSRT table
955 *
956 * RETURN: None
957 *
958 * DESCRIPTION: Format the contents of a CSRT. This table type consists
959 * of an open-ended number of subtables.
960 *
961 ******************************************************************************/
962
963 void
964 AcpiDmDumpCsrt (
965 ACPI_TABLE_HEADER *Table)
966 {
967 ACPI_STATUS Status;
968 ACPI_CSRT_GROUP *Subtable;
969 ACPI_CSRT_SHARED_INFO *SharedInfoTable;
970 ACPI_CSRT_DESCRIPTOR *SubSubtable;
971 UINT32 Length = Table->Length;
972 UINT32 Offset = sizeof (ACPI_TABLE_CSRT);
973 UINT32 SubOffset;
974 UINT32 SubSubOffset;
975 UINT32 InfoLength;
976
977
978 /* The main table only contains the ACPI header, thus already handled */
979
980 /* Subtables (Resource Groups) */
981
982 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
983 while (Offset < Table->Length)
984 {
985 /* Resource group subtable */
986
987 AcpiOsPrintf ("\n");
988 Status = AcpiDmDumpTable (Length, Offset, Subtable,
989 Subtable->Length, AcpiDmTableInfoCsrt0);
990 if (ACPI_FAILURE (Status))
991 {
992 return;
993 }
994
995 /* Shared info subtable (One per resource group) */
996
997 SubOffset = sizeof (ACPI_CSRT_GROUP);
998 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
999 Offset + SubOffset);
1000
1001 AcpiOsPrintf ("\n");
1002 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
1003 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
1004 if (ACPI_FAILURE (Status))
1005 {
1006 return;
1007 }
1008
1009 SubOffset += Subtable->SharedInfoLength;
1010
1011 /* Sub-Subtables (Resource Descriptors) */
1012
1013 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
1014 Offset + SubOffset);
1015
1016 while ((SubOffset < Subtable->Length) &&
1017 ((Offset + SubOffset) < Table->Length))
1018 {
1019 AcpiOsPrintf ("\n");
1020 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable,
1021 SubSubtable->Length, AcpiDmTableInfoCsrt2);
1022 if (ACPI_FAILURE (Status))
1023 {
1024 return;
1025 }
1026
1027 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
1028
1029 /* Resource-specific info buffer */
1030
1031 InfoLength = SubSubtable->Length - SubSubOffset;
1032 if (InfoLength)
1033 {
1034 Status = AcpiDmDumpTable (Length,
1035 Offset + SubOffset + SubSubOffset, Table,
1036 InfoLength, AcpiDmTableInfoCsrt2a);
1037 if (ACPI_FAILURE (Status))
1038 {
1039 return;
1040 }
1041 }
1042
1043 /* Point to next sub-subtable */
1044
1045 SubOffset += SubSubtable->Length;
1046 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable,
1047 SubSubtable->Length);
1048 }
1049
1050 /* Point to next subtable */
1051
1052 Offset += Subtable->Length;
1053 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable,
1054 Subtable->Length);
1055 }
1056 }
1057
1058
1059 /*******************************************************************************
1060 *
1061 * FUNCTION: AcpiDmDumpDbg2
1062 *
1063 * PARAMETERS: Table - A DBG2 table
1064 *
1065 * RETURN: None
1066 *
1067 * DESCRIPTION: Format the contents of a DBG2. This table type consists
1068 * of an open-ended number of subtables.
1069 *
1070 ******************************************************************************/
1071
1072 void
1073 AcpiDmDumpDbg2 (
1074 ACPI_TABLE_HEADER *Table)
1075 {
1076 ACPI_STATUS Status;
1077 ACPI_DBG2_DEVICE *Subtable;
1078 UINT32 Length = Table->Length;
1079 UINT32 Offset = sizeof (ACPI_TABLE_DBG2);
1080 UINT32 i;
1081 UINT32 ArrayOffset;
1082 UINT32 AbsoluteOffset;
1083 UINT8 *Array;
1084
1085
1086 /* Main table */
1087
1088 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
1089 if (ACPI_FAILURE (Status))
1090 {
1091 return;
1092 }
1093
1094 /* Subtables */
1095
1096 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
1097 while (Offset < Table->Length)
1098 {
1099 AcpiOsPrintf ("\n");
1100 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1101 Subtable->Length, AcpiDmTableInfoDbg2Device);
1102 if (ACPI_FAILURE (Status))
1103 {
1104 return;
1105 }
1106
1107 /* Dump the BaseAddress array */
1108
1109 for (i = 0; i < Subtable->RegisterCount; i++)
1110 {
1111 ArrayOffset = Subtable->BaseAddressOffset +
1112 (sizeof (ACPI_GENERIC_ADDRESS) * i);
1113 AbsoluteOffset = Offset + ArrayOffset;
1114 Array = (UINT8 *) Subtable + ArrayOffset;
1115
1116 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1117 Subtable->Length, AcpiDmTableInfoDbg2Addr);
1118 if (ACPI_FAILURE (Status))
1119 {
1120 return;
1121 }
1122 }
1123
1124 /* Dump the AddressSize array */
1125
1126 for (i = 0; i < Subtable->RegisterCount; i++)
1127 {
1128 ArrayOffset = Subtable->AddressSizeOffset +
1129 (sizeof (UINT32) * i);
1130 AbsoluteOffset = Offset + ArrayOffset;
1131 Array = (UINT8 *) Subtable + ArrayOffset;
1132
1133 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1134 Subtable->Length, AcpiDmTableInfoDbg2Size);
1135 if (ACPI_FAILURE (Status))
1136 {
1137 return;
1138 }
1139 }
1140
1141 /* Dump the Namestring (required) */
1142
1143 AcpiOsPrintf ("\n");
1144 ArrayOffset = Subtable->NamepathOffset;
1145 AbsoluteOffset = Offset + ArrayOffset;
1146 Array = (UINT8 *) Subtable + ArrayOffset;
1147
1148 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1149 Subtable->Length, AcpiDmTableInfoDbg2Name);
1150 if (ACPI_FAILURE (Status))
1151 {
1152 return;
1153 }
1154
1155 /* Dump the OemData (optional) */
1156
1157 if (Subtable->OemDataOffset)
1158 {
1159 Status = AcpiDmDumpTable (Length, Offset + Subtable->OemDataOffset,
1160 Table, Subtable->OemDataLength,
1161 AcpiDmTableInfoDbg2OemData);
1162 if (ACPI_FAILURE (Status))
1163 {
1164 return;
1165 }
1166 }
1167
1168 /* Point to next subtable */
1169
1170 Offset += Subtable->Length;
1171 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable,
1172 Subtable->Length);
1173 }
1174 }
1175
1176
1177 /*******************************************************************************
1178 *
1179 * FUNCTION: AcpiDmDumpDmar
1180 *
1181 * PARAMETERS: Table - A DMAR table
1182 *
1183 * RETURN: None
1184 *
1185 * DESCRIPTION: Format the contents of a DMAR. This table type consists
1186 * of an open-ended number of subtables.
1187 *
1188 ******************************************************************************/
1189
1190 void
1191 AcpiDmDumpDmar (
1192 ACPI_TABLE_HEADER *Table)
1193 {
1194 ACPI_STATUS Status;
1195 ACPI_DMAR_HEADER *Subtable;
1196 UINT32 Length = Table->Length;
1197 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
1198 ACPI_DMTABLE_INFO *InfoTable;
1199 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
1200 UINT32 ScopeOffset;
1201 UINT8 *PciPath;
1202 UINT32 PathOffset;
1203
1204
1205 /* Main table */
1206
1207 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
1208 if (ACPI_FAILURE (Status))
1209 {
1210 return;
1211 }
1212
1213 /* Subtables */
1214
1215 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
1216 while (Offset < Table->Length)
1217 {
1218 /* Common subtable header */
1219
1220 AcpiOsPrintf ("\n");
1221 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1222 Subtable->Length, AcpiDmTableInfoDmarHdr);
1223 if (ACPI_FAILURE (Status))
1224 {
1225 return;
1226 }
1227
1228 AcpiOsPrintf ("\n");
1229
1230 switch (Subtable->Type)
1231 {
1232 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
1233
1234 InfoTable = AcpiDmTableInfoDmar0;
1235 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
1236 break;
1237
1238 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
1239
1240 InfoTable = AcpiDmTableInfoDmar1;
1241 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
1242 break;
1243
1244 case ACPI_DMAR_TYPE_ROOT_ATS:
1245
1246 InfoTable = AcpiDmTableInfoDmar2;
1247 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
1248 break;
1249
1250 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
1251
1252 InfoTable = AcpiDmTableInfoDmar3;
1253 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
1254 break;
1255
1256 case ACPI_DMAR_TYPE_NAMESPACE:
1257
1258 InfoTable = AcpiDmTableInfoDmar4;
1259 ScopeOffset = sizeof (ACPI_DMAR_ANDD);
1260 break;
1261
1262 case ACPI_DMAR_TYPE_SATC:
1263
1264 InfoTable = AcpiDmTableInfoDmar5;
1265 ScopeOffset = sizeof (ACPI_DMAR_SATC);
1266 break;
1267
1268 default:
1269
1270 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
1271 Subtable->Type);
1272 return;
1273 }
1274
1275 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1276 Subtable->Length, InfoTable);
1277 if (ACPI_FAILURE (Status))
1278 {
1279 return;
1280 }
1281
1282 /*
1283 * Dump the optional device scope entries
1284 */
1285 if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
1286 (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE))
1287 {
1288 /* These types do not support device scopes */
1289
1290 goto NextSubtable;
1291 }
1292
1293 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset);
1294 while (ScopeOffset < Subtable->Length)
1295 {
1296 AcpiOsPrintf ("\n");
1297 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
1298 ScopeTable->Length, AcpiDmTableInfoDmarScope);
1299 if (ACPI_FAILURE (Status))
1300 {
1301 return;
1302 }
1303 AcpiOsPrintf ("\n");
1304
1305 /* Dump the PCI Path entries for this device scope */
1306
1307 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
1308
1309 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
1310 sizeof (ACPI_DMAR_DEVICE_SCOPE));
1311
1312 while (PathOffset < ScopeTable->Length)
1313 {
1314 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
1315 "PCI Path");
1316 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
1317
1318 /* Point to next PCI Path entry */
1319
1320 PathOffset += 2;
1321 PciPath += 2;
1322 AcpiOsPrintf ("\n");
1323 }
1324
1325 /* Point to next device scope entry */
1326
1327 ScopeOffset += ScopeTable->Length;
1328 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
1329 ScopeTable, ScopeTable->Length);
1330 }
1331
1332 NextSubtable:
1333 /* Point to next subtable */
1334
1335 Offset += Subtable->Length;
1336 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable,
1337 Subtable->Length);
1338 }
1339 }
1340
1341
1342 /*******************************************************************************
1343 *
1344 * FUNCTION: AcpiDmDumpDrtm
1345 *
1346 * PARAMETERS: Table - A DRTM table
1347 *
1348 * RETURN: None
1349 *
1350 * DESCRIPTION: Format the contents of a DRTM.
1351 *
1352 ******************************************************************************/
1353
1354 void
1355 AcpiDmDumpDrtm (
1356 ACPI_TABLE_HEADER *Table)
1357 {
1358 ACPI_STATUS Status;
1359 UINT32 Offset;
1360 ACPI_DRTM_VTABLE_LIST *DrtmVtl;
1361 ACPI_DRTM_RESOURCE_LIST *DrtmRl;
1362 ACPI_DRTM_DPS_ID *DrtmDps;
1363 UINT32 Count;
1364
1365
1366 /* Main table */
1367
1368 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
1369 AcpiDmTableInfoDrtm);
1370 if (ACPI_FAILURE (Status))
1371 {
1372 return;
1373 }
1374
1375 Offset = sizeof (ACPI_TABLE_DRTM);
1376
1377 /* Sub-tables */
1378
1379 /* Dump ValidatedTable length */
1380
1381 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
1382 AcpiOsPrintf ("\n");
1383 Status = AcpiDmDumpTable (Table->Length, Offset,
1384 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
1385 AcpiDmTableInfoDrtm0);
1386 if (ACPI_FAILURE (Status))
1387 {
1388 return;
1389 }
1390
1391 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
1392
1393 /* Dump Validated table addresses */
1394
1395 Count = 0;
1396 while ((Offset < Table->Length) &&
1397 (DrtmVtl->ValidatedTableCount > Count))
1398 {
1399 Status = AcpiDmDumpTable (Table->Length, Offset,
1400 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
1401 AcpiDmTableInfoDrtm0a);
1402 if (ACPI_FAILURE (Status))
1403 {
1404 return;
1405 }
1406
1407 Offset += sizeof (UINT64);
1408 Count++;
1409 }
1410
1411 /* Dump ResourceList length */
1412
1413 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
1414 AcpiOsPrintf ("\n");
1415 Status = AcpiDmDumpTable (Table->Length, Offset,
1416 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
1417 AcpiDmTableInfoDrtm1);
1418 if (ACPI_FAILURE (Status))
1419 {
1420 return;
1421 }
1422
1423 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
1424
1425 /* Dump the Resource List */
1426
1427 Count = 0;
1428 while ((Offset < Table->Length) &&
1429 (DrtmRl->ResourceCount > Count))
1430 {
1431 Status = AcpiDmDumpTable (Table->Length, Offset,
1432 ACPI_ADD_PTR (void, Table, Offset),
1433 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
1434 if (ACPI_FAILURE (Status))
1435 {
1436 return;
1437 }
1438
1439 Offset += sizeof (ACPI_DRTM_RESOURCE);
1440 Count++;
1441 }
1442
1443 /* Dump DPS */
1444
1445 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
1446 AcpiOsPrintf ("\n");
1447 (void) AcpiDmDumpTable (Table->Length, Offset,
1448 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
1449 }
1450
1451
1452 /*******************************************************************************
1453 *
1454 * FUNCTION: AcpiDmDumpEinj
1455 *
1456 * PARAMETERS: Table - A EINJ table
1457 *
1458 * RETURN: None
1459 *
1460 * DESCRIPTION: Format the contents of a EINJ. This table type consists
1461 * of an open-ended number of subtables.
1462 *
1463 ******************************************************************************/
1464
1465 void
1466 AcpiDmDumpEinj (
1467 ACPI_TABLE_HEADER *Table)
1468 {
1469 ACPI_STATUS Status;
1470 ACPI_WHEA_HEADER *Subtable;
1471 UINT32 Length = Table->Length;
1472 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
1473
1474
1475 /* Main table */
1476
1477 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
1478 if (ACPI_FAILURE (Status))
1479 {
1480 return;
1481 }
1482
1483 /* Subtables */
1484
1485 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1486 while (Offset < Table->Length)
1487 {
1488 AcpiOsPrintf ("\n");
1489 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1490 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
1491 if (ACPI_FAILURE (Status))
1492 {
1493 return;
1494 }
1495
1496 /* Point to next subtable (each subtable is of fixed length) */
1497
1498 Offset += sizeof (ACPI_WHEA_HEADER);
1499 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
1500 sizeof (ACPI_WHEA_HEADER));
1501 }
1502 }
1503
1504
1505 /*******************************************************************************
1506 *
1507 * FUNCTION: AcpiDmDumpErst
1508 *
1509 * PARAMETERS: Table - A ERST table
1510 *
1511 * RETURN: None
1512 *
1513 * DESCRIPTION: Format the contents of a ERST. This table type consists
1514 * of an open-ended number of subtables.
1515 *
1516 ******************************************************************************/
1517
1518 void
1519 AcpiDmDumpErst (
1520 ACPI_TABLE_HEADER *Table)
1521 {
1522 ACPI_STATUS Status;
1523 ACPI_WHEA_HEADER *Subtable;
1524 UINT32 Length = Table->Length;
1525 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
1526
1527
1528 /* Main table */
1529
1530 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1531 if (ACPI_FAILURE (Status))
1532 {
1533 return;
1534 }
1535
1536 /* Subtables */
1537
1538 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1539 while (Offset < Table->Length)
1540 {
1541 AcpiOsPrintf ("\n");
1542 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1543 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1544 if (ACPI_FAILURE (Status))
1545 {
1546 return;
1547 }
1548
1549 /* Point to next subtable (each subtable is of fixed length) */
1550
1551 Offset += sizeof (ACPI_WHEA_HEADER);
1552 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
1553 sizeof (ACPI_WHEA_HEADER));
1554 }
1555 }
1556
1557
1558 /*******************************************************************************
1559 *
1560 * FUNCTION: AcpiDmDumpFpdt
1561 *
1562 * PARAMETERS: Table - A FPDT table
1563 *
1564 * RETURN: None
1565 *
1566 * DESCRIPTION: Format the contents of a FPDT. This table type consists
1567 * of an open-ended number of subtables.
1568 *
1569 ******************************************************************************/
1570
1571 void
1572 AcpiDmDumpFpdt (
1573 ACPI_TABLE_HEADER *Table)
1574 {
1575 ACPI_STATUS Status;
1576 ACPI_FPDT_HEADER *Subtable;
1577 UINT32 Length = Table->Length;
1578 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
1579 ACPI_DMTABLE_INFO *InfoTable;
1580
1581
1582 /* There is no main table (other than the standard ACPI header) */
1583
1584 /* Subtables */
1585
1586 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
1587 while (Offset < Table->Length)
1588 {
1589 /* Common subtable header */
1590
1591 AcpiOsPrintf ("\n");
1592 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1593 Subtable->Length, AcpiDmTableInfoFpdtHdr);
1594 if (ACPI_FAILURE (Status))
1595 {
1596 return;
1597 }
1598
1599 switch (Subtable->Type)
1600 {
1601 case ACPI_FPDT_TYPE_BOOT:
1602
1603 InfoTable = AcpiDmTableInfoFpdt0;
1604 break;
1605
1606 case ACPI_FPDT_TYPE_S3PERF:
1607
1608 InfoTable = AcpiDmTableInfoFpdt1;
1609 break;
1610
1611 default:
1612
1613 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
1614 Subtable->Type);
1615
1616 /* Attempt to continue */
1617
1618 if (!Subtable->Length)
1619 {
1620 AcpiOsPrintf ("Invalid zero length subtable\n");
1621 return;
1622 }
1623 goto NextSubtable;
1624 }
1625
1626 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1627 Subtable->Length, InfoTable);
1628 if (ACPI_FAILURE (Status))
1629 {
1630 return;
1631 }
1632
1633 NextSubtable:
1634 /* Point to next subtable */
1635
1636 Offset += Subtable->Length;
1637 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable,
1638 Subtable->Length);
1639 }
1640 }
1641
1642
1643 /*******************************************************************************
1644 *
1645 * FUNCTION: AcpiDmDumpGtdt
1646 *
1647 * PARAMETERS: Table - A GTDT table
1648 *
1649 * RETURN: None
1650 *
1651 * DESCRIPTION: Format the contents of a GTDT. This table type consists
1652 * of an open-ended number of subtables.
1653 *
1654 ******************************************************************************/
1655
1656 void
1657 AcpiDmDumpGtdt (
1658 ACPI_TABLE_HEADER *Table)
1659 {
1660 ACPI_STATUS Status;
1661 ACPI_GTDT_HEADER *Subtable;
1662 UINT32 Length = Table->Length;
1663 UINT32 Offset = sizeof (ACPI_TABLE_GTDT);
1664 ACPI_DMTABLE_INFO *InfoTable;
1665 UINT32 SubtableLength;
1666 UINT32 GtCount;
1667 ACPI_GTDT_TIMER_ENTRY *GtxTable;
1668
1669
1670 /* Main table */
1671
1672 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
1673 if (ACPI_FAILURE (Status))
1674 {
1675 return;
1676 }
1677
1678 /* Rev 3 fields */
1679
1680 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1681
1682 if (Table->Revision > 2)
1683 {
1684 SubtableLength = sizeof (ACPI_GTDT_EL2);
1685 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1686 SubtableLength, AcpiDmTableInfoGtdtEl2);
1687 if (ACPI_FAILURE (Status))
1688 {
1689 return;
1690 }
1691 Offset += SubtableLength;
1692 }
1693
1694 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1695
1696 /* Subtables */
1697
1698 while (Offset < Table->Length)
1699 {
1700 /* Common subtable header */
1701
1702 AcpiOsPrintf ("\n");
1703 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1704 Subtable->Length, AcpiDmTableInfoGtdtHdr);
1705 if (ACPI_FAILURE (Status))
1706 {
1707 return;
1708 }
1709
1710 GtCount = 0;
1711 switch (Subtable->Type)
1712 {
1713 case ACPI_GTDT_TYPE_TIMER_BLOCK:
1714
1715 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
1716 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1717 Subtable))->TimerCount;
1718
1719 InfoTable = AcpiDmTableInfoGtdt0;
1720 break;
1721
1722 case ACPI_GTDT_TYPE_WATCHDOG:
1723
1724 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG);
1725
1726 InfoTable = AcpiDmTableInfoGtdt1;
1727 break;
1728
1729 default:
1730
1731 /* Cannot continue on unknown type - no length */
1732
1733 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
1734 Subtable->Type);
1735 return;
1736 }
1737
1738 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1739 Subtable->Length, InfoTable);
1740 if (ACPI_FAILURE (Status))
1741 {
1742 return;
1743 }
1744
1745 /* Point to end of current subtable (each subtable above is of fixed length) */
1746
1747 Offset += SubtableLength;
1748
1749 /* If there are any Gt Timer Blocks from above, dump them now */
1750
1751 if (GtCount)
1752 {
1753 GtxTable = ACPI_ADD_PTR (
1754 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength);
1755 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
1756
1757 while (GtCount)
1758 {
1759 AcpiOsPrintf ("\n");
1760 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
1761 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
1762 if (ACPI_FAILURE (Status))
1763 {
1764 return;
1765 }
1766 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
1767 GtxTable++;
1768 GtCount--;
1769 }
1770 }
1771
1772 /* Point to next subtable */
1773
1774 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength);
1775 }
1776 }
1777
1778
1779 /*******************************************************************************
1780 *
1781 * FUNCTION: AcpiDmDumpHest
1782 *
1783 * PARAMETERS: Table - A HEST table
1784 *
1785 * RETURN: None
1786 *
1787 * DESCRIPTION: Format the contents of a HEST. This table type consists
1788 * of an open-ended number of subtables.
1789 *
1790 ******************************************************************************/
1791
1792 void
1793 AcpiDmDumpHest (
1794 ACPI_TABLE_HEADER *Table)
1795 {
1796 ACPI_STATUS Status;
1797 ACPI_HEST_HEADER *Subtable;
1798 UINT32 Length = Table->Length;
1799 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
1800 ACPI_DMTABLE_INFO *InfoTable;
1801 UINT32 SubtableLength;
1802 UINT32 BankCount;
1803 ACPI_HEST_IA_ERROR_BANK *BankTable;
1804
1805
1806 /* Main table */
1807
1808 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1809 if (ACPI_FAILURE (Status))
1810 {
1811 return;
1812 }
1813
1814 /* Subtables */
1815
1816 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1817 while (Offset < Table->Length)
1818 {
1819 BankCount = 0;
1820 switch (Subtable->Type)
1821 {
1822 case ACPI_HEST_TYPE_IA32_CHECK:
1823
1824 InfoTable = AcpiDmTableInfoHest0;
1825 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1826 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1827 Subtable))->NumHardwareBanks;
1828 break;
1829
1830 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1831
1832 InfoTable = AcpiDmTableInfoHest1;
1833 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1834 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1835 Subtable))->NumHardwareBanks;
1836 break;
1837
1838 case ACPI_HEST_TYPE_IA32_NMI:
1839
1840 InfoTable = AcpiDmTableInfoHest2;
1841 SubtableLength = sizeof (ACPI_HEST_IA_NMI);
1842 break;
1843
1844 case ACPI_HEST_TYPE_AER_ROOT_PORT:
1845
1846 InfoTable = AcpiDmTableInfoHest6;
1847 SubtableLength = sizeof (ACPI_HEST_AER_ROOT);
1848 break;
1849
1850 case ACPI_HEST_TYPE_AER_ENDPOINT:
1851
1852 InfoTable = AcpiDmTableInfoHest7;
1853 SubtableLength = sizeof (ACPI_HEST_AER);
1854 break;
1855
1856 case ACPI_HEST_TYPE_AER_BRIDGE:
1857
1858 InfoTable = AcpiDmTableInfoHest8;
1859 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1860 break;
1861
1862 case ACPI_HEST_TYPE_GENERIC_ERROR:
1863
1864 InfoTable = AcpiDmTableInfoHest9;
1865 SubtableLength = sizeof (ACPI_HEST_GENERIC);
1866 break;
1867
1868 case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
1869
1870 InfoTable = AcpiDmTableInfoHest10;
1871 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2);
1872 break;
1873
1874 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1875
1876 InfoTable = AcpiDmTableInfoHest11;
1877 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK);
1878 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
1879 Subtable))->NumHardwareBanks;
1880 break;
1881
1882 default:
1883
1884 /* Cannot continue on unknown type - no length */
1885
1886 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
1887 Subtable->Type);
1888 return;
1889 }
1890
1891 AcpiOsPrintf ("\n");
1892 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1893 SubtableLength, InfoTable);
1894 if (ACPI_FAILURE (Status))
1895 {
1896 return;
1897 }
1898
1899 /* Point to end of current subtable (each subtable above is of fixed length) */
1900
1901 Offset += SubtableLength;
1902
1903 /* If there are any (fixed-length) Error Banks from above, dump them now */
1904
1905 if (BankCount)
1906 {
1907 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable,
1908 SubtableLength);
1909 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1910
1911 while (BankCount)
1912 {
1913 AcpiOsPrintf ("\n");
1914 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1915 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1916 if (ACPI_FAILURE (Status))
1917 {
1918 return;
1919 }
1920
1921 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1922 BankTable++;
1923 BankCount--;
1924 }
1925 }
1926
1927 /* Point to next subtable */
1928
1929 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength);
1930 }
1931 }
1932
1933
1934 /*******************************************************************************
1935 *
1936 * FUNCTION: AcpiDmDumpHmat
1937 *
1938 * PARAMETERS: Table - A HMAT table
1939 *
1940 * RETURN: None
1941 *
1942 * DESCRIPTION: Format the contents of a HMAT.
1943 *
1944 ******************************************************************************/
1945
1946 void
1947 AcpiDmDumpHmat (
1948 ACPI_TABLE_HEADER *Table)
1949 {
1950 ACPI_STATUS Status;
1951 ACPI_HMAT_STRUCTURE *HmatStruct;
1952 ACPI_HMAT_LOCALITY *HmatLocality;
1953 ACPI_HMAT_CACHE *HmatCache;
1954 UINT32 Offset;
1955 UINT32 SubtableOffset;
1956 UINT32 Length;
1957 ACPI_DMTABLE_INFO *InfoTable;
1958 UINT32 i, j;
1959
1960
1961 /* Main table */
1962
1963 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat);
1964 if (ACPI_FAILURE (Status))
1965 {
1966 return;
1967 }
1968 Offset = sizeof (ACPI_TABLE_HMAT);
1969
1970 while (Offset < Table->Length)
1971 {
1972 AcpiOsPrintf ("\n");
1973
1974 /* Dump HMAT structure header */
1975
1976 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset);
1977 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE))
1978 {
1979 AcpiOsPrintf ("Invalid HMAT structure length\n");
1980 return;
1981 }
1982 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1983 HmatStruct->Length, AcpiDmTableInfoHmatHdr);
1984 if (ACPI_FAILURE (Status))
1985 {
1986 return;
1987 }
1988
1989 switch (HmatStruct->Type)
1990 {
1991 case ACPI_HMAT_TYPE_ADDRESS_RANGE:
1992
1993 InfoTable = AcpiDmTableInfoHmat0;
1994 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN);
1995 break;
1996
1997 case ACPI_HMAT_TYPE_LOCALITY:
1998
1999 InfoTable = AcpiDmTableInfoHmat1;
2000 Length = sizeof (ACPI_HMAT_LOCALITY);
2001 break;
2002
2003 case ACPI_HMAT_TYPE_CACHE:
2004
2005 InfoTable = AcpiDmTableInfoHmat2;
2006 Length = sizeof (ACPI_HMAT_CACHE);
2007 break;
2008
2009 default:
2010
2011 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n",
2012 HmatStruct->Type);
2013
2014 /* Attempt to continue */
2015
2016 goto NextSubtable;
2017 }
2018
2019 /* Dump HMAT structure body */
2020
2021 if (HmatStruct->Length < Length)
2022 {
2023 AcpiOsPrintf ("Invalid HMAT structure length\n");
2024 return;
2025 }
2026 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
2027 HmatStruct->Length, InfoTable);
2028 if (ACPI_FAILURE (Status))
2029 {
2030 return;
2031 }
2032
2033 /* Dump HMAT structure additionals */
2034
2035 switch (HmatStruct->Type)
2036 {
2037 case ACPI_HMAT_TYPE_LOCALITY:
2038
2039 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct);
2040 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY);
2041
2042 /* Dump initiator proximity domains */
2043
2044 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2045 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4))
2046 {
2047 AcpiOsPrintf ("Invalid initiator proximity domain number\n");
2048 return;
2049 }
2050 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
2051 {
2052 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2053 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2054 4, AcpiDmTableInfoHmat1a);
2055 if (ACPI_FAILURE (Status))
2056 {
2057 return;
2058 }
2059
2060 SubtableOffset += 4;
2061 }
2062
2063 /* Dump target proximity domains */
2064
2065 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2066 (UINT32)(HmatLocality->NumberOfTargetPDs * 4))
2067 {
2068 AcpiOsPrintf ("Invalid target proximity domain number\n");
2069 return;
2070 }
2071 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++)
2072 {
2073 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2074 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2075 4, AcpiDmTableInfoHmat1b);
2076 if (ACPI_FAILURE (Status))
2077 {
2078 return;
2079 }
2080
2081 SubtableOffset += 4;
2082 }
2083
2084 /* Dump latency/bandwidth entris */
2085
2086 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2087 (UINT32)(HmatLocality->NumberOfInitiatorPDs *
2088 HmatLocality->NumberOfTargetPDs * 2))
2089 {
2090 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n");
2091 return;
2092 }
2093 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
2094 {
2095 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++)
2096 {
2097 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2098 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2099 2, AcpiDmTableInfoHmat1c);
2100 if (ACPI_FAILURE(Status))
2101 {
2102 return;
2103 }
2104
2105 SubtableOffset += 2;
2106 }
2107 }
2108 break;
2109
2110 case ACPI_HMAT_TYPE_CACHE:
2111
2112 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct);
2113 SubtableOffset = sizeof (ACPI_HMAT_CACHE);
2114
2115 /* Dump SMBIOS handles */
2116
2117 if ((UINT32)(HmatStruct->Length - SubtableOffset) <
2118 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2))
2119 {
2120 AcpiOsPrintf ("Invalid SMBIOS handle number\n");
2121 return;
2122 }
2123 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++)
2124 {
2125 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
2126 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
2127 2, AcpiDmTableInfoHmat2a);
2128 if (ACPI_FAILURE (Status))
2129 {
2130 return;
2131 }
2132
2133 SubtableOffset += 2;
2134 }
2135 break;
2136
2137 default:
2138
2139 break;
2140 }
2141
2142 NextSubtable:
2143 /* Point to next HMAT structure subtable */
2144
2145 Offset += (HmatStruct->Length);
2146 }
2147 }
Cache object: a98df1b8ab0a7cc27a1a28c85ddbbe12
|