1 /******************************************************************************
3 * Module Name: dttable2.c - handling for specific ACPI tables
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2019, Intel Corp.
12 * All rights reserved.
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
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
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;
37 * The above copyright and patent license is granted only if the following
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.
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
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
72 * 3.4. Intel retains all right, title, and interest in and to the Original
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.
80 * 4. Disclaimer and Export Compliance
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
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
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.
114 *****************************************************************************
116 * Alternatively, you may choose to be licensed under the terms of the
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
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.
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.
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.
150 *****************************************************************************/
152 /* Compile all complex data tables, signatures starting with L-Z */
154 #include <contrib/dev/acpica/compiler/aslcompiler.h>
156 #define _COMPONENT DT_COMPILER
157 ACPI_MODULE_NAME ("dttable2")
160 /******************************************************************************
162 * FUNCTION: DtCompileLpit
164 * PARAMETERS: List - Current field list pointer
168 * DESCRIPTION: Compile LPIT.
170 *****************************************************************************/
177 DT_SUBTABLE *Subtable;
178 DT_SUBTABLE *ParentTable;
179 DT_FIELD **PFieldList = (DT_FIELD **) List;
180 DT_FIELD *SubtableStart;
181 ACPI_DMTABLE_INFO *InfoTable;
182 ACPI_LPIT_HEADER *LpitHeader;
185 /* Note: Main table consists only of the standard ACPI table header */
189 SubtableStart = *PFieldList;
191 /* LPIT Subtable header */
193 Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr,
195 if (ACPI_FAILURE (Status))
200 ParentTable = DtPeekSubtable ();
201 DtInsertSubtable (ParentTable, Subtable);
202 DtPushSubtable (Subtable);
204 LpitHeader = ACPI_CAST_PTR (ACPI_LPIT_HEADER, Subtable->Buffer);
206 switch (LpitHeader->Type)
208 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
210 InfoTable = AcpiDmTableInfoLpit0;
215 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "LPIT");
221 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
222 if (ACPI_FAILURE (Status))
227 ParentTable = DtPeekSubtable ();
228 DtInsertSubtable (ParentTable, Subtable);
236 /******************************************************************************
238 * FUNCTION: DtCompileMadt
240 * PARAMETERS: List - Current field list pointer
244 * DESCRIPTION: Compile MADT.
246 *****************************************************************************/
253 DT_SUBTABLE *Subtable;
254 DT_SUBTABLE *ParentTable;
255 DT_FIELD **PFieldList = (DT_FIELD **) List;
256 DT_FIELD *SubtableStart;
257 ACPI_SUBTABLE_HEADER *MadtHeader;
258 ACPI_DMTABLE_INFO *InfoTable;
261 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt,
263 if (ACPI_FAILURE (Status))
268 ParentTable = DtPeekSubtable ();
269 DtInsertSubtable (ParentTable, Subtable);
273 SubtableStart = *PFieldList;
274 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr,
276 if (ACPI_FAILURE (Status))
281 ParentTable = DtPeekSubtable ();
282 DtInsertSubtable (ParentTable, Subtable);
283 DtPushSubtable (Subtable);
285 MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
287 switch (MadtHeader->Type)
289 case ACPI_MADT_TYPE_LOCAL_APIC:
291 InfoTable = AcpiDmTableInfoMadt0;
294 case ACPI_MADT_TYPE_IO_APIC:
296 InfoTable = AcpiDmTableInfoMadt1;
299 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
301 InfoTable = AcpiDmTableInfoMadt2;
304 case ACPI_MADT_TYPE_NMI_SOURCE:
306 InfoTable = AcpiDmTableInfoMadt3;
309 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
311 InfoTable = AcpiDmTableInfoMadt4;
314 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
316 InfoTable = AcpiDmTableInfoMadt5;
319 case ACPI_MADT_TYPE_IO_SAPIC:
321 InfoTable = AcpiDmTableInfoMadt6;
324 case ACPI_MADT_TYPE_LOCAL_SAPIC:
326 InfoTable = AcpiDmTableInfoMadt7;
329 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
331 InfoTable = AcpiDmTableInfoMadt8;
334 case ACPI_MADT_TYPE_LOCAL_X2APIC:
336 InfoTable = AcpiDmTableInfoMadt9;
339 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
341 InfoTable = AcpiDmTableInfoMadt10;
344 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
346 InfoTable = AcpiDmTableInfoMadt11;
349 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
351 InfoTable = AcpiDmTableInfoMadt12;
354 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
356 InfoTable = AcpiDmTableInfoMadt13;
359 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
361 InfoTable = AcpiDmTableInfoMadt14;
364 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
366 InfoTable = AcpiDmTableInfoMadt15;
371 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT");
375 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
376 if (ACPI_FAILURE (Status))
381 ParentTable = DtPeekSubtable ();
382 DtInsertSubtable (ParentTable, Subtable);
390 /******************************************************************************
392 * FUNCTION: DtCompileMcfg
394 * PARAMETERS: List - Current field list pointer
398 * DESCRIPTION: Compile MCFG.
400 *****************************************************************************/
409 Status = DtCompileTwoSubtables (List,
410 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0);
415 /******************************************************************************
417 * FUNCTION: DtCompileMpst
419 * PARAMETERS: List - Current field list pointer
423 * DESCRIPTION: Compile MPST.
425 *****************************************************************************/
432 DT_SUBTABLE *Subtable;
433 DT_SUBTABLE *ParentTable;
434 DT_FIELD **PFieldList = (DT_FIELD **) List;
435 ACPI_MPST_CHANNEL *MpstChannelInfo;
436 ACPI_MPST_POWER_NODE *MpstPowerNode;
437 ACPI_MPST_DATA_HDR *MpstDataHeader;
438 UINT16 SubtableCount;
439 UINT32 PowerStateCount;
440 UINT32 ComponentCount;
445 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable);
446 if (ACPI_FAILURE (Status))
451 ParentTable = DtPeekSubtable ();
452 DtInsertSubtable (ParentTable, Subtable);
453 DtPushSubtable (Subtable);
455 MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer);
456 SubtableCount = MpstChannelInfo->PowerNodeCount;
458 while (*PFieldList && SubtableCount)
460 /* Subtable: Memory Power Node(s) */
462 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0,
464 if (ACPI_FAILURE (Status))
469 ParentTable = DtPeekSubtable ();
470 DtInsertSubtable (ParentTable, Subtable);
471 DtPushSubtable (Subtable);
473 MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer);
474 PowerStateCount = MpstPowerNode->NumPowerStates;
475 ComponentCount = MpstPowerNode->NumPhysicalComponents;
477 ParentTable = DtPeekSubtable ();
479 /* Sub-subtables - Memory Power State Structure(s) */
481 while (*PFieldList && PowerStateCount)
483 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A,
485 if (ACPI_FAILURE (Status))
490 DtInsertSubtable (ParentTable, Subtable);
494 /* Sub-subtables - Physical Component ID Structure(s) */
496 while (*PFieldList && ComponentCount)
498 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B,
500 if (ACPI_FAILURE (Status))
505 DtInsertSubtable (ParentTable, Subtable);
513 /* Subtable: Count of Memory Power State Characteristic structures */
517 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable);
518 if (ACPI_FAILURE (Status))
523 ParentTable = DtPeekSubtable ();
524 DtInsertSubtable (ParentTable, Subtable);
525 DtPushSubtable (Subtable);
527 MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer);
528 SubtableCount = MpstDataHeader->CharacteristicsCount;
530 ParentTable = DtPeekSubtable ();
532 /* Subtable: Memory Power State Characteristics structure(s) */
534 while (*PFieldList && SubtableCount)
536 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2,
538 if (ACPI_FAILURE (Status))
543 DtInsertSubtable (ParentTable, Subtable);
552 /******************************************************************************
554 * FUNCTION: DtCompileMsct
556 * PARAMETERS: List - Current field list pointer
560 * DESCRIPTION: Compile MSCT.
562 *****************************************************************************/
571 Status = DtCompileTwoSubtables (List,
572 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0);
577 /******************************************************************************
579 * FUNCTION: DtCompileMtmr
581 * PARAMETERS: List - Current field list pointer
585 * DESCRIPTION: Compile MTMR.
587 *****************************************************************************/
596 Status = DtCompileTwoSubtables (List,
597 AcpiDmTableInfoMtmr, AcpiDmTableInfoMtmr0);
602 /******************************************************************************
604 * FUNCTION: DtCompileNfit
606 * PARAMETERS: List - Current field list pointer
610 * DESCRIPTION: Compile NFIT.
612 *****************************************************************************/
619 DT_SUBTABLE *Subtable;
620 DT_SUBTABLE *ParentTable;
621 DT_FIELD **PFieldList = (DT_FIELD **) List;
622 DT_FIELD *SubtableStart;
623 ACPI_NFIT_HEADER *NfitHeader;
624 ACPI_DMTABLE_INFO *InfoTable;
626 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
627 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
632 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit,
634 if (ACPI_FAILURE (Status))
639 ParentTable = DtPeekSubtable ();
640 DtInsertSubtable (ParentTable, Subtable);
641 DtPushSubtable (Subtable);
647 SubtableStart = *PFieldList;
648 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr,
650 if (ACPI_FAILURE (Status))
655 ParentTable = DtPeekSubtable ();
656 DtInsertSubtable (ParentTable, Subtable);
657 DtPushSubtable (Subtable);
659 NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer);
661 switch (NfitHeader->Type)
663 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
665 InfoTable = AcpiDmTableInfoNfit0;
668 case ACPI_NFIT_TYPE_MEMORY_MAP:
670 InfoTable = AcpiDmTableInfoNfit1;
673 case ACPI_NFIT_TYPE_INTERLEAVE:
675 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer);
676 InfoTable = AcpiDmTableInfoNfit2;
679 case ACPI_NFIT_TYPE_SMBIOS:
681 InfoTable = AcpiDmTableInfoNfit3;
684 case ACPI_NFIT_TYPE_CONTROL_REGION:
686 InfoTable = AcpiDmTableInfoNfit4;
689 case ACPI_NFIT_TYPE_DATA_REGION:
691 InfoTable = AcpiDmTableInfoNfit5;
694 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
696 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer);
697 InfoTable = AcpiDmTableInfoNfit6;
700 case ACPI_NFIT_TYPE_CAPABILITIES:
702 InfoTable = AcpiDmTableInfoNfit7;
707 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT");
711 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
712 if (ACPI_FAILURE (Status))
717 ParentTable = DtPeekSubtable ();
718 DtInsertSubtable (ParentTable, Subtable);
721 switch (NfitHeader->Type)
723 case ACPI_NFIT_TYPE_INTERLEAVE:
726 DtPushSubtable (Subtable);
729 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a,
731 if (ACPI_FAILURE (Status))
742 ParentTable = DtPeekSubtable ();
743 DtInsertSubtable (ParentTable, Subtable);
747 Interleave->LineCount = Count;
750 case ACPI_NFIT_TYPE_SMBIOS:
754 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a,
756 if (ACPI_FAILURE (Status))
763 DtInsertSubtable (ParentTable, Subtable);
768 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
771 DtPushSubtable (Subtable);
774 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a,
776 if (ACPI_FAILURE (Status))
787 ParentTable = DtPeekSubtable ();
788 DtInsertSubtable (ParentTable, Subtable);
792 Hint->HintCount = (UINT16) Count;
804 /******************************************************************************
806 * FUNCTION: DtCompilePcct
808 * PARAMETERS: List - Current field list pointer
812 * DESCRIPTION: Compile PCCT.
814 *****************************************************************************/
821 DT_SUBTABLE *Subtable;
822 DT_SUBTABLE *ParentTable;
823 DT_FIELD **PFieldList = (DT_FIELD **) List;
824 DT_FIELD *SubtableStart;
825 ACPI_SUBTABLE_HEADER *PcctHeader;
826 ACPI_DMTABLE_INFO *InfoTable;
831 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct,
833 if (ACPI_FAILURE (Status))
838 ParentTable = DtPeekSubtable ();
839 DtInsertSubtable (ParentTable, Subtable);
845 SubtableStart = *PFieldList;
846 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr,
848 if (ACPI_FAILURE (Status))
853 ParentTable = DtPeekSubtable ();
854 DtInsertSubtable (ParentTable, Subtable);
855 DtPushSubtable (Subtable);
857 PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
859 switch (PcctHeader->Type)
861 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
863 InfoTable = AcpiDmTableInfoPcct0;
866 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
868 InfoTable = AcpiDmTableInfoPcct1;
871 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
873 InfoTable = AcpiDmTableInfoPcct2;
876 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
878 InfoTable = AcpiDmTableInfoPcct3;
881 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
883 InfoTable = AcpiDmTableInfoPcct4;
888 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT");
892 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
893 if (ACPI_FAILURE (Status))
898 ParentTable = DtPeekSubtable ();
899 DtInsertSubtable (ParentTable, Subtable);
907 /******************************************************************************
909 * FUNCTION: DtCompilePdtt
911 * PARAMETERS: List - Current field list pointer
915 * DESCRIPTION: Compile PDTT.
917 *****************************************************************************/
924 DT_SUBTABLE *Subtable;
925 DT_SUBTABLE *ParentTable;
926 DT_FIELD **PFieldList = (DT_FIELD **) List;
927 ACPI_TABLE_PDTT *PdttHeader;
933 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt, &Subtable);
934 if (ACPI_FAILURE (Status))
939 ParentTable = DtPeekSubtable ();
940 DtInsertSubtable (ParentTable, Subtable);
942 PdttHeader = ACPI_CAST_PTR (ACPI_TABLE_PDTT, ParentTable->Buffer);
943 PdttHeader->ArrayOffset = sizeof (ACPI_TABLE_PDTT);
945 /* There is only one type of subtable at this time, no need to decode */
949 /* List of subchannel IDs, each 2 bytes */
951 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt0,
953 if (ACPI_FAILURE (Status))
958 DtInsertSubtable (ParentTable, Subtable);
962 PdttHeader->TriggerCount = (UINT8) Count;
967 /******************************************************************************
969 * FUNCTION: DtCompilePmtt
971 * PARAMETERS: List - Current field list pointer
975 * DESCRIPTION: Compile PMTT.
977 *****************************************************************************/
984 DT_SUBTABLE *Subtable;
985 DT_SUBTABLE *ParentTable;
986 DT_FIELD **PFieldList = (DT_FIELD **) List;
987 DT_FIELD *SubtableStart;
988 ACPI_PMTT_HEADER *PmttHeader;
989 ACPI_PMTT_CONTROLLER *PmttController;
991 UINT8 PrevType = ACPI_PMTT_TYPE_SOCKET;
996 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable);
997 if (ACPI_FAILURE (Status))
1002 ParentTable = DtPeekSubtable ();
1003 DtInsertSubtable (ParentTable, Subtable);
1004 DtPushSubtable (Subtable);
1008 SubtableStart = *PFieldList;
1009 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr,
1011 if (ACPI_FAILURE (Status))
1016 PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer);
1017 while (PrevType >= PmttHeader->Type)
1021 if (PrevType == ACPI_PMTT_TYPE_SOCKET)
1029 PrevType = PmttHeader->Type;
1031 ParentTable = DtPeekSubtable ();
1032 DtInsertSubtable (ParentTable, Subtable);
1033 DtPushSubtable (Subtable);
1035 switch (PmttHeader->Type)
1037 case ACPI_PMTT_TYPE_SOCKET:
1039 /* Subtable: Socket Structure */
1041 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0,
1043 if (ACPI_FAILURE (Status))
1048 ParentTable = DtPeekSubtable ();
1049 DtInsertSubtable (ParentTable, Subtable);
1052 case ACPI_PMTT_TYPE_CONTROLLER:
1054 /* Subtable: Memory Controller Structure */
1056 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1,
1058 if (ACPI_FAILURE (Status))
1063 ParentTable = DtPeekSubtable ();
1064 DtInsertSubtable (ParentTable, Subtable);
1066 PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER,
1067 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER)));
1068 DomainCount = PmttController->DomainCount;
1072 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a,
1074 if (ACPI_FAILURE (Status))
1079 DtInsertSubtable (ParentTable, Subtable);
1084 case ACPI_PMTT_TYPE_DIMM:
1086 /* Subtable: Physical Component Structure */
1088 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2,
1090 if (ACPI_FAILURE (Status))
1095 ParentTable = DtPeekSubtable ();
1096 DtInsertSubtable (ParentTable, Subtable);
1101 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT");
1110 /******************************************************************************
1112 * FUNCTION: DtCompilePptt
1114 * PARAMETERS: List - Current field list pointer
1118 * DESCRIPTION: Compile PPTT.
1120 *****************************************************************************/
1127 ACPI_SUBTABLE_HEADER *PpttHeader;
1128 ACPI_PPTT_PROCESSOR *PpttProcessor = NULL;
1129 DT_SUBTABLE *Subtable;
1130 DT_SUBTABLE *ParentTable;
1131 ACPI_DMTABLE_INFO *InfoTable;
1132 DT_FIELD **PFieldList = (DT_FIELD **) List;
1133 DT_FIELD *SubtableStart;
1136 ParentTable = DtPeekSubtable ();
1139 SubtableStart = *PFieldList;
1141 /* Compile PPTT subtable header */
1143 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPpttHdr,
1145 if (ACPI_FAILURE (Status))
1149 DtInsertSubtable (ParentTable, Subtable);
1150 PpttHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1151 PpttHeader->Length = (UINT8)(Subtable->Length);
1153 switch (PpttHeader->Type)
1155 case ACPI_PPTT_TYPE_PROCESSOR:
1157 InfoTable = AcpiDmTableInfoPptt0;
1160 case ACPI_PPTT_TYPE_CACHE:
1162 InfoTable = AcpiDmTableInfoPptt1;
1165 case ACPI_PPTT_TYPE_ID:
1167 InfoTable = AcpiDmTableInfoPptt2;
1172 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PPTT");
1176 /* Compile PPTT subtable body */
1178 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1179 if (ACPI_FAILURE (Status))
1183 DtInsertSubtable (ParentTable, Subtable);
1184 PpttHeader->Length += (UINT8)(Subtable->Length);
1186 /* Compile PPTT subtable additionals */
1188 switch (PpttHeader->Type)
1190 case ACPI_PPTT_TYPE_PROCESSOR:
1192 PpttProcessor = ACPI_SUB_PTR (ACPI_PPTT_PROCESSOR,
1193 Subtable->Buffer, sizeof (ACPI_SUBTABLE_HEADER));
1196 /* Compile initiator proximity domain list */
1198 PpttProcessor->NumberOfPrivResources = 0;
1201 Status = DtCompileTable (PFieldList,
1202 AcpiDmTableInfoPptt0a, &Subtable);
1203 if (ACPI_FAILURE (Status))
1212 DtInsertSubtable (ParentTable, Subtable);
1213 PpttHeader->Length += (UINT8)(Subtable->Length);
1214 PpttProcessor->NumberOfPrivResources++;
1229 /******************************************************************************
1231 * FUNCTION: DtCompileRsdt
1233 * PARAMETERS: List - Current field list pointer
1237 * DESCRIPTION: Compile RSDT.
1239 *****************************************************************************/
1245 DT_SUBTABLE *Subtable;
1246 DT_SUBTABLE *ParentTable;
1247 DT_FIELD *FieldList = *(DT_FIELD **) List;
1251 ParentTable = DtPeekSubtable ();
1255 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO);
1257 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable);
1258 DtInsertSubtable (ParentTable, Subtable);
1259 FieldList = FieldList->Next;
1266 /******************************************************************************
1268 * FUNCTION: DtCompileS3pt
1270 * PARAMETERS: PFieldList - Current field list pointer
1274 * DESCRIPTION: Compile S3PT (Pointed to by FPDT)
1276 *****************************************************************************/
1280 DT_FIELD **PFieldList)
1283 ACPI_FPDT_HEADER *S3ptHeader;
1284 DT_SUBTABLE *Subtable;
1285 DT_SUBTABLE *ParentTable;
1286 ACPI_DMTABLE_INFO *InfoTable;
1287 DT_FIELD *SubtableStart;
1290 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
1292 if (ACPI_FAILURE (Status))
1297 DtPushSubtable (AslGbl_RootTable);
1301 SubtableStart = *PFieldList;
1302 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr,
1304 if (ACPI_FAILURE (Status))
1309 ParentTable = DtPeekSubtable ();
1310 DtInsertSubtable (ParentTable, Subtable);
1311 DtPushSubtable (Subtable);
1313 S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
1315 switch (S3ptHeader->Type)
1317 case ACPI_S3PT_TYPE_RESUME:
1319 InfoTable = AcpiDmTableInfoS3pt0;
1322 case ACPI_S3PT_TYPE_SUSPEND:
1324 InfoTable = AcpiDmTableInfoS3pt1;
1329 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT");
1333 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1334 if (ACPI_FAILURE (Status))
1339 ParentTable = DtPeekSubtable ();
1340 DtInsertSubtable (ParentTable, Subtable);
1348 /******************************************************************************
1350 * FUNCTION: DtCompileSdev
1352 * PARAMETERS: List - Current field list pointer
1356 * DESCRIPTION: Compile SDEV.
1358 *****************************************************************************/
1365 ACPI_SDEV_HEADER *SdevHeader;
1366 DT_SUBTABLE *Subtable;
1367 DT_SUBTABLE *ParentTable;
1368 ACPI_DMTABLE_INFO *InfoTable;
1369 DT_FIELD **PFieldList = (DT_FIELD **) List;
1370 DT_FIELD *SubtableStart;
1371 ACPI_SDEV_PCIE *Pcie = NULL;
1372 ACPI_SDEV_NAMESPACE *Namesp = NULL;
1380 /* Compile common SDEV subtable header */
1382 SubtableStart = *PFieldList;
1383 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdevHdr,
1385 if (ACPI_FAILURE (Status))
1390 ParentTable = DtPeekSubtable ();
1391 DtInsertSubtable (ParentTable, Subtable);
1392 DtPushSubtable (Subtable);
1394 SdevHeader = ACPI_CAST_PTR (ACPI_SDEV_HEADER, Subtable->Buffer);
1395 SdevHeader->Length = (UINT8)(sizeof (ACPI_SDEV_HEADER));
1397 switch (SdevHeader->Type)
1399 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1401 InfoTable = AcpiDmTableInfoSdev0;
1402 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable->Buffer);
1405 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
1407 InfoTable = AcpiDmTableInfoSdev1;
1408 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable->Buffer);
1413 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV");
1417 /* Compile SDEV subtable body */
1419 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1420 if (ACPI_FAILURE (Status))
1425 ParentTable = DtPeekSubtable ();
1426 DtInsertSubtable (ParentTable, Subtable);
1428 /* Optional data fields are appended to the main subtable body */
1430 switch (SdevHeader->Type)
1432 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1434 /* Append DeviceId namespace string */
1436 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev0a,
1438 if (ACPI_FAILURE (Status))
1448 ParentTable = DtPeekSubtable ();
1449 DtInsertSubtable (ParentTable, Subtable);
1451 Namesp->DeviceIdOffset = sizeof (ACPI_SDEV_NAMESPACE);
1452 Namesp->DeviceIdLength = (UINT16) Subtable->Length;
1454 /* Append Vendor data */
1456 Namesp->VendorDataLength = 0;
1457 Namesp->VendorDataOffset = 0;
1461 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b,
1463 if (ACPI_FAILURE (Status))
1470 ParentTable = DtPeekSubtable ();
1471 DtInsertSubtable (ParentTable, Subtable);
1473 Namesp->VendorDataOffset =
1474 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
1475 Namesp->VendorDataLength =
1476 (UINT16) Subtable->Length;
1480 /* Final size of entire namespace structure */
1482 SdevHeader->Length = (UINT16) (sizeof (ACPI_SDEV_NAMESPACE) +
1483 Subtable->Length + Namesp->DeviceIdLength);
1486 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
1488 /* Append the PCIe path info first */
1491 while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device"))
1493 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a,
1495 if (ACPI_FAILURE (Status))
1506 ParentTable = DtPeekSubtable ();
1507 DtInsertSubtable (ParentTable, Subtable);
1511 /* Path offset will point immediately after the main subtable */
1513 Pcie->PathOffset = sizeof (ACPI_SDEV_PCIE);
1514 Pcie->PathLength = (UINT16)
1515 (EntryCount * sizeof (ACPI_SDEV_PCIE_PATH));
1517 /* Append the Vendor Data last */
1519 Pcie->VendorDataLength = 0;
1520 Pcie->VendorDataOffset = 0;
1524 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b,
1526 if (ACPI_FAILURE (Status))
1533 ParentTable = DtPeekSubtable ();
1534 DtInsertSubtable (ParentTable, Subtable);
1536 Pcie->VendorDataOffset =
1537 Pcie->PathOffset + Pcie->PathLength;
1538 Pcie->VendorDataLength = (UINT16)
1543 SdevHeader->Length =
1544 sizeof (ACPI_SDEV_PCIE) +
1545 Pcie->PathLength + Pcie->VendorDataLength;
1550 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV");
1561 /******************************************************************************
1563 * FUNCTION: DtCompileSlic
1565 * PARAMETERS: List - Current field list pointer
1569 * DESCRIPTION: Compile SLIC.
1571 *****************************************************************************/
1578 DT_SUBTABLE *Subtable;
1579 DT_SUBTABLE *ParentTable;
1580 DT_FIELD **PFieldList = (DT_FIELD **) List;
1585 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic,
1587 if (ACPI_FAILURE (Status))
1592 ParentTable = DtPeekSubtable ();
1593 DtInsertSubtable (ParentTable, Subtable);
1594 DtPushSubtable (Subtable);
1602 /******************************************************************************
1604 * FUNCTION: DtCompileSlit
1606 * PARAMETERS: List - Current field list pointer
1610 * DESCRIPTION: Compile SLIT.
1612 *****************************************************************************/
1619 DT_SUBTABLE *Subtable;
1620 DT_SUBTABLE *ParentTable;
1621 DT_FIELD **PFieldList = (DT_FIELD **) List;
1622 DT_FIELD *FieldList;
1624 UINT8 *LocalityBuffer;
1627 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
1629 if (ACPI_FAILURE (Status))
1634 ParentTable = DtPeekSubtable ();
1635 DtInsertSubtable (ParentTable, Subtable);
1637 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
1638 LocalityBuffer = UtLocalCalloc (Localities);
1640 /* Compile each locality buffer */
1642 FieldList = *PFieldList;
1645 DtCompileBuffer (LocalityBuffer,
1646 FieldList->Value, FieldList, Localities);
1648 DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
1649 DtInsertSubtable (ParentTable, Subtable);
1650 FieldList = FieldList->Next;
1653 ACPI_FREE (LocalityBuffer);
1658 /******************************************************************************
1660 * FUNCTION: DtCompileSrat
1662 * PARAMETERS: List - Current field list pointer
1666 * DESCRIPTION: Compile SRAT.
1668 *****************************************************************************/
1675 DT_SUBTABLE *Subtable;
1676 DT_SUBTABLE *ParentTable;
1677 DT_FIELD **PFieldList = (DT_FIELD **) List;
1678 DT_FIELD *SubtableStart;
1679 ACPI_SUBTABLE_HEADER *SratHeader;
1680 ACPI_DMTABLE_INFO *InfoTable;
1683 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
1685 if (ACPI_FAILURE (Status))
1690 ParentTable = DtPeekSubtable ();
1691 DtInsertSubtable (ParentTable, Subtable);
1695 SubtableStart = *PFieldList;
1696 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
1698 if (ACPI_FAILURE (Status))
1703 ParentTable = DtPeekSubtable ();
1704 DtInsertSubtable (ParentTable, Subtable);
1705 DtPushSubtable (Subtable);
1707 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1709 switch (SratHeader->Type)
1711 case ACPI_SRAT_TYPE_CPU_AFFINITY:
1713 InfoTable = AcpiDmTableInfoSrat0;
1716 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1718 InfoTable = AcpiDmTableInfoSrat1;
1721 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1723 InfoTable = AcpiDmTableInfoSrat2;
1726 case ACPI_SRAT_TYPE_GICC_AFFINITY:
1728 InfoTable = AcpiDmTableInfoSrat3;
1731 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY:
1733 InfoTable = AcpiDmTableInfoSrat4;
1736 case ACPI_SRAT_TYPE_GENERIC_AFFINITY:
1738 InfoTable = AcpiDmTableInfoSrat5;
1743 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
1747 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1748 if (ACPI_FAILURE (Status))
1753 ParentTable = DtPeekSubtable ();
1754 DtInsertSubtable (ParentTable, Subtable);
1762 /******************************************************************************
1764 * FUNCTION: DtCompileStao
1766 * PARAMETERS: PFieldList - Current field list pointer
1770 * DESCRIPTION: Compile STAO.
1772 *****************************************************************************/
1778 DT_FIELD **PFieldList = (DT_FIELD **) List;
1779 DT_SUBTABLE *Subtable;
1780 DT_SUBTABLE *ParentTable;
1784 /* Compile the main table */
1786 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao,
1788 if (ACPI_FAILURE (Status))
1793 ParentTable = DtPeekSubtable ();
1794 DtInsertSubtable (ParentTable, Subtable);
1796 /* Compile each ASCII namestring as a subtable */
1800 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr,
1802 if (ACPI_FAILURE (Status))
1807 ParentTable = DtPeekSubtable ();
1808 DtInsertSubtable (ParentTable, Subtable);
1815 /******************************************************************************
1817 * FUNCTION: DtCompileTcpa
1819 * PARAMETERS: PFieldList - Current field list pointer
1823 * DESCRIPTION: Compile TCPA.
1825 *****************************************************************************/
1831 DT_FIELD **PFieldList = (DT_FIELD **) List;
1832 DT_SUBTABLE *Subtable;
1833 ACPI_TABLE_TCPA_HDR *TcpaHeader;
1834 DT_SUBTABLE *ParentTable;
1838 /* Compile the main table */
1840 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
1842 if (ACPI_FAILURE (Status))
1847 ParentTable = DtPeekSubtable ();
1848 DtInsertSubtable (ParentTable, Subtable);
1851 * Examine the PlatformClass field to determine the table type.
1852 * Either a client or server table. Only one.
1854 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
1856 switch (TcpaHeader->PlatformClass)
1858 case ACPI_TCPA_CLIENT_TABLE:
1860 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
1864 case ACPI_TCPA_SERVER_TABLE:
1866 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
1872 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
1873 TcpaHeader->PlatformClass);
1878 ParentTable = DtPeekSubtable ();
1879 DtInsertSubtable (ParentTable, Subtable);
1884 /******************************************************************************
1886 * FUNCTION: DtCompileTpm2Rev3
1888 * PARAMETERS: PFieldList - Current field list pointer
1892 * DESCRIPTION: Compile TPM2 revision 3
1894 *****************************************************************************/
1899 DT_FIELD **PFieldList = (DT_FIELD **) List;
1900 DT_SUBTABLE *Subtable;
1901 ACPI_TABLE_TPM23 *Tpm23Header;
1902 DT_SUBTABLE *ParentTable;
1903 ACPI_STATUS Status = AE_OK;
1906 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23,
1909 ParentTable = DtPeekSubtable ();
1910 DtInsertSubtable (ParentTable, Subtable);
1911 Tpm23Header = ACPI_CAST_PTR (ACPI_TABLE_TPM23, ParentTable->Buffer);
1913 /* Subtable type depends on the StartMethod */
1915 switch (Tpm23Header->StartMethod)
1917 case ACPI_TPM23_ACPI_START_METHOD:
1919 /* Subtable specific to to ARM_SMC */
1921 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23a,
1923 if (ACPI_FAILURE (Status))
1928 ParentTable = DtPeekSubtable ();
1929 DtInsertSubtable (ParentTable, Subtable);
1940 /******************************************************************************
1942 * FUNCTION: DtCompileTpm2
1944 * PARAMETERS: PFieldList - Current field list pointer
1948 * DESCRIPTION: Compile TPM2.
1950 *****************************************************************************/
1956 DT_FIELD **PFieldList = (DT_FIELD **) List;
1957 DT_SUBTABLE *Subtable;
1958 ACPI_TABLE_TPM2 *Tpm2Header;
1959 DT_SUBTABLE *ParentTable;
1960 ACPI_STATUS Status = AE_OK;
1961 ACPI_TABLE_HEADER *Header;
1964 ParentTable = DtPeekSubtable ();
1966 Header = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer);
1968 if (Header->Revision == 3)
1970 return (DtCompileTpm2Rev3 (List));
1973 /* Compile the main table */
1975 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2,
1977 if (ACPI_FAILURE (Status))
1982 ParentTable = DtPeekSubtable ();
1983 DtInsertSubtable (ParentTable, Subtable);
1985 Tpm2Header = ACPI_CAST_PTR (ACPI_TABLE_TPM2, ParentTable->Buffer);
1987 /* Method parameters */
1988 /* Optional: Log area minimum length */
1989 /* Optional: Log area start address */
1990 /* TBD: Optional fields above not fully implemented (not optional at this time) */
1992 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a,
1994 if (ACPI_FAILURE (Status))
1999 ParentTable = DtPeekSubtable ();
2000 DtInsertSubtable (ParentTable, Subtable);
2003 /* Subtable type depends on the StartMethod */
2005 switch (Tpm2Header->StartMethod)
2007 case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC:
2009 /* Subtable specific to to ARM_SMC */
2011 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211,
2013 if (ACPI_FAILURE (Status))
2018 ParentTable = DtPeekSubtable ();
2019 DtInsertSubtable (ParentTable, Subtable);
2022 case ACPI_TPM2_START_METHOD:
2023 case ACPI_TPM2_MEMORY_MAPPED:
2024 case ACPI_TPM2_COMMAND_BUFFER:
2025 case ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD:
2028 case ACPI_TPM2_RESERVED1:
2029 case ACPI_TPM2_RESERVED3:
2030 case ACPI_TPM2_RESERVED4:
2031 case ACPI_TPM2_RESERVED5:
2032 case ACPI_TPM2_RESERVED9:
2033 case ACPI_TPM2_RESERVED10:
2035 AcpiOsPrintf ("\n**** Reserved TPM2 Start Method type 0x%X\n",
2036 Tpm2Header->StartMethod);
2040 case ACPI_TPM2_NOT_ALLOWED:
2043 AcpiOsPrintf ("\n**** Unknown TPM2 Start Method type 0x%X\n",
2044 Tpm2Header->StartMethod);
2053 /******************************************************************************
2055 * FUNCTION: DtGetGenericTableInfo
2057 * PARAMETERS: Name - Generic type name
2059 * RETURN: Info entry
2061 * DESCRIPTION: Obtain table info for a generic name entry
2063 *****************************************************************************/
2066 DtGetGenericTableInfo (
2069 ACPI_DMTABLE_INFO *Info;
2078 /* Search info table for name match */
2082 Info = AcpiDmTableInfoGeneric[i];
2083 if (Info->Opcode == ACPI_DMT_EXIT)
2089 /* Use caseless compare for generic keywords */
2091 if (!AcpiUtStricmp (Name, Info->Name))
2101 /******************************************************************************
2103 * FUNCTION: DtCompileUefi
2105 * PARAMETERS: List - Current field list pointer
2109 * DESCRIPTION: Compile UEFI.
2111 *****************************************************************************/
2118 DT_SUBTABLE *Subtable;
2119 DT_SUBTABLE *ParentTable;
2120 DT_FIELD **PFieldList = (DT_FIELD **) List;
2124 /* Compile the predefined portion of the UEFI table */
2126 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
2128 if (ACPI_FAILURE (Status))
2133 DataOffset = (UINT16 *) (Subtable->Buffer + 16);
2134 *DataOffset = sizeof (ACPI_TABLE_UEFI);
2136 ParentTable = DtPeekSubtable ();
2137 DtInsertSubtable (ParentTable, Subtable);
2140 * Compile the "generic" portion of the UEFI table. This
2141 * part of the table is not predefined and any of the generic
2142 * operators may be used.
2144 DtCompileGeneric ((void **) PFieldList, NULL, NULL);
2149 /******************************************************************************
2151 * FUNCTION: DtCompileVrtc
2153 * PARAMETERS: List - Current field list pointer
2157 * DESCRIPTION: Compile VRTC.
2159 *****************************************************************************/
2168 Status = DtCompileTwoSubtables (List,
2169 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0);
2174 /******************************************************************************
2176 * FUNCTION: DtCompileWdat
2178 * PARAMETERS: List - Current field list pointer
2182 * DESCRIPTION: Compile WDAT.
2184 *****************************************************************************/
2193 Status = DtCompileTwoSubtables (List,
2194 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
2199 /******************************************************************************
2201 * FUNCTION: DtCompileWpbt
2203 * PARAMETERS: List - Current field list pointer
2207 * DESCRIPTION: Compile WPBT.
2209 *****************************************************************************/
2215 DT_FIELD **PFieldList = (DT_FIELD **) List;
2216 DT_SUBTABLE *Subtable;
2217 DT_SUBTABLE *ParentTable;
2218 ACPI_TABLE_WPBT *Table;
2223 /* Compile the main table */
2225 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt,
2227 if (ACPI_FAILURE (Status))
2232 ParentTable = DtPeekSubtable ();
2233 DtInsertSubtable (ParentTable, Subtable);
2235 /* Compile the argument list subtable */
2237 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0,
2239 if (ACPI_FAILURE (Status))
2244 /* Extract the length of the Arguments buffer, insert into main table */
2246 Length = (UINT16) Subtable->TotalLength;
2247 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer);
2248 Table->ArgumentsLength = Length;
2250 ParentTable = DtPeekSubtable ();
2251 DtInsertSubtable (ParentTable, Subtable);
2256 /******************************************************************************
2258 * FUNCTION: DtCompileXsdt
2260 * PARAMETERS: List - Current field list pointer
2264 * DESCRIPTION: Compile XSDT.
2266 *****************************************************************************/
2272 DT_SUBTABLE *Subtable;
2273 DT_SUBTABLE *ParentTable;
2274 DT_FIELD *FieldList = *(DT_FIELD **) List;
2278 ParentTable = DtPeekSubtable ();
2282 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
2284 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
2285 DtInsertSubtable (ParentTable, Subtable);
2286 FieldList = FieldList->Next;
2293 /******************************************************************************
2295 * FUNCTION: DtCompileGeneric
2297 * PARAMETERS: List - Current field list pointer
2298 * Name - Field name to end generic compiling
2299 * Length - Compiled table length to return
2303 * DESCRIPTION: Compile generic unknown table.
2305 *****************************************************************************/
2314 DT_SUBTABLE *Subtable;
2315 DT_SUBTABLE *ParentTable;
2316 DT_FIELD **PFieldList = (DT_FIELD **) List;
2317 ACPI_DMTABLE_INFO *Info;
2320 ParentTable = DtPeekSubtable ();
2323 * Compile the "generic" portion of the table. This
2324 * part of the table is not predefined and any of the generic
2325 * operators may be used.
2328 /* Find any and all labels in the entire generic portion */
2330 DtDetectAllLabels (*PFieldList);
2332 /* Now we can actually compile the parse tree */
2334 if (Length && *Length)
2340 if (Name && !strcmp ((*PFieldList)->Name, Name))
2345 Info = DtGetGenericTableInfo ((*PFieldList)->Name);
2348 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found",
2349 (*PFieldList)->Name);
2350 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
2351 (*PFieldList), AslGbl_MsgBuffer);
2353 *PFieldList = (*PFieldList)->Next;
2357 Status = DtCompileTable (PFieldList, Info,
2359 if (ACPI_SUCCESS (Status))
2361 DtInsertSubtable (ParentTable, Subtable);
2364 *Length += Subtable->Length;
2369 *PFieldList = (*PFieldList)->Next;
2371 if (Status == AE_NOT_FOUND)
2373 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found",
2374 (*PFieldList)->Name);
2375 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
2376 (*PFieldList), AslGbl_MsgBuffer);