Annotation of src/sys/external/bsd/acpica/dist/common/dmtbdump1.c, Revision 1.1.1.4.6.1
1.1 christos 1: /******************************************************************************
2: *
3: * Module Name: dmtbdump1 - Dump ACPI data tables that contain no AML code
4: *
5: *****************************************************************************/
6:
7: /*
1.1.1.4.6.1! thorpej 8: * Copyright (C) 2000 - 2021, Intel Corp.
1.1 christos 9: * All rights reserved.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions, and the following disclaimer,
16: * without modification.
17: * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18: * substantially similar to the "NO WARRANTY" disclaimer below
19: * ("Disclaimer") and any redistribution must be conditioned upon
20: * including a substantially similar Disclaimer requirement for further
21: * binary redistribution.
22: * 3. Neither the names of the above-listed copyright holders nor the names
23: * of any contributors may be used to endorse or promote products derived
24: * from this software without specific prior written permission.
25: *
26: * Alternatively, this software may be distributed under the terms of the
27: * GNU General Public License ("GPL") version 2 as published by the Free
28: * Software Foundation.
29: *
30: * NO WARRANTY
31: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
1.1.1.4.6.1! thorpej 33: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
1.1 christos 34: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35: * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41: * POSSIBILITY OF SUCH DAMAGES.
42: */
43:
44: #include "acpi.h"
45: #include "accommon.h"
46: #include "acdisasm.h"
47: #include "actables.h"
48:
49: /* This module used for application-level code only */
50:
51: #define _COMPONENT ACPI_CA_DISASSEMBLER
52: ACPI_MODULE_NAME ("dmtbdump1")
53:
54:
55: /*******************************************************************************
56: *
57: * FUNCTION: AcpiDmDumpAsf
58: *
59: * PARAMETERS: Table - A ASF table
60: *
61: * RETURN: None
62: *
63: * DESCRIPTION: Format the contents of a ASF table
64: *
65: ******************************************************************************/
66:
67: void
68: AcpiDmDumpAsf (
69: ACPI_TABLE_HEADER *Table)
70: {
71: ACPI_STATUS Status;
72: UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
73: ACPI_ASF_INFO *Subtable;
74: ACPI_DMTABLE_INFO *InfoTable;
75: ACPI_DMTABLE_INFO *DataInfoTable = NULL;
76: UINT8 *DataTable = NULL;
77: UINT32 DataCount = 0;
78: UINT32 DataLength = 0;
79: UINT32 DataOffset = 0;
80: UINT32 i;
81: UINT8 Type;
82:
83:
84: /* No main table, only subtables */
85:
86: Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
87: while (Offset < Table->Length)
88: {
89: /* Common subtable header */
90:
91: Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
92: Subtable->Header.Length, AcpiDmTableInfoAsfHdr);
93: if (ACPI_FAILURE (Status))
94: {
95: return;
96: }
97:
98: /* The actual type is the lower 7 bits of Type */
99:
100: Type = (UINT8) (Subtable->Header.Type & 0x7F);
101:
102: switch (Type)
103: {
104: case ACPI_ASF_TYPE_INFO:
105:
106: InfoTable = AcpiDmTableInfoAsf0;
107: break;
108:
109: case ACPI_ASF_TYPE_ALERT:
110:
111: InfoTable = AcpiDmTableInfoAsf1;
112: DataInfoTable = AcpiDmTableInfoAsf1a;
113: DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT));
114: DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts;
115: DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength;
116: DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
117: break;
118:
119: case ACPI_ASF_TYPE_CONTROL:
120:
121: InfoTable = AcpiDmTableInfoAsf2;
122: DataInfoTable = AcpiDmTableInfoAsf2a;
123: DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE));
124: DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls;
125: DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength;
126: DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
127: break;
128:
129: case ACPI_ASF_TYPE_BOOT:
130:
131: InfoTable = AcpiDmTableInfoAsf3;
132: break;
133:
134: case ACPI_ASF_TYPE_ADDRESS:
135:
136: InfoTable = AcpiDmTableInfoAsf4;
137: DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS));
138: DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices;
139: DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
140: break;
141:
142: default:
143:
144: AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
145: Subtable->Header.Type);
146: return;
147: }
148:
149: Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
150: Subtable->Header.Length, InfoTable);
151: if (ACPI_FAILURE (Status))
152: {
153: return;
154: }
155:
156: /* Dump variable-length extra data */
157:
158: switch (Type)
159: {
160: case ACPI_ASF_TYPE_ALERT:
161: case ACPI_ASF_TYPE_CONTROL:
162:
163: for (i = 0; i < DataCount; i++)
164: {
165: AcpiOsPrintf ("\n");
166: Status = AcpiDmDumpTable (Table->Length, DataOffset,
167: DataTable, DataLength, DataInfoTable);
168: if (ACPI_FAILURE (Status))
169: {
170: return;
171: }
172:
173: DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
174: DataOffset += DataLength;
175: }
176: break;
177:
178: case ACPI_ASF_TYPE_ADDRESS:
179:
180: for (i = 0; i < DataLength; i++)
181: {
182: if (!(i % 16))
183: {
184: AcpiDmLineHeader (DataOffset, 1, "Addresses");
185: }
186:
187: AcpiOsPrintf ("%2.2X ", *DataTable);
188: DataTable++;
189: DataOffset++;
190:
191: if (DataOffset > Table->Length)
192: {
193: AcpiOsPrintf (
194: "**** ACPI table terminates in the middle of a "
195: "data structure! (ASF! table)\n");
196: return;
197: }
198: }
199:
200: AcpiOsPrintf ("\n");
201: break;
202:
203: default:
204:
205: break;
206: }
207:
208: AcpiOsPrintf ("\n");
209:
210: /* Point to next subtable */
211:
212: if (!Subtable->Header.Length)
213: {
214: AcpiOsPrintf ("Invalid zero subtable header length\n");
215: return;
216: }
217:
218: Offset += Subtable->Header.Length;
219: Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable,
220: Subtable->Header.Length);
221: }
222: }
223:
1.1.1.4.6.1! thorpej 224: /*******************************************************************************
! 225: *
! 226: * FUNCTION: AcpiDmDumpCedt
! 227: *
! 228: * PARAMETERS: Table - A CEDT table
! 229: *
! 230: * RETURN: None
! 231: *
! 232: * DESCRIPTION: Format the contents of a CEDT. This table type consists
! 233: * of an open-ended number of subtables.
! 234: *
! 235: ******************************************************************************/
! 236:
! 237: void
! 238: AcpiDmDumpCedt (
! 239: ACPI_TABLE_HEADER *Table)
! 240: {
! 241: ACPI_STATUS Status;
! 242: ACPI_CEDT_HEADER *Subtable;
! 243: UINT32 Length = Table->Length;
! 244: UINT32 Offset = sizeof (ACPI_TABLE_CEDT);
! 245: ACPI_DMTABLE_INFO *InfoTable;
! 246:
! 247:
! 248: /* There is no main table (other than the standard ACPI header) */
! 249:
! 250: Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset);
! 251: while (Offset < Table->Length)
! 252: {
! 253: /* Common subtable header */
! 254:
! 255: AcpiOsPrintf ("\n");
! 256: Status = AcpiDmDumpTable (Length, Offset, Subtable,
! 257: Subtable->Length, AcpiDmTableInfoCedtHdr);
! 258: if (ACPI_FAILURE (Status))
! 259: {
! 260: return;
! 261: }
! 262:
! 263: switch (Subtable->Type)
! 264: {
! 265: case ACPI_CEDT_TYPE_CHBS:
! 266:
! 267: InfoTable = AcpiDmTableInfoCedt0;
! 268: break;
! 269:
! 270: default:
! 271:
! 272: AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n",
! 273: Subtable->Type);
! 274:
! 275: /* Attempt to continue */
! 276:
! 277: if (!Subtable->Length)
! 278: {
! 279: AcpiOsPrintf ("Invalid zero length subtable\n");
! 280: return;
! 281: }
! 282: goto NextSubtable;
! 283: }
! 284:
! 285: Status = AcpiDmDumpTable (Length, Offset, Subtable,
! 286: Subtable->Length, InfoTable);
! 287: if (ACPI_FAILURE (Status))
! 288: {
! 289: return;
! 290: }
! 291:
! 292: NextSubtable:
! 293: /* Point to next subtable */
! 294:
! 295: Offset += Subtable->Length;
! 296: Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable,
! 297: Subtable->Length);
! 298: }
! 299: }
1.1 christos 300:
301: /*******************************************************************************
302: *
303: * FUNCTION: AcpiDmDumpCpep
304: *
305: * PARAMETERS: Table - A CPEP table
306: *
307: * RETURN: None
308: *
309: * DESCRIPTION: Format the contents of a CPEP. This table type consists
310: * of an open-ended number of subtables.
311: *
312: ******************************************************************************/
313:
314: void
315: AcpiDmDumpCpep (
316: ACPI_TABLE_HEADER *Table)
317: {
318: ACPI_STATUS Status;
319: ACPI_CPEP_POLLING *Subtable;
320: UINT32 Length = Table->Length;
321: UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
322:
323:
324: /* Main table */
325:
326: Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
327: if (ACPI_FAILURE (Status))
328: {
329: return;
330: }
331:
332: /* Subtables */
333:
334: Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
335: while (Offset < Table->Length)
336: {
337: AcpiOsPrintf ("\n");
338: Status = AcpiDmDumpTable (Length, Offset, Subtable,
339: Subtable->Header.Length, AcpiDmTableInfoCpep0);
340: if (ACPI_FAILURE (Status))
341: {
342: return;
343: }
344:
345: /* Point to next subtable */
346:
347: Offset += Subtable->Header.Length;
348: Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable,
349: Subtable->Header.Length);
350: }
351: }
352:
353:
354: /*******************************************************************************
355: *
356: * FUNCTION: AcpiDmDumpCsrt
357: *
358: * PARAMETERS: Table - A CSRT table
359: *
360: * RETURN: None
361: *
362: * DESCRIPTION: Format the contents of a CSRT. This table type consists
363: * of an open-ended number of subtables.
364: *
365: ******************************************************************************/
366:
367: void
368: AcpiDmDumpCsrt (
369: ACPI_TABLE_HEADER *Table)
370: {
371: ACPI_STATUS Status;
372: ACPI_CSRT_GROUP *Subtable;
373: ACPI_CSRT_SHARED_INFO *SharedInfoTable;
374: ACPI_CSRT_DESCRIPTOR *SubSubtable;
375: UINT32 Length = Table->Length;
376: UINT32 Offset = sizeof (ACPI_TABLE_CSRT);
377: UINT32 SubOffset;
378: UINT32 SubSubOffset;
379: UINT32 InfoLength;
380:
381:
382: /* The main table only contains the ACPI header, thus already handled */
383:
384: /* Subtables (Resource Groups) */
385:
386: Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
387: while (Offset < Table->Length)
388: {
389: /* Resource group subtable */
390:
391: AcpiOsPrintf ("\n");
392: Status = AcpiDmDumpTable (Length, Offset, Subtable,
393: Subtable->Length, AcpiDmTableInfoCsrt0);
394: if (ACPI_FAILURE (Status))
395: {
396: return;
397: }
398:
399: /* Shared info subtable (One per resource group) */
400:
401: SubOffset = sizeof (ACPI_CSRT_GROUP);
402: SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
403: Offset + SubOffset);
404:
405: AcpiOsPrintf ("\n");
406: Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
407: sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
408: if (ACPI_FAILURE (Status))
409: {
410: return;
411: }
412:
413: SubOffset += Subtable->SharedInfoLength;
414:
415: /* Sub-Subtables (Resource Descriptors) */
416:
417: SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
418: Offset + SubOffset);
419:
420: while ((SubOffset < Subtable->Length) &&
421: ((Offset + SubOffset) < Table->Length))
422: {
423: AcpiOsPrintf ("\n");
424: Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable,
425: SubSubtable->Length, AcpiDmTableInfoCsrt2);
426: if (ACPI_FAILURE (Status))
427: {
428: return;
429: }
430:
431: SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
432:
433: /* Resource-specific info buffer */
434:
435: InfoLength = SubSubtable->Length - SubSubOffset;
436: if (InfoLength)
437: {
438: Status = AcpiDmDumpTable (Length,
439: Offset + SubOffset + SubSubOffset, Table,
440: InfoLength, AcpiDmTableInfoCsrt2a);
441: if (ACPI_FAILURE (Status))
442: {
443: return;
444: }
445: }
446:
447: /* Point to next sub-subtable */
448:
449: SubOffset += SubSubtable->Length;
450: SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable,
451: SubSubtable->Length);
452: }
453:
454: /* Point to next subtable */
455:
456: Offset += Subtable->Length;
457: Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable,
458: Subtable->Length);
459: }
460: }
461:
462:
463: /*******************************************************************************
464: *
465: * FUNCTION: AcpiDmDumpDbg2
466: *
467: * PARAMETERS: Table - A DBG2 table
468: *
469: * RETURN: None
470: *
471: * DESCRIPTION: Format the contents of a DBG2. This table type consists
472: * of an open-ended number of subtables.
473: *
474: ******************************************************************************/
475:
476: void
477: AcpiDmDumpDbg2 (
478: ACPI_TABLE_HEADER *Table)
479: {
480: ACPI_STATUS Status;
481: ACPI_DBG2_DEVICE *Subtable;
482: UINT32 Length = Table->Length;
483: UINT32 Offset = sizeof (ACPI_TABLE_DBG2);
484: UINT32 i;
485: UINT32 ArrayOffset;
486: UINT32 AbsoluteOffset;
487: UINT8 *Array;
488:
489:
490: /* Main table */
491:
492: Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
493: if (ACPI_FAILURE (Status))
494: {
495: return;
496: }
497:
498: /* Subtables */
499:
500: Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
501: while (Offset < Table->Length)
502: {
503: AcpiOsPrintf ("\n");
504: Status = AcpiDmDumpTable (Length, Offset, Subtable,
505: Subtable->Length, AcpiDmTableInfoDbg2Device);
506: if (ACPI_FAILURE (Status))
507: {
508: return;
509: }
510:
511: /* Dump the BaseAddress array */
512:
513: for (i = 0; i < Subtable->RegisterCount; i++)
514: {
515: ArrayOffset = Subtable->BaseAddressOffset +
516: (sizeof (ACPI_GENERIC_ADDRESS) * i);
517: AbsoluteOffset = Offset + ArrayOffset;
518: Array = (UINT8 *) Subtable + ArrayOffset;
519:
520: Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
521: Subtable->Length, AcpiDmTableInfoDbg2Addr);
522: if (ACPI_FAILURE (Status))
523: {
524: return;
525: }
526: }
527:
528: /* Dump the AddressSize array */
529:
530: for (i = 0; i < Subtable->RegisterCount; i++)
531: {
532: ArrayOffset = Subtable->AddressSizeOffset +
533: (sizeof (UINT32) * i);
534: AbsoluteOffset = Offset + ArrayOffset;
535: Array = (UINT8 *) Subtable + ArrayOffset;
536:
537: Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
538: Subtable->Length, AcpiDmTableInfoDbg2Size);
539: if (ACPI_FAILURE (Status))
540: {
541: return;
542: }
543: }
544:
545: /* Dump the Namestring (required) */
546:
547: AcpiOsPrintf ("\n");
548: ArrayOffset = Subtable->NamepathOffset;
549: AbsoluteOffset = Offset + ArrayOffset;
550: Array = (UINT8 *) Subtable + ArrayOffset;
551:
552: Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
553: Subtable->Length, AcpiDmTableInfoDbg2Name);
554: if (ACPI_FAILURE (Status))
555: {
556: return;
557: }
558:
559: /* Dump the OemData (optional) */
560:
561: if (Subtable->OemDataOffset)
562: {
563: Status = AcpiDmDumpTable (Length, Offset + Subtable->OemDataOffset,
564: Table, Subtable->OemDataLength,
565: AcpiDmTableInfoDbg2OemData);
566: if (ACPI_FAILURE (Status))
567: {
568: return;
569: }
570: }
571:
572: /* Point to next subtable */
573:
574: Offset += Subtable->Length;
575: Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable,
576: Subtable->Length);
577: }
578: }
579:
580:
581: /*******************************************************************************
582: *
583: * FUNCTION: AcpiDmDumpDmar
584: *
585: * PARAMETERS: Table - A DMAR table
586: *
587: * RETURN: None
588: *
589: * DESCRIPTION: Format the contents of a DMAR. This table type consists
590: * of an open-ended number of subtables.
591: *
592: ******************************************************************************/
593:
594: void
595: AcpiDmDumpDmar (
596: ACPI_TABLE_HEADER *Table)
597: {
598: ACPI_STATUS Status;
599: ACPI_DMAR_HEADER *Subtable;
600: UINT32 Length = Table->Length;
601: UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
602: ACPI_DMTABLE_INFO *InfoTable;
603: ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
604: UINT32 ScopeOffset;
605: UINT8 *PciPath;
606: UINT32 PathOffset;
607:
608:
609: /* Main table */
610:
611: Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
612: if (ACPI_FAILURE (Status))
613: {
614: return;
615: }
616:
617: /* Subtables */
618:
619: Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
620: while (Offset < Table->Length)
621: {
622: /* Common subtable header */
623:
624: AcpiOsPrintf ("\n");
625: Status = AcpiDmDumpTable (Length, Offset, Subtable,
626: Subtable->Length, AcpiDmTableInfoDmarHdr);
627: if (ACPI_FAILURE (Status))
628: {
629: return;
630: }
631:
632: AcpiOsPrintf ("\n");
633:
634: switch (Subtable->Type)
635: {
636: case ACPI_DMAR_TYPE_HARDWARE_UNIT:
637:
638: InfoTable = AcpiDmTableInfoDmar0;
639: ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
640: break;
641:
642: case ACPI_DMAR_TYPE_RESERVED_MEMORY:
643:
644: InfoTable = AcpiDmTableInfoDmar1;
645: ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
646: break;
647:
648: case ACPI_DMAR_TYPE_ROOT_ATS:
649:
650: InfoTable = AcpiDmTableInfoDmar2;
651: ScopeOffset = sizeof (ACPI_DMAR_ATSR);
652: break;
653:
654: case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
655:
656: InfoTable = AcpiDmTableInfoDmar3;
657: ScopeOffset = sizeof (ACPI_DMAR_RHSA);
658: break;
659:
660: case ACPI_DMAR_TYPE_NAMESPACE:
661:
662: InfoTable = AcpiDmTableInfoDmar4;
663: ScopeOffset = sizeof (ACPI_DMAR_ANDD);
664: break;
665:
666: default:
667:
668: AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
669: Subtable->Type);
670: return;
671: }
672:
673: Status = AcpiDmDumpTable (Length, Offset, Subtable,
674: Subtable->Length, InfoTable);
675: if (ACPI_FAILURE (Status))
676: {
677: return;
678: }
679:
680: /*
681: * Dump the optional device scope entries
682: */
683: if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
684: (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE))
685: {
686: /* These types do not support device scopes */
687:
688: goto NextSubtable;
689: }
690:
691: ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset);
692: while (ScopeOffset < Subtable->Length)
693: {
694: AcpiOsPrintf ("\n");
695: Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
696: ScopeTable->Length, AcpiDmTableInfoDmarScope);
697: if (ACPI_FAILURE (Status))
698: {
699: return;
700: }
701: AcpiOsPrintf ("\n");
702:
703: /* Dump the PCI Path entries for this device scope */
704:
705: PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
706:
707: PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
708: sizeof (ACPI_DMAR_DEVICE_SCOPE));
709:
710: while (PathOffset < ScopeTable->Length)
711: {
712: AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
713: "PCI Path");
714: AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
715:
716: /* Point to next PCI Path entry */
717:
718: PathOffset += 2;
719: PciPath += 2;
720: AcpiOsPrintf ("\n");
721: }
722:
723: /* Point to next device scope entry */
724:
725: ScopeOffset += ScopeTable->Length;
726: ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
727: ScopeTable, ScopeTable->Length);
728: }
729:
730: NextSubtable:
731: /* Point to next subtable */
732:
733: Offset += Subtable->Length;
734: Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable,
735: Subtable->Length);
736: }
737: }
738:
739:
740: /*******************************************************************************
741: *
742: * FUNCTION: AcpiDmDumpDrtm
743: *
744: * PARAMETERS: Table - A DRTM table
745: *
746: * RETURN: None
747: *
748: * DESCRIPTION: Format the contents of a DRTM.
749: *
750: ******************************************************************************/
751:
752: void
753: AcpiDmDumpDrtm (
754: ACPI_TABLE_HEADER *Table)
755: {
756: ACPI_STATUS Status;
757: UINT32 Offset;
758: ACPI_DRTM_VTABLE_LIST *DrtmVtl;
759: ACPI_DRTM_RESOURCE_LIST *DrtmRl;
760: ACPI_DRTM_DPS_ID *DrtmDps;
761: UINT32 Count;
762:
763:
764: /* Main table */
765:
766: Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
767: AcpiDmTableInfoDrtm);
768: if (ACPI_FAILURE (Status))
769: {
770: return;
771: }
772:
773: Offset = sizeof (ACPI_TABLE_DRTM);
774:
775: /* Sub-tables */
776:
777: /* Dump ValidatedTable length */
778:
779: DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
780: AcpiOsPrintf ("\n");
781: Status = AcpiDmDumpTable (Table->Length, Offset,
782: DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
783: AcpiDmTableInfoDrtm0);
784: if (ACPI_FAILURE (Status))
785: {
786: return;
787: }
788:
789: Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
790:
791: /* Dump Validated table addresses */
792:
793: Count = 0;
794: while ((Offset < Table->Length) &&
795: (DrtmVtl->ValidatedTableCount > Count))
796: {
797: Status = AcpiDmDumpTable (Table->Length, Offset,
798: ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
799: AcpiDmTableInfoDrtm0a);
800: if (ACPI_FAILURE (Status))
801: {
802: return;
803: }
804:
805: Offset += sizeof (UINT64);
806: Count++;
807: }
808:
809: /* Dump ResourceList length */
810:
811: DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
812: AcpiOsPrintf ("\n");
813: Status = AcpiDmDumpTable (Table->Length, Offset,
814: DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
815: AcpiDmTableInfoDrtm1);
816: if (ACPI_FAILURE (Status))
817: {
818: return;
819: }
820:
821: Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
822:
823: /* Dump the Resource List */
824:
825: Count = 0;
826: while ((Offset < Table->Length) &&
827: (DrtmRl->ResourceCount > Count))
828: {
829: Status = AcpiDmDumpTable (Table->Length, Offset,
830: ACPI_ADD_PTR (void, Table, Offset),
831: sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
832: if (ACPI_FAILURE (Status))
833: {
834: return;
835: }
836:
837: Offset += sizeof (ACPI_DRTM_RESOURCE);
838: Count++;
839: }
840:
841: /* Dump DPS */
842:
843: DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
844: AcpiOsPrintf ("\n");
845: (void) AcpiDmDumpTable (Table->Length, Offset,
846: DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
847: }
848:
849:
850: /*******************************************************************************
851: *
852: * FUNCTION: AcpiDmDumpEinj
853: *
854: * PARAMETERS: Table - A EINJ table
855: *
856: * RETURN: None
857: *
858: * DESCRIPTION: Format the contents of a EINJ. This table type consists
859: * of an open-ended number of subtables.
860: *
861: ******************************************************************************/
862:
863: void
864: AcpiDmDumpEinj (
865: ACPI_TABLE_HEADER *Table)
866: {
867: ACPI_STATUS Status;
868: ACPI_WHEA_HEADER *Subtable;
869: UINT32 Length = Table->Length;
870: UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
871:
872:
873: /* Main table */
874:
875: Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
876: if (ACPI_FAILURE (Status))
877: {
878: return;
879: }
880:
881: /* Subtables */
882:
883: Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
884: while (Offset < Table->Length)
885: {
886: AcpiOsPrintf ("\n");
887: Status = AcpiDmDumpTable (Length, Offset, Subtable,
888: sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
889: if (ACPI_FAILURE (Status))
890: {
891: return;
892: }
893:
894: /* Point to next subtable (each subtable is of fixed length) */
895:
896: Offset += sizeof (ACPI_WHEA_HEADER);
897: Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
898: sizeof (ACPI_WHEA_HEADER));
899: }
900: }
901:
902:
903: /*******************************************************************************
904: *
905: * FUNCTION: AcpiDmDumpErst
906: *
907: * PARAMETERS: Table - A ERST table
908: *
909: * RETURN: None
910: *
911: * DESCRIPTION: Format the contents of a ERST. This table type consists
912: * of an open-ended number of subtables.
913: *
914: ******************************************************************************/
915:
916: void
917: AcpiDmDumpErst (
918: ACPI_TABLE_HEADER *Table)
919: {
920: ACPI_STATUS Status;
921: ACPI_WHEA_HEADER *Subtable;
922: UINT32 Length = Table->Length;
923: UINT32 Offset = sizeof (ACPI_TABLE_ERST);
924:
925:
926: /* Main table */
927:
928: Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
929: if (ACPI_FAILURE (Status))
930: {
931: return;
932: }
933:
934: /* Subtables */
935:
936: Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
937: while (Offset < Table->Length)
938: {
939: AcpiOsPrintf ("\n");
940: Status = AcpiDmDumpTable (Length, Offset, Subtable,
941: sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
942: if (ACPI_FAILURE (Status))
943: {
944: return;
945: }
946:
947: /* Point to next subtable (each subtable is of fixed length) */
948:
949: Offset += sizeof (ACPI_WHEA_HEADER);
950: Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable,
951: sizeof (ACPI_WHEA_HEADER));
952: }
953: }
954:
955:
956: /*******************************************************************************
957: *
958: * FUNCTION: AcpiDmDumpFpdt
959: *
960: * PARAMETERS: Table - A FPDT table
961: *
962: * RETURN: None
963: *
964: * DESCRIPTION: Format the contents of a FPDT. This table type consists
965: * of an open-ended number of subtables.
966: *
967: ******************************************************************************/
968:
969: void
970: AcpiDmDumpFpdt (
971: ACPI_TABLE_HEADER *Table)
972: {
973: ACPI_STATUS Status;
974: ACPI_FPDT_HEADER *Subtable;
975: UINT32 Length = Table->Length;
976: UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
977: ACPI_DMTABLE_INFO *InfoTable;
978:
979:
980: /* There is no main table (other than the standard ACPI header) */
981:
982: /* Subtables */
983:
984: Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
985: while (Offset < Table->Length)
986: {
987: /* Common subtable header */
988:
989: AcpiOsPrintf ("\n");
990: Status = AcpiDmDumpTable (Length, Offset, Subtable,
991: Subtable->Length, AcpiDmTableInfoFpdtHdr);
992: if (ACPI_FAILURE (Status))
993: {
994: return;
995: }
996:
997: switch (Subtable->Type)
998: {
999: case ACPI_FPDT_TYPE_BOOT:
1000:
1001: InfoTable = AcpiDmTableInfoFpdt0;
1002: break;
1003:
1004: case ACPI_FPDT_TYPE_S3PERF:
1005:
1006: InfoTable = AcpiDmTableInfoFpdt1;
1007: break;
1008:
1009: default:
1010:
1011: AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
1012: Subtable->Type);
1013:
1014: /* Attempt to continue */
1015:
1016: if (!Subtable->Length)
1017: {
1018: AcpiOsPrintf ("Invalid zero length subtable\n");
1019: return;
1020: }
1021: goto NextSubtable;
1022: }
1023:
1024: Status = AcpiDmDumpTable (Length, Offset, Subtable,
1025: Subtable->Length, InfoTable);
1026: if (ACPI_FAILURE (Status))
1027: {
1028: return;
1029: }
1030:
1031: NextSubtable:
1032: /* Point to next subtable */
1033:
1034: Offset += Subtable->Length;
1035: Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable,
1036: Subtable->Length);
1037: }
1038: }
1039:
1040:
1041: /*******************************************************************************
1042: *
1043: * FUNCTION: AcpiDmDumpGtdt
1044: *
1045: * PARAMETERS: Table - A GTDT table
1046: *
1047: * RETURN: None
1048: *
1049: * DESCRIPTION: Format the contents of a GTDT. This table type consists
1050: * of an open-ended number of subtables.
1051: *
1052: ******************************************************************************/
1053:
1054: void
1055: AcpiDmDumpGtdt (
1056: ACPI_TABLE_HEADER *Table)
1057: {
1058: ACPI_STATUS Status;
1059: ACPI_GTDT_HEADER *Subtable;
1060: UINT32 Length = Table->Length;
1061: UINT32 Offset = sizeof (ACPI_TABLE_GTDT);
1062: ACPI_DMTABLE_INFO *InfoTable;
1063: UINT32 SubtableLength;
1064: UINT32 GtCount;
1065: ACPI_GTDT_TIMER_ENTRY *GtxTable;
1066:
1067:
1068: /* Main table */
1069:
1070: Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
1071: if (ACPI_FAILURE (Status))
1072: {
1073: return;
1074: }
1075:
1.1.1.2 christos 1076: /* Rev 3 fields */
1.1 christos 1077:
1078: Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1.1.1.2 christos 1079:
1080: if (Table->Revision > 2)
1081: {
1082: SubtableLength = sizeof (ACPI_GTDT_EL2);
1083: Status = AcpiDmDumpTable (Length, Offset, Subtable,
1084: SubtableLength, AcpiDmTableInfoGtdtEl2);
1085: if (ACPI_FAILURE (Status))
1086: {
1087: return;
1088: }
1089: Offset += SubtableLength;
1090: }
1091:
1092: Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1093:
1094: /* Subtables */
1095:
1.1 christos 1096: while (Offset < Table->Length)
1097: {
1098: /* Common subtable header */
1099:
1100: AcpiOsPrintf ("\n");
1101: Status = AcpiDmDumpTable (Length, Offset, Subtable,
1102: Subtable->Length, AcpiDmTableInfoGtdtHdr);
1103: if (ACPI_FAILURE (Status))
1104: {
1105: return;
1106: }
1107:
1108: GtCount = 0;
1109: switch (Subtable->Type)
1110: {
1111: case ACPI_GTDT_TYPE_TIMER_BLOCK:
1112:
1113: SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
1114: GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1115: Subtable))->TimerCount;
1116:
1117: InfoTable = AcpiDmTableInfoGtdt0;
1118: break;
1119:
1120: case ACPI_GTDT_TYPE_WATCHDOG:
1121:
1122: SubtableLength = sizeof (ACPI_GTDT_WATCHDOG);
1123:
1124: InfoTable = AcpiDmTableInfoGtdt1;
1125: break;
1126:
1127: default:
1128:
1129: /* Cannot continue on unknown type - no length */
1130:
1131: AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
1132: Subtable->Type);
1133: return;
1134: }
1135:
1136: Status = AcpiDmDumpTable (Length, Offset, Subtable,
1137: Subtable->Length, InfoTable);
1138: if (ACPI_FAILURE (Status))
1139: {
1140: return;
1141: }
1142:
1143: /* Point to end of current subtable (each subtable above is of fixed length) */
1144:
1145: Offset += SubtableLength;
1146:
1147: /* If there are any Gt Timer Blocks from above, dump them now */
1148:
1149: if (GtCount)
1150: {
1151: GtxTable = ACPI_ADD_PTR (
1152: ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength);
1153: SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
1154:
1155: while (GtCount)
1156: {
1157: AcpiOsPrintf ("\n");
1158: Status = AcpiDmDumpTable (Length, Offset, GtxTable,
1159: sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
1160: if (ACPI_FAILURE (Status))
1161: {
1162: return;
1163: }
1164: Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
1165: GtxTable++;
1166: GtCount--;
1167: }
1168: }
1169:
1170: /* Point to next subtable */
1171:
1172: Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength);
1173: }
1174: }
1175:
1176:
1177: /*******************************************************************************
1178: *
1179: * FUNCTION: AcpiDmDumpHest
1180: *
1181: * PARAMETERS: Table - A HEST table
1182: *
1183: * RETURN: None
1184: *
1185: * DESCRIPTION: Format the contents of a HEST. This table type consists
1186: * of an open-ended number of subtables.
1187: *
1188: ******************************************************************************/
1189:
1190: void
1191: AcpiDmDumpHest (
1192: ACPI_TABLE_HEADER *Table)
1193: {
1194: ACPI_STATUS Status;
1195: ACPI_HEST_HEADER *Subtable;
1196: UINT32 Length = Table->Length;
1197: UINT32 Offset = sizeof (ACPI_TABLE_HEST);
1198: ACPI_DMTABLE_INFO *InfoTable;
1199: UINT32 SubtableLength;
1200: UINT32 BankCount;
1201: ACPI_HEST_IA_ERROR_BANK *BankTable;
1202:
1203:
1204: /* Main table */
1205:
1206: Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1207: if (ACPI_FAILURE (Status))
1208: {
1209: return;
1210: }
1211:
1212: /* Subtables */
1213:
1214: Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1215: while (Offset < Table->Length)
1216: {
1217: BankCount = 0;
1218: switch (Subtable->Type)
1219: {
1220: case ACPI_HEST_TYPE_IA32_CHECK:
1221:
1222: InfoTable = AcpiDmTableInfoHest0;
1223: SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1224: BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1225: Subtable))->NumHardwareBanks;
1226: break;
1227:
1228: case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1229:
1230: InfoTable = AcpiDmTableInfoHest1;
1231: SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1232: BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1233: Subtable))->NumHardwareBanks;
1234: break;
1235:
1236: case ACPI_HEST_TYPE_IA32_NMI:
1237:
1238: InfoTable = AcpiDmTableInfoHest2;
1239: SubtableLength = sizeof (ACPI_HEST_IA_NMI);
1240: break;
1241:
1242: case ACPI_HEST_TYPE_AER_ROOT_PORT:
1243:
1244: InfoTable = AcpiDmTableInfoHest6;
1245: SubtableLength = sizeof (ACPI_HEST_AER_ROOT);
1246: break;
1247:
1248: case ACPI_HEST_TYPE_AER_ENDPOINT:
1249:
1250: InfoTable = AcpiDmTableInfoHest7;
1251: SubtableLength = sizeof (ACPI_HEST_AER);
1252: break;
1253:
1254: case ACPI_HEST_TYPE_AER_BRIDGE:
1255:
1256: InfoTable = AcpiDmTableInfoHest8;
1257: SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1258: break;
1259:
1260: case ACPI_HEST_TYPE_GENERIC_ERROR:
1261:
1262: InfoTable = AcpiDmTableInfoHest9;
1263: SubtableLength = sizeof (ACPI_HEST_GENERIC);
1264: break;
1265:
1266: case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
1267:
1268: InfoTable = AcpiDmTableInfoHest10;
1269: SubtableLength = sizeof (ACPI_HEST_GENERIC_V2);
1270: break;
1271:
1272: case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1273:
1274: InfoTable = AcpiDmTableInfoHest11;
1275: SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK);
1276: BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
1277: Subtable))->NumHardwareBanks;
1278: break;
1279:
1280: default:
1281:
1282: /* Cannot continue on unknown type - no length */
1283:
1284: AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
1285: Subtable->Type);
1286: return;
1287: }
1288:
1289: AcpiOsPrintf ("\n");
1290: Status = AcpiDmDumpTable (Length, Offset, Subtable,
1291: SubtableLength, InfoTable);
1292: if (ACPI_FAILURE (Status))
1293: {
1294: return;
1295: }
1296:
1297: /* Point to end of current subtable (each subtable above is of fixed length) */
1298:
1299: Offset += SubtableLength;
1300:
1301: /* If there are any (fixed-length) Error Banks from above, dump them now */
1302:
1303: if (BankCount)
1304: {
1305: BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable,
1306: SubtableLength);
1307: SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1308:
1309: while (BankCount)
1310: {
1311: AcpiOsPrintf ("\n");
1312: Status = AcpiDmDumpTable (Length, Offset, BankTable,
1313: sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1314: if (ACPI_FAILURE (Status))
1315: {
1316: return;
1317: }
1318:
1319: Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1320: BankTable++;
1321: BankCount--;
1322: }
1323: }
1324:
1325: /* Point to next subtable */
1326:
1327: Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength);
1328: }
1329: }
1330:
1331:
1332: /*******************************************************************************
1333: *
1334: * FUNCTION: AcpiDmDumpHmat
1335: *
1336: * PARAMETERS: Table - A HMAT table
1337: *
1338: * RETURN: None
1339: *
1340: * DESCRIPTION: Format the contents of a HMAT.
1341: *
1342: ******************************************************************************/
1343:
1344: void
1345: AcpiDmDumpHmat (
1346: ACPI_TABLE_HEADER *Table)
1347: {
1348: ACPI_STATUS Status;
1349: ACPI_HMAT_STRUCTURE *HmatStruct;
1350: ACPI_HMAT_LOCALITY *HmatLocality;
1351: ACPI_HMAT_CACHE *HmatCache;
1352: UINT32 Offset;
1353: UINT32 SubtableOffset;
1354: UINT32 Length;
1355: ACPI_DMTABLE_INFO *InfoTable;
1356: UINT32 i, j;
1357:
1358:
1359: /* Main table */
1360:
1361: Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat);
1362: if (ACPI_FAILURE (Status))
1363: {
1364: return;
1365: }
1366: Offset = sizeof (ACPI_TABLE_HMAT);
1367:
1368: while (Offset < Table->Length)
1369: {
1370: AcpiOsPrintf ("\n");
1371:
1372: /* Dump HMAT structure header */
1373:
1374: HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset);
1375: if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE))
1376: {
1377: AcpiOsPrintf ("Invalid HMAT structure length\n");
1378: return;
1379: }
1380: Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1381: HmatStruct->Length, AcpiDmTableInfoHmatHdr);
1382: if (ACPI_FAILURE (Status))
1383: {
1384: return;
1385: }
1386:
1387: switch (HmatStruct->Type)
1388: {
1389: case ACPI_HMAT_TYPE_ADDRESS_RANGE:
1390:
1391: InfoTable = AcpiDmTableInfoHmat0;
1.1.1.2 christos 1392: Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN);
1.1 christos 1393: break;
1394:
1395: case ACPI_HMAT_TYPE_LOCALITY:
1396:
1397: InfoTable = AcpiDmTableInfoHmat1;
1398: Length = sizeof (ACPI_HMAT_LOCALITY);
1399: break;
1400:
1401: case ACPI_HMAT_TYPE_CACHE:
1402:
1403: InfoTable = AcpiDmTableInfoHmat2;
1404: Length = sizeof (ACPI_HMAT_CACHE);
1405: break;
1406:
1407: default:
1408:
1409: AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n",
1410: HmatStruct->Type);
1411:
1412: /* Attempt to continue */
1413:
1414: goto NextSubtable;
1415: }
1416:
1417: /* Dump HMAT structure body */
1418:
1419: if (HmatStruct->Length < Length)
1420: {
1421: AcpiOsPrintf ("Invalid HMAT structure length\n");
1422: return;
1423: }
1424: Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1425: HmatStruct->Length, InfoTable);
1426: if (ACPI_FAILURE (Status))
1427: {
1428: return;
1429: }
1430:
1431: /* Dump HMAT structure additionals */
1432:
1433: switch (HmatStruct->Type)
1434: {
1435: case ACPI_HMAT_TYPE_LOCALITY:
1436:
1437: HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct);
1438: SubtableOffset = sizeof (ACPI_HMAT_LOCALITY);
1439:
1440: /* Dump initiator proximity domains */
1441:
1442: if ((UINT32)(HmatStruct->Length - SubtableOffset) <
1443: (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4))
1444: {
1445: AcpiOsPrintf ("Invalid initiator proximity domain number\n");
1446: return;
1447: }
1448: for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1449: {
1450: Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1451: ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
1452: 4, AcpiDmTableInfoHmat1a);
1.1.1.3 christos 1453: if (ACPI_FAILURE (Status))
1454: {
1455: return;
1456: }
1457:
1.1 christos 1458: SubtableOffset += 4;
1459: }
1460:
1461: /* Dump target proximity domains */
1462:
1463: if ((UINT32)(HmatStruct->Length - SubtableOffset) <
1464: (UINT32)(HmatLocality->NumberOfTargetPDs * 4))
1465: {
1466: AcpiOsPrintf ("Invalid target proximity domain number\n");
1467: return;
1468: }
1469: for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++)
1470: {
1471: Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1472: ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
1473: 4, AcpiDmTableInfoHmat1b);
1.1.1.3 christos 1474: if (ACPI_FAILURE (Status))
1475: {
1476: return;
1477: }
1478:
1.1 christos 1479: SubtableOffset += 4;
1480: }
1481:
1482: /* Dump latency/bandwidth entris */
1483:
1484: if ((UINT32)(HmatStruct->Length - SubtableOffset) <
1485: (UINT32)(HmatLocality->NumberOfInitiatorPDs *
1486: HmatLocality->NumberOfTargetPDs * 2))
1487: {
1488: AcpiOsPrintf ("Invalid latency/bandwidth entry number\n");
1489: return;
1490: }
1491: for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1492: {
1493: for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++)
1494: {
1495: Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1496: ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
1497: 2, AcpiDmTableInfoHmat1c);
1.1.1.3 christos 1498: if (ACPI_FAILURE(Status))
1499: {
1500: return;
1501: }
1502:
1.1 christos 1503: SubtableOffset += 2;
1504: }
1505: }
1506: break;
1507:
1508: case ACPI_HMAT_TYPE_CACHE:
1509:
1510: HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct);
1511: SubtableOffset = sizeof (ACPI_HMAT_CACHE);
1512:
1513: /* Dump SMBIOS handles */
1514:
1515: if ((UINT32)(HmatStruct->Length - SubtableOffset) <
1516: (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2))
1517: {
1518: AcpiOsPrintf ("Invalid SMBIOS handle number\n");
1519: return;
1520: }
1521: for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++)
1522: {
1523: Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1524: ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset),
1525: 2, AcpiDmTableInfoHmat2a);
1.1.1.3 christos 1526: if (ACPI_FAILURE (Status))
1527: {
1528: return;
1529: }
1530:
1.1 christos 1531: SubtableOffset += 2;
1532: }
1533: break;
1534:
1535: default:
1536:
1537: break;
1538: }
1539:
1540: NextSubtable:
1541: /* Point to next HMAT structure subtable */
1542:
1543: Offset += (HmatStruct->Length);
1544: }
1545: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to dmtbdump1.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / external / bsd / acpica / dist / common