dttable.c revision 284460
133965Sjdp/****************************************************************************** 233965Sjdp * 333965Sjdp * Module Name: dttable.c - handling for specific ACPI tables 433965Sjdp * 533965Sjdp *****************************************************************************/ 633965Sjdp 733965Sjdp/* 889857Sobrien * Copyright (C) 2000 - 2015, Intel Corp. 989857Sobrien * All rights reserved. 1033965Sjdp * 1133965Sjdp * Redistribution and use in source and binary forms, with or without 1233965Sjdp * modification, are permitted provided that the following conditions 1333965Sjdp * are met: 1433965Sjdp * 1. Redistributions of source code must retain the above copyright 1533965Sjdp * notice, this list of conditions, and the following disclaimer, 1633965Sjdp * without modification. 1733965Sjdp * 2. Redistributions in binary form must reproduce at minimum a disclaimer 1833965Sjdp * substantially similar to the "NO WARRANTY" disclaimer below 1933965Sjdp * ("Disclaimer") and any redistribution must be conditioned upon 2033965Sjdp * including a substantially similar Disclaimer requirement for further 2133965Sjdp * binary redistribution. 2233965Sjdp * 3. Neither the names of the above-listed copyright holders nor the names 2333965Sjdp * of any contributors may be used to endorse or promote products derived 2433965Sjdp * from this software without specific prior written permission. 2533965Sjdp * 2633965Sjdp * Alternatively, this software may be distributed under the terms of the 2733965Sjdp * GNU General Public License ("GPL") version 2 as published by the Free 2889857Sobrien * Software Foundation. 2933965Sjdp * 3033965Sjdp * NO WARRANTY 3133965Sjdp * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32130561Sobrien * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33130561Sobrien * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34218822Sdim * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35218822Sdim * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36130561Sobrien * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37130561Sobrien * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38130561Sobrien * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39130561Sobrien * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40130561Sobrien * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41130561Sobrien * POSSIBILITY OF SUCH DAMAGES. 42130561Sobrien */ 43130561Sobrien 44130561Sobrien/* Compile all complex data tables */ 45218822Sdim 46218822Sdim#include <contrib/dev/acpica/compiler/aslcompiler.h> 47218822Sdim#include <contrib/dev/acpica/compiler/dtcompiler.h> 48218822Sdim 49218822Sdim#define _COMPONENT DT_COMPILER 50218822Sdim ACPI_MODULE_NAME ("dttable") 51218822Sdim 52218822Sdim 53218822Sdim/* TBD: merge these into dmtbinfo.c? */ 54218822Sdim 55218822Sdimstatic ACPI_DMTABLE_INFO TableInfoAsfAddress[] = 56218822Sdim{ 57218822Sdim {ACPI_DMT_BUFFER, 0, "Addresses", 0}, 58218822Sdim {ACPI_DMT_EXIT, 0, NULL, 0} 59218822Sdim}; 60218822Sdim 61218822Sdimstatic ACPI_DMTABLE_INFO TableInfoDmarPciPath[] = 62218822Sdim{ 63218822Sdim {ACPI_DMT_PCI_PATH, 0, "PCI Path", 0}, 64218822Sdim {ACPI_DMT_EXIT, 0, NULL, 0} 65218822Sdim}; 66218822Sdim 67218822Sdim 68218822Sdim/* Local prototypes */ 69218822Sdim 70130561Sobrienstatic ACPI_STATUS 7133965SjdpDtCompileTwoSubtables ( 7233965Sjdp void **List, 73218822Sdim ACPI_DMTABLE_INFO *TableInfo1, 74218822Sdim ACPI_DMTABLE_INFO *TableInfo2); 75218822Sdim 76218822Sdim 77218822Sdim/****************************************************************************** 78218822Sdim * 79218822Sdim * FUNCTION: DtCompileTwoSubtables 80218822Sdim * 81218822Sdim * PARAMETERS: List - Current field list pointer 82104834Sobrien * TableInfo1 - Info table 1 83218822Sdim * TableInfo1 - Info table 2 84218822Sdim * 85218822Sdim * RETURN: Status 86218822Sdim * 8777298Sobrien * DESCRIPTION: Compile tables with a header and one or more same subtables. 8877298Sobrien * Include CPEP, EINJ, ERST, MCFG, MSCT, WDAT 89218822Sdim * 90218822Sdim *****************************************************************************/ 91218822Sdim 92218822Sdimstatic ACPI_STATUS 9391041SobrienDtCompileTwoSubtables ( 94218822Sdim void **List, 95218822Sdim ACPI_DMTABLE_INFO *TableInfo1, 96218822Sdim ACPI_DMTABLE_INFO *TableInfo2) 97218822Sdim{ 98218822Sdim ACPI_STATUS Status; 99218822Sdim DT_SUBTABLE *Subtable; 100218822Sdim DT_SUBTABLE *ParentTable; 101218822Sdim DT_FIELD **PFieldList = (DT_FIELD **) List; 102218822Sdim 103218822Sdim 104218822Sdim Status = DtCompileTable (PFieldList, TableInfo1, &Subtable, TRUE); 105218822Sdim if (ACPI_FAILURE (Status)) 106218822Sdim { 107218822Sdim return (Status); 108218822Sdim } 109218822Sdim 110218822Sdim ParentTable = DtPeekSubtable (); 111218822Sdim DtInsertSubtable (ParentTable, Subtable); 11233965Sjdp 11333965Sjdp while (*PFieldList) 11438889Sjdp { 11533965Sjdp Status = DtCompileTable (PFieldList, TableInfo2, &Subtable, FALSE); 11633965Sjdp if (ACPI_FAILURE (Status)) 11733965Sjdp { 11833965Sjdp return (Status); 119130561Sobrien } 120130561Sobrien 121130561Sobrien DtInsertSubtable (ParentTable, Subtable); 12233965Sjdp } 12333965Sjdp 124130561Sobrien return (AE_OK); 125130561Sobrien} 126130561Sobrien 127130561Sobrien 128130561Sobrien/****************************************************************************** 129130561Sobrien * 130130561Sobrien * FUNCTION: DtCompileFacs 131130561Sobrien * 132130561Sobrien * PARAMETERS: PFieldList - Current field list pointer 133130561Sobrien * 134130561Sobrien * RETURN: Status 135130561Sobrien * 136130561Sobrien * DESCRIPTION: Compile FACS. 137130561Sobrien * 138130561Sobrien *****************************************************************************/ 13933965Sjdp 14033965SjdpACPI_STATUS 141130561SobrienDtCompileFacs ( 142104834Sobrien DT_FIELD **PFieldList) 143218822Sdim{ 144218822Sdim DT_SUBTABLE *Subtable; 145104834Sobrien UINT8 *ReservedBuffer; 146104834Sobrien ACPI_STATUS Status; 147104834Sobrien UINT32 ReservedSize; 148104834Sobrien 149104834Sobrien 150104834Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoFacs, 151104834Sobrien &Gbl_RootTable, TRUE); 15238889Sjdp if (ACPI_FAILURE (Status)) 15338889Sjdp { 154218822Sdim return (Status); 15538889Sjdp } 15638889Sjdp 15733965Sjdp /* Large FACS reserved area at the end of the table */ 15833965Sjdp 159218822Sdim ReservedSize = (UINT32) sizeof (((ACPI_TABLE_FACS *) NULL)->Reserved1); 16033965Sjdp ReservedBuffer = UtLocalCalloc (ReservedSize); 16138889Sjdp 16233965Sjdp DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable); 16333965Sjdp 164218822Sdim ACPI_FREE (ReservedBuffer); 16533965Sjdp DtInsertSubtable (Gbl_RootTable, Subtable); 166218822Sdim return (AE_OK); 16733965Sjdp} 16833965Sjdp 169218822Sdim 17033965Sjdp/****************************************************************************** 17138889Sjdp * 17260484Sobrien * FUNCTION: DtCompileRsdp 173218822Sdim * 17433965Sjdp * PARAMETERS: PFieldList - Current field list pointer 17538889Sjdp * 17633965Sjdp * RETURN: Status 177218822Sdim * 17833965Sjdp * DESCRIPTION: Compile RSDP. 179218822Sdim * 180218822Sdim *****************************************************************************/ 181218822Sdim 182218822SdimACPI_STATUS 183218822SdimDtCompileRsdp ( 184218822Sdim DT_FIELD **PFieldList) 18577298Sobrien{ 18677298Sobrien DT_SUBTABLE *Subtable; 187218822Sdim ACPI_TABLE_RSDP *Rsdp; 18877298Sobrien ACPI_RSDP_EXTENSION *RsdpExtension; 18977298Sobrien ACPI_STATUS Status; 19089857Sobrien 19189857Sobrien 192218822Sdim /* Compile the "common" RSDP (ACPI 1.0) */ 19377298Sobrien 194218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp1, 195218822Sdim &Gbl_RootTable, TRUE); 196218822Sdim if (ACPI_FAILURE (Status)) 197218822Sdim { 198218822Sdim return (Status); 19968765Sobrien } 20068765Sobrien 201218822Sdim Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Gbl_RootTable->Buffer); 20268765Sobrien DtSetTableChecksum (&Rsdp->Checksum); 20333965Sjdp 20433965Sjdp if (Rsdp->Revision > 0) 205130561Sobrien { 206130561Sobrien /* Compile the "extended" part of the RSDP as a subtable */ 207130561Sobrien 20838889Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp2, 20938889Sjdp &Subtable, TRUE); 21038889Sjdp if (ACPI_FAILURE (Status)) 21138889Sjdp { 21238889Sjdp return (Status); 213104834Sobrien } 214104834Sobrien 215104834Sobrien DtInsertSubtable (Gbl_RootTable, Subtable); 216104834Sobrien 21789857Sobrien /* Set length and extended checksum for entire RSDP */ 21889857Sobrien 21989857Sobrien RsdpExtension = ACPI_CAST_PTR (ACPI_RSDP_EXTENSION, Subtable->Buffer); 22089857Sobrien RsdpExtension->Length = Gbl_RootTable->Length + Subtable->Length; 22189857Sobrien DtSetTableChecksum (&RsdpExtension->ExtendedChecksum); 22260484Sobrien } 223104834Sobrien 22460484Sobrien return (AE_OK); 225130561Sobrien} 22660484Sobrien 227130561Sobrien 228130561Sobrien/****************************************************************************** 229130561Sobrien * 230130561Sobrien * FUNCTION: DtCompileAsf 23133965Sjdp * 23233965Sjdp * PARAMETERS: List - Current field list pointer 23333965Sjdp * 23460484Sobrien * RETURN: Status 23560484Sobrien * 23660484Sobrien * DESCRIPTION: Compile ASF!. 23760484Sobrien * 23889857Sobrien *****************************************************************************/ 23960484Sobrien 24060484SobrienACPI_STATUS 241218822SdimDtCompileAsf ( 242218822Sdim void **List) 24360484Sobrien{ 244130561Sobrien ACPI_ASF_INFO *AsfTable; 24560484Sobrien DT_SUBTABLE *Subtable; 24633965Sjdp DT_SUBTABLE *ParentTable; 24733965Sjdp ACPI_DMTABLE_INFO *InfoTable; 24833965Sjdp ACPI_DMTABLE_INFO *DataInfoTable = NULL; 24933965Sjdp UINT32 DataCount = 0; 25033965Sjdp ACPI_STATUS Status; 25177298Sobrien UINT32 i; 25233965Sjdp DT_FIELD **PFieldList = (DT_FIELD **) List; 25333965Sjdp DT_FIELD *SubtableStart; 25433965Sjdp 25533965Sjdp 25633965Sjdp while (*PFieldList) 25733965Sjdp { 25833965Sjdp SubtableStart = *PFieldList; 25989857Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr, 26078828Sobrien &Subtable, TRUE); 26178828Sobrien if (ACPI_FAILURE (Status)) 26278828Sobrien { 26378828Sobrien return (Status); 26477298Sobrien } 26577298Sobrien 26677298Sobrien ParentTable = DtPeekSubtable (); 26777298Sobrien DtInsertSubtable (ParentTable, Subtable); 268218822Sdim DtPushSubtable (Subtable); 26968765Sobrien 27068765Sobrien AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer); 27168765Sobrien 272130561Sobrien switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */ 27360484Sobrien { 27460484Sobrien case ACPI_ASF_TYPE_INFO: 27560484Sobrien 276206619Simp InfoTable = AcpiDmTableInfoAsf0; 277206619Simp break; 278206619Simp 279206619Simp case ACPI_ASF_TYPE_ALERT: 280239272Sgonzo 281239272Sgonzo InfoTable = AcpiDmTableInfoAsf1; 282239272Sgonzo break; 283239272Sgonzo 284239272Sgonzo case ACPI_ASF_TYPE_CONTROL: 285239272Sgonzo 286239272Sgonzo InfoTable = AcpiDmTableInfoAsf2; 287239272Sgonzo break; 288218822Sdim 289218822Sdim case ACPI_ASF_TYPE_BOOT: 290218822Sdim 291130561Sobrien InfoTable = AcpiDmTableInfoAsf3; 292130561Sobrien break; 293130561Sobrien 294218822Sdim case ACPI_ASF_TYPE_ADDRESS: 295218822Sdim 296218822Sdim InfoTable = AcpiDmTableInfoAsf4; 297218822Sdim break; 298218822Sdim 299218822Sdim default: 300218822Sdim 301218822Sdim DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!"); 30289857Sobrien return (AE_ERROR); 30389857Sobrien } 30489857Sobrien 30589857Sobrien Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 30660484Sobrien if (ACPI_FAILURE (Status)) 30738889Sjdp { 30838889Sjdp return (Status); 30938889Sjdp } 31038889Sjdp 31138889Sjdp ParentTable = DtPeekSubtable (); 31260484Sobrien DtInsertSubtable (ParentTable, Subtable); 31360484Sobrien 31460484Sobrien switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */ 31560484Sobrien { 31660484Sobrien case ACPI_ASF_TYPE_INFO: 31760484Sobrien 31860484Sobrien DataInfoTable = NULL; 31960484Sobrien break; 32060484Sobrien 32138889Sjdp case ACPI_ASF_TYPE_ALERT: 32238889Sjdp 32338889Sjdp DataInfoTable = AcpiDmTableInfoAsf1a; 32438889Sjdp DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, 32538889Sjdp ACPI_SUB_PTR (UINT8, Subtable->Buffer, 32660484Sobrien sizeof (ACPI_ASF_HEADER)))->Alerts; 32760484Sobrien break; 32860484Sobrien 32960484Sobrien case ACPI_ASF_TYPE_CONTROL: 33060484Sobrien 33160484Sobrien DataInfoTable = AcpiDmTableInfoAsf2a; 33260484Sobrien DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, 33360484Sobrien ACPI_SUB_PTR (UINT8, Subtable->Buffer, 33460484Sobrien sizeof (ACPI_ASF_HEADER)))->Controls; 33577298Sobrien break; 33677298Sobrien 33777298Sobrien case ACPI_ASF_TYPE_BOOT: 33877298Sobrien 33977298Sobrien DataInfoTable = NULL; 34077298Sobrien break; 34177298Sobrien 34277298Sobrien case ACPI_ASF_TYPE_ADDRESS: 34377298Sobrien 34460484Sobrien DataInfoTable = TableInfoAsfAddress; 345218822Sdim DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, 346218822Sdim ACPI_SUB_PTR (UINT8, Subtable->Buffer, 34733965Sjdp sizeof (ACPI_ASF_HEADER)))->Devices; 348218822Sdim break; 349218822Sdim 350218822Sdim default: 351218822Sdim 35233965Sjdp DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!"); 35333965Sjdp return (AE_ERROR); 35433965Sjdp } 35538889Sjdp 35638889Sjdp if (DataInfoTable) 35738889Sjdp { 35838889Sjdp switch (AsfTable->Header.Type & 0x7F) 35938889Sjdp { 36038889Sjdp case ACPI_ASF_TYPE_ADDRESS: 36138889Sjdp 362130561Sobrien while (DataCount > 0) 363130561Sobrien { 364130561Sobrien Status = DtCompileTable (PFieldList, DataInfoTable, 365130561Sobrien &Subtable, TRUE); 366130561Sobrien if (ACPI_FAILURE (Status)) 367130561Sobrien { 36877298Sobrien return (Status); 36977298Sobrien } 37077298Sobrien 37177298Sobrien DtInsertSubtable (ParentTable, Subtable); 37277298Sobrien DataCount = DataCount - Subtable->Length; 37377298Sobrien } 374218822Sdim break; 375218822Sdim 376218822Sdim default: 377218822Sdim 378218822Sdim for (i = 0; i < DataCount; i++) 379218822Sdim { 380218822Sdim Status = DtCompileTable (PFieldList, DataInfoTable, 381218822Sdim &Subtable, TRUE); 382218822Sdim if (ACPI_FAILURE (Status)) 383218822Sdim { 384218822Sdim return (Status); 38577298Sobrien } 38677298Sobrien 38777298Sobrien DtInsertSubtable (ParentTable, Subtable); 38877298Sobrien } 38977298Sobrien break; 390218822Sdim } 391218822Sdim } 392218822Sdim 393218822Sdim DtPopSubtable (); 394218822Sdim } 39533965Sjdp 39633965Sjdp return (AE_OK); 39733965Sjdp} 39833965Sjdp 399104834Sobrien 400104834Sobrien/****************************************************************************** 401104834Sobrien * 402104834Sobrien * FUNCTION: DtCompileCpep 403104834Sobrien * 40460484Sobrien * PARAMETERS: List - Current field list pointer 40560484Sobrien * 40660484Sobrien * RETURN: Status 40733965Sjdp * 408218822Sdim * DESCRIPTION: Compile CPEP. 409218822Sdim * 410218822Sdim *****************************************************************************/ 411218822Sdim 412218822SdimACPI_STATUS 41360484SobrienDtCompileCpep ( 41460484Sobrien void **List) 41560484Sobrien{ 41638889Sjdp ACPI_STATUS Status; 417104834Sobrien 418104834Sobrien 419130561Sobrien Status = DtCompileTwoSubtables (List, 420104834Sobrien AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0); 42160484Sobrien return (Status); 422130561Sobrien} 423130561Sobrien 424130561Sobrien 425130561Sobrien/****************************************************************************** 426104834Sobrien * 427218822Sdim * FUNCTION: DtCompileCsrt 428218822Sdim * 429218822Sdim * PARAMETERS: List - Current field list pointer 430218822Sdim * 431218822Sdim * RETURN: Status 432218822Sdim * 43389857Sobrien * DESCRIPTION: Compile CSRT. 43489857Sobrien * 43589857Sobrien *****************************************************************************/ 43689857Sobrien 43733965SjdpACPI_STATUS 43833965SjdpDtCompileCsrt ( 43933965Sjdp void **List) 44033965Sjdp{ 44133965Sjdp ACPI_STATUS Status = AE_OK; 44233965Sjdp DT_SUBTABLE *Subtable; 44333965Sjdp DT_SUBTABLE *ParentTable; 44433965Sjdp DT_FIELD **PFieldList = (DT_FIELD **) List; 44533965Sjdp UINT32 DescriptorCount; 44633965Sjdp UINT32 GroupLength; 44777298Sobrien 448218822Sdim 44977298Sobrien /* Subtables (Resource Groups) */ 45077298Sobrien 451218822Sdim ParentTable = DtPeekSubtable (); 45277298Sobrien while (*PFieldList) 45377298Sobrien { 45477298Sobrien /* Resource group subtable */ 45577298Sobrien 45677298Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt0, 457218822Sdim &Subtable, TRUE); 45877298Sobrien if (ACPI_FAILURE (Status)) 45977298Sobrien { 46077298Sobrien return (Status); 461218822Sdim } 46277298Sobrien 46377298Sobrien /* Compute the number of resource descriptors */ 46477298Sobrien 465218822Sdim GroupLength = 466218822Sdim (ACPI_CAST_PTR (ACPI_CSRT_GROUP, 467218822Sdim Subtable->Buffer))->Length - 468218822Sdim (ACPI_CAST_PTR (ACPI_CSRT_GROUP, 469218822Sdim Subtable->Buffer))->SharedInfoLength - 47033965Sjdp sizeof (ACPI_CSRT_GROUP); 47177298Sobrien 47233965Sjdp DescriptorCount = (GroupLength / 47377298Sobrien sizeof (ACPI_CSRT_DESCRIPTOR)); 47460484Sobrien 47533965Sjdp DtInsertSubtable (ParentTable, Subtable); 47633965Sjdp DtPushSubtable (Subtable); 47733965Sjdp ParentTable = DtPeekSubtable (); 47833965Sjdp 47960484Sobrien /* Shared info subtable (One per resource group) */ 48033965Sjdp 48133965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt1, 48233965Sjdp &Subtable, TRUE); 48333965Sjdp if (ACPI_FAILURE (Status)) 48433965Sjdp { 48533965Sjdp return (Status); 48633965Sjdp } 48733965Sjdp 488218822Sdim DtInsertSubtable (ParentTable, Subtable); 48960484Sobrien 49060484Sobrien /* Sub-Subtables (Resource Descriptors) */ 49160484Sobrien 492130561Sobrien while (*PFieldList && DescriptorCount) 49338889Sjdp { 49460484Sobrien 49538889Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2, 496218822Sdim &Subtable, TRUE); 497130561Sobrien if (ACPI_FAILURE (Status)) 498130561Sobrien { 49933965Sjdp return (Status); 50033965Sjdp } 50133965Sjdp DtInsertSubtable (ParentTable, Subtable); 502218822Sdim 503218822Sdim DtPushSubtable (Subtable); 504218822Sdim ParentTable = DtPeekSubtable (); 505218822Sdim if (*PFieldList) 506218822Sdim { 507218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2a, 508130561Sobrien &Subtable, TRUE); 509107492Sobrien if (ACPI_FAILURE (Status)) 510130561Sobrien { 511130561Sobrien return (Status); 512130561Sobrien } 513130561Sobrien if (Subtable) 514104834Sobrien { 515104834Sobrien DtInsertSubtable (ParentTable, Subtable); 516130561Sobrien } 51777298Sobrien } 51877298Sobrien DtPopSubtable (); 519130561Sobrien ParentTable = DtPeekSubtable (); 520130561Sobrien 521130561Sobrien DescriptorCount--; 522218822Sdim } 52338889Sjdp 52438889Sjdp DtPopSubtable (); 52538889Sjdp ParentTable = DtPeekSubtable (); 526130561Sobrien } 527130561Sobrien 52833965Sjdp return (Status); 52933965Sjdp} 530218822Sdim 53185815Sobrien 53285815Sobrien/****************************************************************************** 53385815Sobrien * 534130561Sobrien * FUNCTION: DtCompileDbg2 535130561Sobrien * 536130561Sobrien * PARAMETERS: List - Current field list pointer 537130561Sobrien * 538130561Sobrien * RETURN: Status 539130561Sobrien * 54033965Sjdp * DESCRIPTION: Compile DBG2. 54133965Sjdp * 54233965Sjdp *****************************************************************************/ 543130561Sobrien 54433965SjdpACPI_STATUS 54533965SjdpDtCompileDbg2 ( 54633965Sjdp void **List) 547130561Sobrien{ 548130561Sobrien ACPI_STATUS Status; 54933965Sjdp DT_SUBTABLE *Subtable; 55033965Sjdp DT_SUBTABLE *ParentTable; 55133965Sjdp DT_FIELD **PFieldList = (DT_FIELD **) List; 55233965Sjdp UINT32 SubtableCount; 553130561Sobrien ACPI_DBG2_HEADER *Dbg2Header; 554104834Sobrien ACPI_DBG2_DEVICE *DeviceInfo; 555218822Sdim UINT16 CurrentOffset; 556218822Sdim UINT32 i; 557104834Sobrien 558104834Sobrien 559130561Sobrien /* Main table */ 560104834Sobrien 561104834Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2, &Subtable, TRUE); 56260484Sobrien if (ACPI_FAILURE (Status)) 563130561Sobrien { 56477298Sobrien return (Status); 56577298Sobrien } 566130561Sobrien 56777298Sobrien ParentTable = DtPeekSubtable (); 568130561Sobrien DtInsertSubtable (ParentTable, Subtable); 569104834Sobrien 570104834Sobrien /* Main table fields */ 571104834Sobrien 572130561Sobrien Dbg2Header = ACPI_CAST_PTR (ACPI_DBG2_HEADER, Subtable->Buffer); 573130561Sobrien Dbg2Header->InfoOffset = sizeof (ACPI_TABLE_HEADER) + ACPI_PTR_DIFF ( 57433965Sjdp ACPI_ADD_PTR (UINT8, Dbg2Header, sizeof (ACPI_DBG2_HEADER)), Dbg2Header); 57577298Sobrien 57633965Sjdp SubtableCount = Dbg2Header->InfoCount; 57733965Sjdp DtPushSubtable (Subtable); 578218822Sdim 57933965Sjdp /* Process all Device Information subtables (Count = InfoCount) */ 580130561Sobrien 581130561Sobrien while (*PFieldList && SubtableCount) 582130561Sobrien { 583130561Sobrien /* Subtable: Debug Device Information */ 58433965Sjdp 58533965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Device, 586130561Sobrien &Subtable, TRUE); 58733965Sjdp if (ACPI_FAILURE (Status)) 58833965Sjdp { 58933965Sjdp return (Status); 59033965Sjdp } 591218822Sdim 59233965Sjdp DeviceInfo = ACPI_CAST_PTR (ACPI_DBG2_DEVICE, Subtable->Buffer); 59377298Sobrien CurrentOffset = (UINT16) sizeof (ACPI_DBG2_DEVICE); 594130561Sobrien 59533965Sjdp ParentTable = DtPeekSubtable (); 59689857Sobrien DtInsertSubtable (ParentTable, Subtable); 597218822Sdim DtPushSubtable (Subtable); 59877298Sobrien 599218822Sdim ParentTable = DtPeekSubtable (); 600218822Sdim 60177298Sobrien /* BaseAddressRegister GAS array (Required, size is RegisterCount) */ 602218822Sdim 603218822Sdim DeviceInfo->BaseAddressOffset = CurrentOffset; 604218822Sdim for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++) 605218822Sdim { 606218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Addr, 607130561Sobrien &Subtable, TRUE); 60889857Sobrien if (ACPI_FAILURE (Status)) 609218822Sdim { 610218822Sdim return (Status); 61189857Sobrien } 612218822Sdim 61377298Sobrien CurrentOffset += (UINT16) sizeof (ACPI_GENERIC_ADDRESS); 614218822Sdim DtInsertSubtable (ParentTable, Subtable); 615218822Sdim } 61677298Sobrien 617218822Sdim /* AddressSize array (Required, size = RegisterCount) */ 618218822Sdim 619218822Sdim DeviceInfo->AddressSizeOffset = CurrentOffset; 620218822Sdim for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++) 621218822Sdim { 622218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Size, 62377298Sobrien &Subtable, TRUE); 624130561Sobrien if (ACPI_FAILURE (Status)) 625218822Sdim { 626218822Sdim return (Status); 62733965Sjdp } 628130561Sobrien 62933965Sjdp CurrentOffset += (UINT16) sizeof (UINT32); 63033965Sjdp DtInsertSubtable (ParentTable, Subtable); 631130561Sobrien } 63233965Sjdp 63333965Sjdp /* NamespaceString device identifier (Required, size = NamePathLength) */ 63433965Sjdp 63533965Sjdp DeviceInfo->NamepathOffset = CurrentOffset; 636130561Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Name, 63733965Sjdp &Subtable, TRUE); 63833965Sjdp if (ACPI_FAILURE (Status)) 639130561Sobrien { 64033965Sjdp return (Status); 64133965Sjdp } 64233965Sjdp 643130561Sobrien /* Update the device info header */ 64433965Sjdp 64533965Sjdp DeviceInfo->NamepathLength = (UINT16) Subtable->Length; 64633965Sjdp CurrentOffset += (UINT16) DeviceInfo->NamepathLength; 647130561Sobrien DtInsertSubtable (ParentTable, Subtable); 64833965Sjdp 64933965Sjdp /* OemData - Variable-length data (Optional, size = OemDataLength) */ 65033965Sjdp 651130561Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2OemData, 65260484Sobrien &Subtable, TRUE); 65360484Sobrien if (ACPI_FAILURE (Status)) 65460484Sobrien { 655130561Sobrien return (Status); 65660484Sobrien } 65760484Sobrien 65860484Sobrien /* Update the device info header (zeros if no OEM data present) */ 65960484Sobrien 66060484Sobrien DeviceInfo->OemDataOffset = 0; 661218822Sdim DeviceInfo->OemDataLength = 0; 662218822Sdim 663218822Sdim /* Optional subtable (OemData) */ 664218822Sdim 665130561Sobrien if (Subtable && Subtable->Length) 66660484Sobrien { 66760484Sobrien DeviceInfo->OemDataOffset = CurrentOffset; 668218822Sdim DeviceInfo->OemDataLength = (UINT16) Subtable->Length; 66960484Sobrien 670130561Sobrien DtInsertSubtable (ParentTable, Subtable); 67133965Sjdp } 67233965Sjdp 673130561Sobrien SubtableCount--; 67433965Sjdp DtPopSubtable (); /* Get next Device Information subtable */ 67533965Sjdp } 676218822Sdim 677218822Sdim DtPopSubtable (); 67860484Sobrien return (AE_OK); 67960484Sobrien} 680130561Sobrien 68177298Sobrien 68277298Sobrien/****************************************************************************** 68377298Sobrien * 68433965Sjdp * FUNCTION: DtCompileDmar 68533965Sjdp * 68633965Sjdp * PARAMETERS: List - Current field list pointer 68733965Sjdp * 68877298Sobrien * RETURN: Status 68977298Sobrien * 69077298Sobrien * DESCRIPTION: Compile DMAR. 69177298Sobrien * 69233965Sjdp *****************************************************************************/ 69333965Sjdp 69433965SjdpACPI_STATUS 69533965SjdpDtCompileDmar ( 69633965Sjdp void **List) 69733965Sjdp{ 69833965Sjdp ACPI_STATUS Status; 69933965Sjdp DT_SUBTABLE *Subtable; 70033965Sjdp DT_SUBTABLE *ParentTable; 701218822Sdim DT_FIELD **PFieldList = (DT_FIELD **) List; 70233965Sjdp DT_FIELD *SubtableStart; 70333965Sjdp ACPI_DMTABLE_INFO *InfoTable; 70433965Sjdp ACPI_DMAR_HEADER *DmarHeader; 70533965Sjdp ACPI_DMAR_DEVICE_SCOPE *DmarDeviceScope; 70633965Sjdp UINT32 DeviceScopeLength; 70733965Sjdp UINT32 PciPathLength; 70833965Sjdp 70933965Sjdp 71033965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE); 71160484Sobrien if (ACPI_FAILURE (Status)) 71260484Sobrien { 71360484Sobrien return (Status); 71460484Sobrien } 71533965Sjdp 716130561Sobrien ParentTable = DtPeekSubtable (); 717130561Sobrien DtInsertSubtable (ParentTable, Subtable); 718130561Sobrien DtPushSubtable (Subtable); 719130561Sobrien 720130561Sobrien while (*PFieldList) 721130561Sobrien { 722130561Sobrien /* DMAR Header */ 723130561Sobrien 724218822Sdim SubtableStart = *PFieldList; 725218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarHdr, 726218822Sdim &Subtable, TRUE); 727218822Sdim if (ACPI_FAILURE (Status)) 728130561Sobrien { 729130561Sobrien return (Status); 730130561Sobrien } 731130561Sobrien 732130561Sobrien ParentTable = DtPeekSubtable (); 733130561Sobrien DtInsertSubtable (ParentTable, Subtable); 734130561Sobrien DtPushSubtable (Subtable); 735130561Sobrien 736130561Sobrien DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer); 737130561Sobrien 738130561Sobrien switch (DmarHeader->Type) 739130561Sobrien { 74033965Sjdp case ACPI_DMAR_TYPE_HARDWARE_UNIT: 74133965Sjdp 74233965Sjdp InfoTable = AcpiDmTableInfoDmar0; 74333965Sjdp break; 74477298Sobrien 74577298Sobrien case ACPI_DMAR_TYPE_RESERVED_MEMORY: 74677298Sobrien 74777298Sobrien InfoTable = AcpiDmTableInfoDmar1; 74877298Sobrien break; 74977298Sobrien 75077298Sobrien case ACPI_DMAR_TYPE_ROOT_ATS: 75177298Sobrien 75277298Sobrien InfoTable = AcpiDmTableInfoDmar2; 75333965Sjdp break; 75433965Sjdp 75533965Sjdp case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 75633965Sjdp 75733965Sjdp InfoTable = AcpiDmTableInfoDmar3; 75833965Sjdp break; 75933965Sjdp 76033965Sjdp case ACPI_DMAR_TYPE_NAMESPACE: 76133965Sjdp 76260484Sobrien InfoTable = AcpiDmTableInfoDmar4; 76333965Sjdp break; 76433965Sjdp 76560484Sobrien default: 76633965Sjdp 76733965Sjdp DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "DMAR"); 768130561Sobrien return (AE_ERROR); 76933965Sjdp } 77033965Sjdp 77133965Sjdp /* DMAR Subtable */ 77277298Sobrien 77385815Sobrien Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 77460484Sobrien if (ACPI_FAILURE (Status)) 77560484Sobrien { 77660484Sobrien return (Status); 77760484Sobrien } 77833965Sjdp 77933965Sjdp ParentTable = DtPeekSubtable (); 78033965Sjdp DtInsertSubtable (ParentTable, Subtable); 78133965Sjdp 78233965Sjdp /* 78333965Sjdp * Optional Device Scope subtables 78433965Sjdp */ 78533965Sjdp if ((DmarHeader->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 78633965Sjdp (DmarHeader->Type == ACPI_DMAR_TYPE_NAMESPACE)) 78733965Sjdp { 78833965Sjdp /* These types do not support device scopes */ 789218822Sdim 79033965Sjdp DtPopSubtable (); 79133965Sjdp continue; 79233965Sjdp } 79360484Sobrien 79460484Sobrien DtPushSubtable (Subtable); 79560484Sobrien DeviceScopeLength = DmarHeader->Length - Subtable->Length - 79660484Sobrien ParentTable->Length; 79760484Sobrien while (DeviceScopeLength) 79833965Sjdp { 79933965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope, 80033965Sjdp &Subtable, FALSE); 80133965Sjdp if (Status == AE_NOT_FOUND) 80233965Sjdp { 803218822Sdim break; 80489857Sobrien } 80589857Sobrien 80689857Sobrien ParentTable = DtPeekSubtable (); 80789857Sobrien DtInsertSubtable (ParentTable, Subtable); 80833965Sjdp DtPushSubtable (Subtable); 80989857Sobrien 81089857Sobrien DmarDeviceScope = ACPI_CAST_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable->Buffer); 81189857Sobrien 81289857Sobrien /* Optional PCI Paths */ 81389857Sobrien 81433965Sjdp PciPathLength = DmarDeviceScope->Length - Subtable->Length; 81533965Sjdp while (PciPathLength) 81633965Sjdp { 81733965Sjdp Status = DtCompileTable (PFieldList, TableInfoDmarPciPath, 81833965Sjdp &Subtable, FALSE); 81933965Sjdp if (Status == AE_NOT_FOUND) 82033965Sjdp { 82133965Sjdp DtPopSubtable (); 82233965Sjdp break; 82333965Sjdp } 82433965Sjdp 82533965Sjdp ParentTable = DtPeekSubtable (); 82633965Sjdp DtInsertSubtable (ParentTable, Subtable); 82733965Sjdp PciPathLength -= Subtable->Length; 82833965Sjdp } 82933965Sjdp 83033965Sjdp DtPopSubtable (); 83133965Sjdp DeviceScopeLength -= DmarDeviceScope->Length; 83233965Sjdp } 83333965Sjdp 83433965Sjdp DtPopSubtable (); 83533965Sjdp DtPopSubtable (); 83633965Sjdp } 83733965Sjdp 83833965Sjdp return (AE_OK); 83933965Sjdp} 84033965Sjdp 84133965Sjdp 84233965Sjdp/****************************************************************************** 84333965Sjdp * 84433965Sjdp * FUNCTION: DtCompileDrtm 845218822Sdim * 846218822Sdim * PARAMETERS: List - Current field list pointer 847218822Sdim * 848218822Sdim * RETURN: Status 84933965Sjdp * 85033965Sjdp * DESCRIPTION: Compile DRTM. 85133965Sjdp * 85233965Sjdp *****************************************************************************/ 85333965Sjdp 854218822SdimACPI_STATUS 855218822SdimDtCompileDrtm ( 856218822Sdim void **List) 857218822Sdim{ 85860484Sobrien ACPI_STATUS Status; 85960484Sobrien DT_SUBTABLE *Subtable; 86060484Sobrien DT_SUBTABLE *ParentTable; 86160484Sobrien DT_FIELD **PFieldList = (DT_FIELD **) List; 86260484Sobrien UINT32 Count; 86360484Sobrien /* ACPI_TABLE_DRTM *Drtm; */ 86460484Sobrien ACPI_DRTM_VTABLE_LIST *DrtmVtl; 86560484Sobrien ACPI_DRTM_RESOURCE_LIST *DrtmRl; 86660484Sobrien /* ACPI_DRTM_DPS_ID *DrtmDps; */ 867218822Sdim 868218822Sdim 869218822Sdim ParentTable = DtPeekSubtable (); 870218822Sdim 871218822Sdim /* Compile DRTM header */ 87233965Sjdp 87333965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm, 87433965Sjdp &Subtable, TRUE); 87533965Sjdp if (ACPI_FAILURE (Status)) 87689857Sobrien { 877218822Sdim return (Status); 878218822Sdim } 87933965Sjdp DtInsertSubtable (ParentTable, Subtable); 880215256Simp 881218822Sdim /* 882218822Sdim * Using ACPI_SUB_PTR, We needn't define a seperate structure. Care 883215256Simp * should be taken to avoid accessing ACPI_TABLE_HADER fields. 884215256Simp */ 885215256Simp#if 0 886215256Simp Drtm = ACPI_SUB_PTR (ACPI_TABLE_DRTM, 887215256Simp Subtable->Buffer, sizeof (ACPI_TABLE_HEADER)); 888185925Simp#endif 889185925Simp /* Compile VTL */ 890185925Simp 891185925Simp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0, 89233965Sjdp &Subtable, TRUE); 89333965Sjdp if (ACPI_FAILURE (Status)) 89433965Sjdp { 89533965Sjdp return (Status); 89633965Sjdp } 89733965Sjdp DtInsertSubtable (ParentTable, Subtable); 89833965Sjdp DrtmVtl = ACPI_CAST_PTR (ACPI_DRTM_VTABLE_LIST, Subtable->Buffer); 89933965Sjdp 90089857Sobrien DtPushSubtable (Subtable); 90133965Sjdp ParentTable = DtPeekSubtable (); 902130561Sobrien Count = 0; 903130561Sobrien while (*PFieldList) 904218822Sdim { 90533965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0a, 90689857Sobrien &Subtable, TRUE); 90733965Sjdp if (ACPI_FAILURE (Status)) 90833965Sjdp { 90933965Sjdp return (Status); 91033965Sjdp } 91133965Sjdp if (!Subtable) 91233965Sjdp { 91333965Sjdp break; 91433965Sjdp } 91533965Sjdp DtInsertSubtable (ParentTable, Subtable); 91633965Sjdp Count++; 91733965Sjdp } 91833965Sjdp DrtmVtl->ValidatedTableCount = Count; 91933965Sjdp DtPopSubtable (); 92077298Sobrien ParentTable = DtPeekSubtable (); 92177298Sobrien 92233965Sjdp /* Compile RL */ 92333965Sjdp 92433965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1, 92533965Sjdp &Subtable, TRUE); 92633965Sjdp if (ACPI_FAILURE (Status)) 927218822Sdim { 928218822Sdim return (Status); 929218822Sdim } 930218822Sdim DtInsertSubtable (ParentTable, Subtable); 931218822Sdim DrtmRl = ACPI_CAST_PTR (ACPI_DRTM_RESOURCE_LIST, Subtable->Buffer); 932218822Sdim 933218822Sdim DtPushSubtable (Subtable); 934218822Sdim ParentTable = DtPeekSubtable (); 935218822Sdim Count = 0; 936218822Sdim while (*PFieldList) 937218822Sdim { 938218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1a, 939218822Sdim &Subtable, TRUE); 940218822Sdim if (ACPI_FAILURE (Status)) 941218822Sdim { 942218822Sdim return (Status); 943218822Sdim } 944218822Sdim if (!Subtable) 945218822Sdim { 946218822Sdim break; 947218822Sdim } 948218822Sdim DtInsertSubtable (ParentTable, Subtable); 949218822Sdim Count++; 95033965Sjdp } 95133965Sjdp DrtmRl->ResourceCount = Count; 95233965Sjdp DtPopSubtable (); 953130561Sobrien ParentTable = DtPeekSubtable (); 95433965Sjdp 95533965Sjdp /* Compile DPS */ 95633965Sjdp 95733965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm2, 95833965Sjdp &Subtable, TRUE); 95933965Sjdp if (ACPI_FAILURE (Status)) 96033965Sjdp { 961218822Sdim return (Status); 962218822Sdim } 963218822Sdim DtInsertSubtable (ParentTable, Subtable); 964218822Sdim /* DrtmDps = ACPI_CAST_PTR (ACPI_DRTM_DPS_ID, Subtable->Buffer);*/ 965218822Sdim 966218822Sdim 967218822Sdim return (AE_OK); 96889857Sobrien} 96933965Sjdp 97033965Sjdp 97133965Sjdp/****************************************************************************** 97278828Sobrien * 97333965Sjdp * FUNCTION: DtCompileEinj 97433965Sjdp * 97533965Sjdp * PARAMETERS: List - Current field list pointer 97689857Sobrien * 97789857Sobrien * RETURN: Status 978130561Sobrien * 979130561Sobrien * DESCRIPTION: Compile EINJ. 980218822Sdim * 98189857Sobrien *****************************************************************************/ 98289857Sobrien 983130561SobrienACPI_STATUS 984130561SobrienDtCompileEinj ( 985218822Sdim void **List) 98689857Sobrien{ 98789857Sobrien ACPI_STATUS Status; 98889857Sobrien 98989857Sobrien 990130561Sobrien Status = DtCompileTwoSubtables (List, 991130561Sobrien AcpiDmTableInfoEinj, AcpiDmTableInfoEinj0); 99289857Sobrien return (Status); 99389857Sobrien} 99489857Sobrien 995130561Sobrien 996130561Sobrien/****************************************************************************** 99778828Sobrien * 99889857Sobrien * FUNCTION: DtCompileErst 99989857Sobrien * 100089857Sobrien * PARAMETERS: List - Current field list pointer 100189857Sobrien * 1002218822Sdim * RETURN: Status 100389857Sobrien * 100489857Sobrien * DESCRIPTION: Compile ERST. 100533965Sjdp * 100633965Sjdp *****************************************************************************/ 100733965Sjdp 100833965SjdpACPI_STATUS 100933965SjdpDtCompileErst ( 101033965Sjdp void **List) 1011130561Sobrien{ 101233965Sjdp ACPI_STATUS Status; 101333965Sjdp 1014218822Sdim 1015218822Sdim Status = DtCompileTwoSubtables (List, 1016218822Sdim AcpiDmTableInfoErst, AcpiDmTableInfoEinj0); 1017218822Sdim return (Status); 1018130561Sobrien} 1019130561Sobrien 1020130561Sobrien 1021130561Sobrien/****************************************************************************** 102233965Sjdp * 102333965Sjdp * FUNCTION: DtCompileFadt 102433965Sjdp * 102533965Sjdp * PARAMETERS: List - Current field list pointer 102633965Sjdp * 102733965Sjdp * RETURN: Status 102833965Sjdp * 102933965Sjdp * DESCRIPTION: Compile FADT. 103033965Sjdp * 103189857Sobrien *****************************************************************************/ 103289857Sobrien 103389857SobrienACPI_STATUS 103489857SobrienDtCompileFadt ( 1035130561Sobrien void **List) 103691041Sobrien{ 103791041Sobrien ACPI_STATUS Status; 103891041Sobrien DT_SUBTABLE *Subtable; 103991041Sobrien DT_SUBTABLE *ParentTable; 1040218822Sdim DT_FIELD **PFieldList = (DT_FIELD **) List; 104191041Sobrien ACPI_TABLE_HEADER *Table; 104291041Sobrien UINT8 Revision; 104391041Sobrien 104489857Sobrien 104589857Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt1, 104689857Sobrien &Subtable, TRUE); 104789857Sobrien if (ACPI_FAILURE (Status)) 104889857Sobrien { 104960484Sobrien return (Status); 105060484Sobrien } 105160484Sobrien 105260484Sobrien ParentTable = DtPeekSubtable (); 105360484Sobrien DtInsertSubtable (ParentTable, Subtable); 105460484Sobrien 105560484Sobrien Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); 105660484Sobrien Revision = Table->Revision; 105760484Sobrien 105860484Sobrien if (Revision == 2) 1059130561Sobrien { 1060130561Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt2, 1061130561Sobrien &Subtable, TRUE); 1062130561Sobrien if (ACPI_FAILURE (Status)) 1063130561Sobrien { 1064130561Sobrien return (Status); 1065130561Sobrien } 1066130561Sobrien 1067130561Sobrien DtInsertSubtable (ParentTable, Subtable); 1068130561Sobrien } 1069130561Sobrien else if (Revision >= 2) 1070130561Sobrien { 1071104834Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt3, 1072130561Sobrien &Subtable, TRUE); 1073104834Sobrien if (ACPI_FAILURE (Status)) 1074104834Sobrien { 1075104834Sobrien return (Status); 1076104834Sobrien } 1077104834Sobrien 1078104834Sobrien DtInsertSubtable (ParentTable, Subtable); 1079130561Sobrien 1080104834Sobrien if (Revision >= 5) 1081104834Sobrien { 1082104834Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt5, 1083104834Sobrien &Subtable, TRUE); 1084104834Sobrien if (ACPI_FAILURE (Status)) 1085104834Sobrien { 108689857Sobrien return (Status); 108733965Sjdp } 108889857Sobrien 108989857Sobrien DtInsertSubtable (ParentTable, Subtable); 1090218822Sdim } 109189857Sobrien 109291041Sobrien if (Revision >= 6) 109391041Sobrien { 109489857Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt6, 109533965Sjdp &Subtable, TRUE); 109689857Sobrien if (ACPI_FAILURE (Status)) 109789857Sobrien { 109889857Sobrien return (Status); 109989857Sobrien } 1100218822Sdim 110189857Sobrien DtInsertSubtable (ParentTable, Subtable); 1102130561Sobrien } 1103130561Sobrien } 110489857Sobrien 110589857Sobrien return (AE_OK); 1106218822Sdim} 110789857Sobrien 110889857Sobrien/****************************************************************************** 110989857Sobrien * 111089857Sobrien * FUNCTION: DtCompileGtdt 1111218822Sdim * 111289857Sobrien * PARAMETERS: List - Current field list pointer 111389857Sobrien * 111433965Sjdp * RETURN: Status 1115218822Sdim * 1116218822Sdim * DESCRIPTION: Compile GTDT. 111733965Sjdp * 111860484Sobrien *****************************************************************************/ 111989857Sobrien 112033965SjdpACPI_STATUS 1121130561SobrienDtCompileGtdt ( 1122130561Sobrien void **List) 1123130561Sobrien{ 1124130561Sobrien ACPI_STATUS Status; 1125130561Sobrien DT_SUBTABLE *Subtable; 1126130561Sobrien DT_SUBTABLE *ParentTable; 1127130561Sobrien DT_FIELD **PFieldList = (DT_FIELD **) List; 1128130561Sobrien DT_FIELD *SubtableStart; 1129130561Sobrien ACPI_SUBTABLE_HEADER *GtdtHeader; 1130130561Sobrien ACPI_DMTABLE_INFO *InfoTable; 1131218822Sdim UINT32 GtCount; 113233965Sjdp 113333965Sjdp 1134218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt, 1135218822Sdim &Subtable, TRUE); 1136218822Sdim if (ACPI_FAILURE (Status)) 1137218822Sdim { 1138218822Sdim return (Status); 113933965Sjdp } 114033965Sjdp 114133965Sjdp ParentTable = DtPeekSubtable (); 114233965Sjdp DtInsertSubtable (ParentTable, Subtable); 1143130561Sobrien 1144130561Sobrien while (*PFieldList) 1145130561Sobrien { 1146130561Sobrien SubtableStart = *PFieldList; 1147218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdtHdr, 1148218822Sdim &Subtable, TRUE); 1149218822Sdim if (ACPI_FAILURE (Status)) 1150218822Sdim { 1151218822Sdim return (Status); 1152130561Sobrien } 1153130561Sobrien 1154130561Sobrien ParentTable = DtPeekSubtable (); 1155130561Sobrien DtInsertSubtable (ParentTable, Subtable); 115633965Sjdp DtPushSubtable (Subtable); 1157218822Sdim 115833965Sjdp GtdtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 115960484Sobrien 116089857Sobrien switch (GtdtHeader->Type) 116133965Sjdp { 116260484Sobrien case ACPI_GTDT_TYPE_TIMER_BLOCK: 116333965Sjdp 116433965Sjdp InfoTable = AcpiDmTableInfoGtdt0; 116533965Sjdp break; 116633965Sjdp 116789857Sobrien case ACPI_GTDT_TYPE_WATCHDOG: 116889857Sobrien 1169107492Sobrien InfoTable = AcpiDmTableInfoGtdt1; 1170218822Sdim break; 117133965Sjdp 117289857Sobrien default: 117389857Sobrien 117489857Sobrien DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "GTDT"); 1175107492Sobrien return (AE_ERROR); 1176218822Sdim } 117789857Sobrien 1178218822Sdim Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1179218822Sdim if (ACPI_FAILURE (Status)) 1180218822Sdim { 1181218822Sdim return (Status); 118289857Sobrien } 118333965Sjdp 1184218822Sdim ParentTable = DtPeekSubtable (); 1185218822Sdim DtInsertSubtable (ParentTable, Subtable); 1186218822Sdim 1187218822Sdim /* 1188218822Sdim * Additional GT block subtable data 118991041Sobrien */ 1190104834Sobrien 1191104834Sobrien switch (GtdtHeader->Type) 1192104834Sobrien { 1193104834Sobrien case ACPI_GTDT_TYPE_TIMER_BLOCK: 1194218822Sdim 1195104834Sobrien DtPushSubtable (Subtable); 119691041Sobrien ParentTable = DtPeekSubtable (); 119791041Sobrien 119891041Sobrien GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 119991041Sobrien Subtable->Buffer - sizeof(ACPI_GTDT_HEADER)))->TimerCount; 1200218822Sdim while (GtCount) 120191041Sobrien { 1202104834Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt0a, 1203130561Sobrien &Subtable, TRUE); 1204130561Sobrien if (ACPI_FAILURE (Status)) 1205218822Sdim { 1206104834Sobrien return (Status); 1207104834Sobrien } 1208130561Sobrien 1209130561Sobrien 1210218822Sdim DtInsertSubtable (ParentTable, Subtable); 1211104834Sobrien GtCount--; 121277298Sobrien } 121377298Sobrien DtPopSubtable (); 1214218822Sdim break; 1215218822Sdim 121677298Sobrien default: 1217218822Sdim 1218218822Sdim break; 121989857Sobrien } 122089857Sobrien 1221107492Sobrien DtPopSubtable (); 122289857Sobrien } 122389857Sobrien 122489857Sobrien return (AE_OK); 1225107492Sobrien} 122689857Sobrien 122777298Sobrien 1228218822Sdim/****************************************************************************** 1229218822Sdim * 1230218822Sdim * FUNCTION: DtCompileFpdt 1231104834Sobrien * 1232218822Sdim * PARAMETERS: List - Current field list pointer 1233218822Sdim * 1234218822Sdim * RETURN: Status 1235218822Sdim * 1236218822Sdim * DESCRIPTION: Compile FPDT. 1237104834Sobrien * 1238104834Sobrien *****************************************************************************/ 1239218822Sdim 1240218822SdimACPI_STATUS 1241104834SobrienDtCompileFpdt ( 1242104834Sobrien void **List) 1243104834Sobrien{ 1244218822Sdim ACPI_STATUS Status; 1245218822Sdim ACPI_FPDT_HEADER *FpdtHeader; 1246104834Sobrien DT_SUBTABLE *Subtable; 1247104834Sobrien DT_SUBTABLE *ParentTable; 1248104834Sobrien ACPI_DMTABLE_INFO *InfoTable; 1249104834Sobrien DT_FIELD **PFieldList = (DT_FIELD **) List; 1250218822Sdim DT_FIELD *SubtableStart; 1251218822Sdim 1252104834Sobrien 1253104834Sobrien while (*PFieldList) 1254104834Sobrien { 1255218822Sdim SubtableStart = *PFieldList; 1256218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoFpdtHdr, 1257104834Sobrien &Subtable, TRUE); 1258104834Sobrien if (ACPI_FAILURE (Status)) 1259130561Sobrien { 1260104834Sobrien return (Status); 1261218822Sdim } 1262218822Sdim 1263104834Sobrien ParentTable = DtPeekSubtable (); 126491041Sobrien DtInsertSubtable (ParentTable, Subtable); 126591041Sobrien DtPushSubtable (Subtable); 1266218822Sdim 1267218822Sdim FpdtHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer); 1268218822Sdim 126991041Sobrien switch (FpdtHeader->Type) 1270218822Sdim { 127189857Sobrien case ACPI_FPDT_TYPE_BOOT: 127289857Sobrien 127389857Sobrien InfoTable = AcpiDmTableInfoFpdt0; 127489857Sobrien break; 1275218822Sdim 1276218822Sdim case ACPI_FPDT_TYPE_S3PERF: 1277218822Sdim 1278218822Sdim InfoTable = AcpiDmTableInfoFpdt1; 1279218822Sdim break; 1280218822Sdim 1281218822Sdim default: 1282130561Sobrien 1283104834Sobrien DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "FPDT"); 1284218822Sdim return (AE_ERROR); 1285104834Sobrien break; 1286218822Sdim } 1287104834Sobrien 1288218822Sdim Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1289218822Sdim if (ACPI_FAILURE (Status)) 1290130561Sobrien { 1291130561Sobrien return (Status); 1292130561Sobrien } 1293130561Sobrien 1294130561Sobrien ParentTable = DtPeekSubtable (); 1295218822Sdim DtInsertSubtable (ParentTable, Subtable); 1296218822Sdim DtPopSubtable (); 1297130561Sobrien } 129833965Sjdp 1299218822Sdim return (AE_OK); 130033965Sjdp} 1301218822Sdim 130233965Sjdp 1303218822Sdim/****************************************************************************** 1304218822Sdim * 1305130561Sobrien * FUNCTION: DtCompileHest 1306130561Sobrien * 1307130561Sobrien * PARAMETERS: List - Current field list pointer 1308130561Sobrien * 1309130561Sobrien * RETURN: Status 1310218822Sdim * 1311218822Sdim * DESCRIPTION: Compile HEST. 1312218822Sdim * 1313218822Sdim *****************************************************************************/ 131460484Sobrien 131560484SobrienACPI_STATUS 131660484SobrienDtCompileHest ( 131760484Sobrien void **List) 131860484Sobrien{ 1319130561Sobrien ACPI_STATUS Status; 1320218822Sdim DT_SUBTABLE *Subtable; 1321218822Sdim DT_SUBTABLE *ParentTable; 1322130561Sobrien DT_FIELD **PFieldList = (DT_FIELD **) List; 1323130561Sobrien DT_FIELD *SubtableStart; 1324130561Sobrien ACPI_DMTABLE_INFO *InfoTable; 1325130561Sobrien UINT16 Type; 1326130561Sobrien UINT32 BankCount; 1327130561Sobrien 132833965Sjdp 132938889Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest, 133033965Sjdp &Subtable, TRUE); 133133965Sjdp if (ACPI_FAILURE (Status)) 133233965Sjdp { 133333965Sjdp return (Status); 133433965Sjdp } 133533965Sjdp 133633965Sjdp ParentTable = DtPeekSubtable (); 133733965Sjdp DtInsertSubtable (ParentTable, Subtable); 133860484Sobrien 133960484Sobrien while (*PFieldList) 134060484Sobrien { 134160484Sobrien /* Get subtable type */ 134260484Sobrien 134338889Sjdp SubtableStart = *PFieldList; 134438889Sjdp DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0); 134577298Sobrien 134677298Sobrien switch (Type) 134777298Sobrien { 134833965Sjdp case ACPI_HEST_TYPE_IA32_CHECK: 134933965Sjdp 135033965Sjdp InfoTable = AcpiDmTableInfoHest0; 135133965Sjdp break; 135233965Sjdp 1353218822Sdim case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 135433965Sjdp 135560484Sobrien InfoTable = AcpiDmTableInfoHest1; 135633965Sjdp break; 135760484Sobrien 135860484Sobrien case ACPI_HEST_TYPE_IA32_NMI: 135960484Sobrien 136060484Sobrien InfoTable = AcpiDmTableInfoHest2; 136160484Sobrien break; 136233965Sjdp 136360484Sobrien case ACPI_HEST_TYPE_AER_ROOT_PORT: 136433965Sjdp 136533965Sjdp InfoTable = AcpiDmTableInfoHest6; 1366130561Sobrien break; 136760484Sobrien 136860484Sobrien case ACPI_HEST_TYPE_AER_ENDPOINT: 136960484Sobrien 1370130561Sobrien InfoTable = AcpiDmTableInfoHest7; 1371130561Sobrien break; 1372130561Sobrien 1373130561Sobrien case ACPI_HEST_TYPE_AER_BRIDGE: 137460484Sobrien 137533965Sjdp InfoTable = AcpiDmTableInfoHest8; 137633965Sjdp break; 137733965Sjdp 137860484Sobrien case ACPI_HEST_TYPE_GENERIC_ERROR: 137960484Sobrien 138060484Sobrien InfoTable = AcpiDmTableInfoHest9; 138160484Sobrien break; 1382218822Sdim 138360484Sobrien default: 138460484Sobrien 138533965Sjdp /* Cannot continue on unknown type */ 138633965Sjdp 138733965Sjdp DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HEST"); 1388218822Sdim return (AE_ERROR); 1389218822Sdim } 1390218822Sdim 1391218822Sdim Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 139238889Sjdp if (ACPI_FAILURE (Status)) 139338889Sjdp { 139438889Sjdp return (Status); 139538889Sjdp } 139638889Sjdp 139733965Sjdp DtInsertSubtable (ParentTable, Subtable); 139833965Sjdp 139933965Sjdp /* 1400218822Sdim * Additional subtable data - IA32 Error Bank(s) 140133965Sjdp */ 1402218822Sdim BankCount = 0; 140338889Sjdp switch (Type) 140438889Sjdp { 1405218822Sdim case ACPI_HEST_TYPE_IA32_CHECK: 140638889Sjdp 140733965Sjdp BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 140833965Sjdp Subtable->Buffer))->NumHardwareBanks; 140933965Sjdp break; 1410218822Sdim 141177298Sobrien case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 141233965Sjdp 141333965Sjdp BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 141433965Sjdp Subtable->Buffer))->NumHardwareBanks; 141533965Sjdp break; 1416218822Sdim 141761843Sobrien default: 141861843Sobrien 141961843Sobrien break; 1420218822Sdim } 142161843Sobrien 142261843Sobrien while (BankCount) 142361843Sobrien { 142433965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank, 1425218822Sdim &Subtable, TRUE); 1426218822Sdim if (ACPI_FAILURE (Status)) 1427218822Sdim { 1428218822Sdim return (Status); 142933965Sjdp } 143033965Sjdp 143133965Sjdp DtInsertSubtable (ParentTable, Subtable); 143233965Sjdp BankCount--; 143333965Sjdp } 143433965Sjdp } 143533965Sjdp 143660484Sobrien return (AE_OK); 143760484Sobrien} 143860484Sobrien 143960484Sobrien 144060484Sobrien/****************************************************************************** 144138889Sjdp * 144238889Sjdp * FUNCTION: DtCompileIort 144338889Sjdp * 144460484Sobrien * PARAMETERS: List - Current field list pointer 144560484Sobrien * 144660484Sobrien * RETURN: Status 144760484Sobrien * 144860484Sobrien * DESCRIPTION: Compile IORT. 144960484Sobrien * 1450104834Sobrien *****************************************************************************/ 1451104834Sobrien 1452104834SobrienACPI_STATUS 1453104834SobrienDtCompileIort ( 1454104834Sobrien void **List) 1455104834Sobrien{ 1456104834Sobrien ACPI_STATUS Status; 1457104834Sobrien DT_SUBTABLE *Subtable; 1458104834Sobrien DT_SUBTABLE *ParentTable; 1459104834Sobrien DT_FIELD **PFieldList = (DT_FIELD **) List; 1460104834Sobrien DT_FIELD *SubtableStart; 1461104834Sobrien ACPI_TABLE_IORT *Iort; 146233965Sjdp ACPI_IORT_NODE *IortNode; 1463104834Sobrien ACPI_IORT_ITS_GROUP *IortItsGroup; 146433965Sjdp ACPI_IORT_SMMU *IortSmmu; 146533965Sjdp UINT32 NodeNumber; 146633965Sjdp UINT32 NodeLength; 1467130561Sobrien UINT32 IdMappingNumber; 1468130561Sobrien UINT32 ItsNumber; 1469130561Sobrien UINT32 ContextIrptNumber; 1470130561Sobrien UINT32 PmuIrptNumber; 1471130561Sobrien UINT32 PaddingLength; 1472218822Sdim 1473130561Sobrien 1474130561Sobrien ParentTable = DtPeekSubtable (); 1475130561Sobrien 147660484Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort, 147760484Sobrien &Subtable, TRUE); 147860484Sobrien if (ACPI_FAILURE (Status)) 147960484Sobrien { 148033965Sjdp return (Status); 148133965Sjdp } 148233965Sjdp DtInsertSubtable (ParentTable, Subtable); 148333965Sjdp 148433965Sjdp /* 148533965Sjdp * Using ACPI_SUB_PTR, We needn't define a seperate structure. Care 148633965Sjdp * should be taken to avoid accessing ACPI_TABLE_HADER fields. 148733965Sjdp */ 148889857Sobrien Iort = ACPI_SUB_PTR (ACPI_TABLE_IORT, 148989857Sobrien Subtable->Buffer, sizeof (ACPI_TABLE_HEADER)); 149089857Sobrien 149189857Sobrien /* 1492130561Sobrien * OptionalPadding - Variable-length data 1493130561Sobrien * (Optional, size = OffsetToNodes - sizeof (ACPI_TABLE_IORT)) 1494130561Sobrien * Optionally allows the generic data types to be used for filling 1495130561Sobrien * this field. 1496218822Sdim */ 1497218822Sdim Iort->NodeOffset = sizeof (ACPI_TABLE_IORT); 1498218822Sdim Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortPad, 1499218822Sdim &Subtable, TRUE); 1500218822Sdim if (ACPI_FAILURE (Status)) 1501218822Sdim { 1502218822Sdim return (Status); 1503218822Sdim } 1504130561Sobrien if (Subtable) 150533965Sjdp { 150633965Sjdp DtInsertSubtable (ParentTable, Subtable); 150733965Sjdp Iort->NodeOffset += Subtable->Length; 150833965Sjdp } 150933965Sjdp else 151033965Sjdp { 151133965Sjdp Status = DtCompileGeneric (ACPI_CAST_PTR (void *, PFieldList), 151233965Sjdp AcpiDmTableInfoIortHdr[0].Name, &PaddingLength); 151333965Sjdp if (ACPI_FAILURE (Status)) 151433965Sjdp { 151533965Sjdp return (Status); 151633965Sjdp } 151733965Sjdp Iort->NodeOffset += PaddingLength; 151833965Sjdp } 151933965Sjdp 152033965Sjdp NodeNumber = 0; 152133965Sjdp while (*PFieldList) 152233965Sjdp { 152333965Sjdp SubtableStart = *PFieldList; 152433965Sjdp Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortHdr, 152533965Sjdp &Subtable, TRUE); 152633965Sjdp if (ACPI_FAILURE (Status)) 152733965Sjdp { 152833965Sjdp return (Status); 152933965Sjdp } 153033965Sjdp DtInsertSubtable (ParentTable, Subtable); 153133965Sjdp IortNode = ACPI_CAST_PTR (ACPI_IORT_NODE, Subtable->Buffer); 153233965Sjdp NodeLength = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); 153333965Sjdp 153433965Sjdp DtPushSubtable (Subtable); 153560484Sobrien ParentTable = DtPeekSubtable (); 153689857Sobrien 153789857Sobrien switch (IortNode->Type) 153889857Sobrien { 153989857Sobrien case ACPI_IORT_NODE_ITS_GROUP: 154089857Sobrien 154189857Sobrien Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0, 154260484Sobrien &Subtable, TRUE); 154360484Sobrien if (ACPI_FAILURE (Status)) 154460484Sobrien { 154560484Sobrien return (Status); 154660484Sobrien } 1547130561Sobrien DtInsertSubtable (ParentTable, Subtable); 154860484Sobrien IortItsGroup = ACPI_CAST_PTR (ACPI_IORT_ITS_GROUP, Subtable->Buffer); 154960484Sobrien NodeLength += Subtable->Length; 155060484Sobrien 155160484Sobrien ItsNumber = 0; 155260484Sobrien while (*PFieldList) 155360484Sobrien { 1554 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0a, 1555 &Subtable, TRUE); 1556 if (ACPI_FAILURE (Status)) 1557 { 1558 return (Status); 1559 } 1560 if (!Subtable) 1561 { 1562 break; 1563 } 1564 DtInsertSubtable (ParentTable, Subtable); 1565 NodeLength += Subtable->Length; 1566 ItsNumber++; 1567 } 1568 1569 IortItsGroup->ItsCount = ItsNumber; 1570 break; 1571 1572 case ACPI_IORT_NODE_NAMED_COMPONENT: 1573 1574 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1, 1575 &Subtable, TRUE); 1576 if (ACPI_FAILURE (Status)) 1577 { 1578 return (Status); 1579 } 1580 DtInsertSubtable (ParentTable, Subtable); 1581 NodeLength += Subtable->Length; 1582 1583 /* 1584 * Padding - Variable-length data 1585 * Optionally allows the offset of the ID mappings to be used 1586 * for filling this field. 1587 */ 1588 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1a, 1589 &Subtable, TRUE); 1590 if (ACPI_FAILURE (Status)) 1591 { 1592 return (Status); 1593 } 1594 if (Subtable) 1595 { 1596 DtInsertSubtable (ParentTable, Subtable); 1597 NodeLength += Subtable->Length; 1598 } 1599 else 1600 { 1601 if (NodeLength > IortNode->MappingOffset) 1602 { 1603 return (AE_BAD_DATA); 1604 } 1605 if (NodeLength < IortNode->MappingOffset) 1606 { 1607 Status = DtCompilePadding ( 1608 IortNode->MappingOffset - NodeLength, 1609 &Subtable); 1610 if (ACPI_FAILURE (Status)) 1611 { 1612 return (Status); 1613 } 1614 DtInsertSubtable (ParentTable, Subtable); 1615 NodeLength = IortNode->MappingOffset; 1616 } 1617 } 1618 break; 1619 1620 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: 1621 1622 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort2, 1623 &Subtable, TRUE); 1624 if (ACPI_FAILURE (Status)) 1625 { 1626 return (Status); 1627 } 1628 DtInsertSubtable (ParentTable, Subtable); 1629 NodeLength += Subtable->Length; 1630 break; 1631 1632 case ACPI_IORT_NODE_SMMU: 1633 1634 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3, 1635 &Subtable, TRUE); 1636 if (ACPI_FAILURE (Status)) 1637 { 1638 return (Status); 1639 } 1640 DtInsertSubtable (ParentTable, Subtable); 1641 IortSmmu = ACPI_CAST_PTR (ACPI_IORT_SMMU, Subtable->Buffer); 1642 NodeLength += Subtable->Length; 1643 1644 /* Compile global interrupt array */ 1645 1646 IortSmmu->GlobalInterruptOffset = NodeLength; 1647 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3a, 1648 &Subtable, TRUE); 1649 if (ACPI_FAILURE (Status)) 1650 { 1651 return (Status); 1652 } 1653 DtInsertSubtable (ParentTable, Subtable); 1654 NodeLength += Subtable->Length; 1655 1656 /* Compile context interrupt array */ 1657 1658 ContextIrptNumber = 0; 1659 IortSmmu->ContextInterruptOffset = NodeLength; 1660 while (*PFieldList) 1661 { 1662 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3b, 1663 &Subtable, TRUE); 1664 if (ACPI_FAILURE (Status)) 1665 { 1666 return (Status); 1667 } 1668 if (!Subtable) 1669 { 1670 break; 1671 } 1672 DtInsertSubtable (ParentTable, Subtable); 1673 NodeLength += Subtable->Length; 1674 ContextIrptNumber++; 1675 } 1676 IortSmmu->ContextInterruptCount = ContextIrptNumber; 1677 1678 /* Compile PMU interrupt array */ 1679 1680 PmuIrptNumber = 0; 1681 IortSmmu->PmuInterruptOffset = NodeLength; 1682 while (*PFieldList) 1683 { 1684 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3c, 1685 &Subtable, TRUE); 1686 if (ACPI_FAILURE (Status)) 1687 { 1688 return (Status); 1689 } 1690 if (!Subtable) 1691 { 1692 break; 1693 } 1694 DtInsertSubtable (ParentTable, Subtable); 1695 NodeLength += Subtable->Length; 1696 PmuIrptNumber++; 1697 } 1698 IortSmmu->PmuInterruptCount = PmuIrptNumber; 1699 break; 1700 1701 default: 1702 1703 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IORT"); 1704 return (AE_ERROR); 1705 } 1706 1707 /* Compile Array of ID mappings */ 1708 1709 IortNode->MappingOffset = NodeLength; 1710 IdMappingNumber = 0; 1711 while (*PFieldList) 1712 { 1713 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortMap, 1714 &Subtable, TRUE); 1715 if (ACPI_FAILURE (Status)) 1716 { 1717 return (Status); 1718 } 1719 if (!Subtable) 1720 { 1721 break; 1722 } 1723 DtInsertSubtable (ParentTable, Subtable); 1724 NodeLength += sizeof (ACPI_IORT_ID_MAPPING); 1725 IdMappingNumber++; 1726 } 1727 IortNode->MappingCount = IdMappingNumber; 1728 1729 /* 1730 * Node length can be determined by DT_LENGTH option 1731 * IortNode->Length = NodeLength; 1732 */ 1733 DtPopSubtable (); 1734 ParentTable = DtPeekSubtable (); 1735 NodeNumber++; 1736 } 1737 Iort->NodeCount = NodeNumber; 1738 1739 return (AE_OK); 1740} 1741 1742 1743/****************************************************************************** 1744 * 1745 * FUNCTION: DtCompileIvrs 1746 * 1747 * PARAMETERS: List - Current field list pointer 1748 * 1749 * RETURN: Status 1750 * 1751 * DESCRIPTION: Compile IVRS. 1752 * 1753 *****************************************************************************/ 1754 1755ACPI_STATUS 1756DtCompileIvrs ( 1757 void **List) 1758{ 1759 ACPI_STATUS Status; 1760 DT_SUBTABLE *Subtable; 1761 DT_SUBTABLE *ParentTable; 1762 DT_FIELD **PFieldList = (DT_FIELD **) List; 1763 DT_FIELD *SubtableStart; 1764 ACPI_DMTABLE_INFO *InfoTable; 1765 ACPI_IVRS_HEADER *IvrsHeader; 1766 UINT8 EntryType; 1767 1768 1769 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs, 1770 &Subtable, TRUE); 1771 if (ACPI_FAILURE (Status)) 1772 { 1773 return (Status); 1774 } 1775 1776 ParentTable = DtPeekSubtable (); 1777 DtInsertSubtable (ParentTable, Subtable); 1778 1779 while (*PFieldList) 1780 { 1781 SubtableStart = *PFieldList; 1782 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHdr, 1783 &Subtable, TRUE); 1784 if (ACPI_FAILURE (Status)) 1785 { 1786 return (Status); 1787 } 1788 1789 ParentTable = DtPeekSubtable (); 1790 DtInsertSubtable (ParentTable, Subtable); 1791 DtPushSubtable (Subtable); 1792 1793 IvrsHeader = ACPI_CAST_PTR (ACPI_IVRS_HEADER, Subtable->Buffer); 1794 1795 switch (IvrsHeader->Type) 1796 { 1797 case ACPI_IVRS_TYPE_HARDWARE: 1798 1799 InfoTable = AcpiDmTableInfoIvrs0; 1800 break; 1801 1802 case ACPI_IVRS_TYPE_MEMORY1: 1803 case ACPI_IVRS_TYPE_MEMORY2: 1804 case ACPI_IVRS_TYPE_MEMORY3: 1805 1806 InfoTable = AcpiDmTableInfoIvrs1; 1807 break; 1808 1809 default: 1810 1811 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IVRS"); 1812 return (AE_ERROR); 1813 } 1814 1815 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1816 if (ACPI_FAILURE (Status)) 1817 { 1818 return (Status); 1819 } 1820 1821 ParentTable = DtPeekSubtable (); 1822 DtInsertSubtable (ParentTable, Subtable); 1823 1824 if (IvrsHeader->Type == ACPI_IVRS_TYPE_HARDWARE) 1825 { 1826 while (*PFieldList && 1827 !ACPI_STRCMP ((*PFieldList)->Name, "Entry Type")) 1828 { 1829 SubtableStart = *PFieldList; 1830 DtCompileInteger (&EntryType, *PFieldList, 1, 0); 1831 1832 switch (EntryType) 1833 { 1834 /* 4-byte device entries */ 1835 1836 case ACPI_IVRS_TYPE_PAD4: 1837 case ACPI_IVRS_TYPE_ALL: 1838 case ACPI_IVRS_TYPE_SELECT: 1839 case ACPI_IVRS_TYPE_START: 1840 case ACPI_IVRS_TYPE_END: 1841 1842 InfoTable = AcpiDmTableInfoIvrs4; 1843 break; 1844 1845 /* 8-byte entries, type A */ 1846 1847 case ACPI_IVRS_TYPE_ALIAS_SELECT: 1848 case ACPI_IVRS_TYPE_ALIAS_START: 1849 1850 InfoTable = AcpiDmTableInfoIvrs8a; 1851 break; 1852 1853 /* 8-byte entries, type B */ 1854 1855 case ACPI_IVRS_TYPE_PAD8: 1856 case ACPI_IVRS_TYPE_EXT_SELECT: 1857 case ACPI_IVRS_TYPE_EXT_START: 1858 1859 InfoTable = AcpiDmTableInfoIvrs8b; 1860 break; 1861 1862 /* 8-byte entries, type C */ 1863 1864 case ACPI_IVRS_TYPE_SPECIAL: 1865 1866 InfoTable = AcpiDmTableInfoIvrs8c; 1867 break; 1868 1869 default: 1870 1871 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, 1872 "IVRS Device Entry"); 1873 return (AE_ERROR); 1874 } 1875 1876 Status = DtCompileTable (PFieldList, InfoTable, 1877 &Subtable, TRUE); 1878 if (ACPI_FAILURE (Status)) 1879 { 1880 return (Status); 1881 } 1882 1883 DtInsertSubtable (ParentTable, Subtable); 1884 } 1885 } 1886 1887 DtPopSubtable (); 1888 } 1889 1890 return (AE_OK); 1891} 1892 1893 1894/****************************************************************************** 1895 * 1896 * FUNCTION: DtCompileLpit 1897 * 1898 * PARAMETERS: List - Current field list pointer 1899 * 1900 * RETURN: Status 1901 * 1902 * DESCRIPTION: Compile LPIT. 1903 * 1904 *****************************************************************************/ 1905 1906ACPI_STATUS 1907DtCompileLpit ( 1908 void **List) 1909{ 1910 ACPI_STATUS Status; 1911 DT_SUBTABLE *Subtable; 1912 DT_SUBTABLE *ParentTable; 1913 DT_FIELD **PFieldList = (DT_FIELD **) List; 1914 DT_FIELD *SubtableStart; 1915 ACPI_DMTABLE_INFO *InfoTable; 1916 ACPI_LPIT_HEADER *LpitHeader; 1917 1918 1919 /* Note: Main table consists only of the standard ACPI table header */ 1920 1921 while (*PFieldList) 1922 { 1923 SubtableStart = *PFieldList; 1924 1925 /* LPIT Subtable header */ 1926 1927 Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr, 1928 &Subtable, TRUE); 1929 if (ACPI_FAILURE (Status)) 1930 { 1931 return (Status); 1932 } 1933 1934 ParentTable = DtPeekSubtable (); 1935 DtInsertSubtable (ParentTable, Subtable); 1936 DtPushSubtable (Subtable); 1937 1938 LpitHeader = ACPI_CAST_PTR (ACPI_LPIT_HEADER, Subtable->Buffer); 1939 1940 switch (LpitHeader->Type) 1941 { 1942 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 1943 1944 InfoTable = AcpiDmTableInfoLpit0; 1945 break; 1946 1947 default: 1948 1949 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "LPIT"); 1950 return (AE_ERROR); 1951 } 1952 1953 /* LPIT Subtable */ 1954 1955 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1956 if (ACPI_FAILURE (Status)) 1957 { 1958 return (Status); 1959 } 1960 1961 ParentTable = DtPeekSubtable (); 1962 DtInsertSubtable (ParentTable, Subtable); 1963 DtPopSubtable (); 1964 } 1965 1966 return (AE_OK); 1967} 1968 1969 1970/****************************************************************************** 1971 * 1972 * FUNCTION: DtCompileMadt 1973 * 1974 * PARAMETERS: List - Current field list pointer 1975 * 1976 * RETURN: Status 1977 * 1978 * DESCRIPTION: Compile MADT. 1979 * 1980 *****************************************************************************/ 1981 1982ACPI_STATUS 1983DtCompileMadt ( 1984 void **List) 1985{ 1986 ACPI_STATUS Status; 1987 DT_SUBTABLE *Subtable; 1988 DT_SUBTABLE *ParentTable; 1989 DT_FIELD **PFieldList = (DT_FIELD **) List; 1990 DT_FIELD *SubtableStart; 1991 ACPI_SUBTABLE_HEADER *MadtHeader; 1992 ACPI_DMTABLE_INFO *InfoTable; 1993 1994 1995 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt, 1996 &Subtable, TRUE); 1997 if (ACPI_FAILURE (Status)) 1998 { 1999 return (Status); 2000 } 2001 2002 ParentTable = DtPeekSubtable (); 2003 DtInsertSubtable (ParentTable, Subtable); 2004 2005 while (*PFieldList) 2006 { 2007 SubtableStart = *PFieldList; 2008 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr, 2009 &Subtable, TRUE); 2010 if (ACPI_FAILURE (Status)) 2011 { 2012 return (Status); 2013 } 2014 2015 ParentTable = DtPeekSubtable (); 2016 DtInsertSubtable (ParentTable, Subtable); 2017 DtPushSubtable (Subtable); 2018 2019 MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 2020 2021 switch (MadtHeader->Type) 2022 { 2023 case ACPI_MADT_TYPE_LOCAL_APIC: 2024 2025 InfoTable = AcpiDmTableInfoMadt0; 2026 break; 2027 2028 case ACPI_MADT_TYPE_IO_APIC: 2029 2030 InfoTable = AcpiDmTableInfoMadt1; 2031 break; 2032 2033 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 2034 2035 InfoTable = AcpiDmTableInfoMadt2; 2036 break; 2037 2038 case ACPI_MADT_TYPE_NMI_SOURCE: 2039 2040 InfoTable = AcpiDmTableInfoMadt3; 2041 break; 2042 2043 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 2044 2045 InfoTable = AcpiDmTableInfoMadt4; 2046 break; 2047 2048 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 2049 2050 InfoTable = AcpiDmTableInfoMadt5; 2051 break; 2052 2053 case ACPI_MADT_TYPE_IO_SAPIC: 2054 2055 InfoTable = AcpiDmTableInfoMadt6; 2056 break; 2057 2058 case ACPI_MADT_TYPE_LOCAL_SAPIC: 2059 2060 InfoTable = AcpiDmTableInfoMadt7; 2061 break; 2062 2063 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 2064 2065 InfoTable = AcpiDmTableInfoMadt8; 2066 break; 2067 2068 case ACPI_MADT_TYPE_LOCAL_X2APIC: 2069 2070 InfoTable = AcpiDmTableInfoMadt9; 2071 break; 2072 2073 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 2074 2075 InfoTable = AcpiDmTableInfoMadt10; 2076 break; 2077 2078 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 2079 2080 InfoTable = AcpiDmTableInfoMadt11; 2081 break; 2082 2083 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 2084 2085 InfoTable = AcpiDmTableInfoMadt12; 2086 break; 2087 2088 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 2089 2090 InfoTable = AcpiDmTableInfoMadt13; 2091 break; 2092 2093 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 2094 2095 InfoTable = AcpiDmTableInfoMadt14; 2096 break; 2097 2098 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 2099 2100 InfoTable = AcpiDmTableInfoMadt15; 2101 break; 2102 2103 default: 2104 2105 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT"); 2106 return (AE_ERROR); 2107 } 2108 2109 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 2110 if (ACPI_FAILURE (Status)) 2111 { 2112 return (Status); 2113 } 2114 2115 ParentTable = DtPeekSubtable (); 2116 DtInsertSubtable (ParentTable, Subtable); 2117 DtPopSubtable (); 2118 } 2119 2120 return (AE_OK); 2121} 2122 2123 2124/****************************************************************************** 2125 * 2126 * FUNCTION: DtCompileMcfg 2127 * 2128 * PARAMETERS: List - Current field list pointer 2129 * 2130 * RETURN: Status 2131 * 2132 * DESCRIPTION: Compile MCFG. 2133 * 2134 *****************************************************************************/ 2135 2136ACPI_STATUS 2137DtCompileMcfg ( 2138 void **List) 2139{ 2140 ACPI_STATUS Status; 2141 2142 2143 Status = DtCompileTwoSubtables (List, 2144 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0); 2145 return (Status); 2146} 2147 2148 2149/****************************************************************************** 2150 * 2151 * FUNCTION: DtCompileMpst 2152 * 2153 * PARAMETERS: List - Current field list pointer 2154 * 2155 * RETURN: Status 2156 * 2157 * DESCRIPTION: Compile MPST. 2158 * 2159 *****************************************************************************/ 2160 2161ACPI_STATUS 2162DtCompileMpst ( 2163 void **List) 2164{ 2165 ACPI_STATUS Status; 2166 DT_SUBTABLE *Subtable; 2167 DT_SUBTABLE *ParentTable; 2168 DT_FIELD **PFieldList = (DT_FIELD **) List; 2169 ACPI_MPST_CHANNEL *MpstChannelInfo; 2170 ACPI_MPST_POWER_NODE *MpstPowerNode; 2171 ACPI_MPST_DATA_HDR *MpstDataHeader; 2172 UINT16 SubtableCount; 2173 UINT32 PowerStateCount; 2174 UINT32 ComponentCount; 2175 2176 2177 /* Main table */ 2178 2179 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable, TRUE); 2180 if (ACPI_FAILURE (Status)) 2181 { 2182 return (Status); 2183 } 2184 2185 ParentTable = DtPeekSubtable (); 2186 DtInsertSubtable (ParentTable, Subtable); 2187 DtPushSubtable (Subtable); 2188 2189 MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer); 2190 SubtableCount = MpstChannelInfo->PowerNodeCount; 2191 2192 while (*PFieldList && SubtableCount) 2193 { 2194 /* Subtable: Memory Power Node(s) */ 2195 2196 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0, 2197 &Subtable, TRUE); 2198 if (ACPI_FAILURE (Status)) 2199 { 2200 return (Status); 2201 } 2202 2203 ParentTable = DtPeekSubtable (); 2204 DtInsertSubtable (ParentTable, Subtable); 2205 DtPushSubtable (Subtable); 2206 2207 MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer); 2208 PowerStateCount = MpstPowerNode->NumPowerStates; 2209 ComponentCount = MpstPowerNode->NumPhysicalComponents; 2210 2211 ParentTable = DtPeekSubtable (); 2212 2213 /* Sub-subtables - Memory Power State Structure(s) */ 2214 2215 while (*PFieldList && PowerStateCount) 2216 { 2217 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A, 2218 &Subtable, TRUE); 2219 if (ACPI_FAILURE (Status)) 2220 { 2221 return (Status); 2222 } 2223 2224 DtInsertSubtable (ParentTable, Subtable); 2225 PowerStateCount--; 2226 } 2227 2228 /* Sub-subtables - Physical Component ID Structure(s) */ 2229 2230 while (*PFieldList && ComponentCount) 2231 { 2232 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B, 2233 &Subtable, TRUE); 2234 if (ACPI_FAILURE (Status)) 2235 { 2236 return (Status); 2237 } 2238 2239 DtInsertSubtable (ParentTable, Subtable); 2240 ComponentCount--; 2241 } 2242 2243 SubtableCount--; 2244 DtPopSubtable (); 2245 } 2246 2247 /* Subtable: Count of Memory Power State Characteristic structures */ 2248 2249 DtPopSubtable (); 2250 2251 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable, TRUE); 2252 if (ACPI_FAILURE (Status)) 2253 { 2254 return (Status); 2255 } 2256 2257 ParentTable = DtPeekSubtable (); 2258 DtInsertSubtable (ParentTable, Subtable); 2259 DtPushSubtable (Subtable); 2260 2261 MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer); 2262 SubtableCount = MpstDataHeader->CharacteristicsCount; 2263 2264 ParentTable = DtPeekSubtable (); 2265 2266 /* Subtable: Memory Power State Characteristics structure(s) */ 2267 2268 while (*PFieldList && SubtableCount) 2269 { 2270 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2, 2271 &Subtable, TRUE); 2272 if (ACPI_FAILURE (Status)) 2273 { 2274 return (Status); 2275 } 2276 2277 DtInsertSubtable (ParentTable, Subtable); 2278 SubtableCount--; 2279 } 2280 2281 DtPopSubtable (); 2282 return (AE_OK); 2283} 2284 2285 2286/****************************************************************************** 2287 * 2288 * FUNCTION: DtCompileMsct 2289 * 2290 * PARAMETERS: List - Current field list pointer 2291 * 2292 * RETURN: Status 2293 * 2294 * DESCRIPTION: Compile MSCT. 2295 * 2296 *****************************************************************************/ 2297 2298ACPI_STATUS 2299DtCompileMsct ( 2300 void **List) 2301{ 2302 ACPI_STATUS Status; 2303 2304 2305 Status = DtCompileTwoSubtables (List, 2306 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0); 2307 return (Status); 2308} 2309 2310 2311/****************************************************************************** 2312 * 2313 * FUNCTION: DtCompileMtmr 2314 * 2315 * PARAMETERS: List - Current field list pointer 2316 * 2317 * RETURN: Status 2318 * 2319 * DESCRIPTION: Compile MTMR. 2320 * 2321 *****************************************************************************/ 2322 2323ACPI_STATUS 2324DtCompileMtmr ( 2325 void **List) 2326{ 2327 ACPI_STATUS Status; 2328 2329 2330 Status = DtCompileTwoSubtables (List, 2331 AcpiDmTableInfoMtmr, AcpiDmTableInfoMtmr0); 2332 return (Status); 2333} 2334 2335 2336/****************************************************************************** 2337 * 2338 * FUNCTION: DtCompileNfit 2339 * 2340 * PARAMETERS: List - Current field list pointer 2341 * 2342 * RETURN: Status 2343 * 2344 * DESCRIPTION: Compile NFIT. 2345 * 2346 *****************************************************************************/ 2347 2348ACPI_STATUS 2349DtCompileNfit ( 2350 void **List) 2351{ 2352 ACPI_STATUS Status; 2353 DT_SUBTABLE *Subtable; 2354 DT_SUBTABLE *ParentTable; 2355 DT_FIELD **PFieldList = (DT_FIELD **) List; 2356 DT_FIELD *SubtableStart; 2357 ACPI_NFIT_HEADER *NfitHeader; 2358 ACPI_DMTABLE_INFO *InfoTable; 2359 UINT32 Count; 2360 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 2361 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 2362 2363 /* Main table */ 2364 2365 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit, 2366 &Subtable, TRUE); 2367 if (ACPI_FAILURE (Status)) 2368 { 2369 return (Status); 2370 } 2371 2372 ParentTable = DtPeekSubtable (); 2373 DtInsertSubtable (ParentTable, Subtable); 2374 DtPushSubtable (Subtable); 2375 2376 /* Subtables */ 2377 2378 while (*PFieldList) 2379 { 2380 SubtableStart = *PFieldList; 2381 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr, 2382 &Subtable, TRUE); 2383 if (ACPI_FAILURE (Status)) 2384 { 2385 return (Status); 2386 } 2387 2388 ParentTable = DtPeekSubtable (); 2389 DtInsertSubtable (ParentTable, Subtable); 2390 DtPushSubtable (Subtable); 2391 2392 NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer); 2393 2394 switch (NfitHeader->Type) 2395 { 2396 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 2397 2398 InfoTable = AcpiDmTableInfoNfit0; 2399 break; 2400 2401 case ACPI_NFIT_TYPE_MEMORY_MAP: 2402 2403 InfoTable = AcpiDmTableInfoNfit1; 2404 break; 2405 2406 case ACPI_NFIT_TYPE_INTERLEAVE: 2407 2408 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer); 2409 InfoTable = AcpiDmTableInfoNfit2; 2410 break; 2411 2412 case ACPI_NFIT_TYPE_SMBIOS: 2413 2414 InfoTable = AcpiDmTableInfoNfit3; 2415 break; 2416 2417 case ACPI_NFIT_TYPE_CONTROL_REGION: 2418 2419 InfoTable = AcpiDmTableInfoNfit4; 2420 break; 2421 2422 case ACPI_NFIT_TYPE_DATA_REGION: 2423 2424 InfoTable = AcpiDmTableInfoNfit5; 2425 break; 2426 2427 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 2428 2429 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer); 2430 InfoTable = AcpiDmTableInfoNfit6; 2431 break; 2432 2433 default: 2434 2435 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT"); 2436 return (AE_ERROR); 2437 } 2438 2439 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 2440 if (ACPI_FAILURE (Status)) 2441 { 2442 return (Status); 2443 } 2444 2445 ParentTable = DtPeekSubtable (); 2446 DtInsertSubtable (ParentTable, Subtable); 2447 DtPopSubtable (); 2448 2449 switch (NfitHeader->Type) 2450 { 2451 case ACPI_NFIT_TYPE_INTERLEAVE: 2452 2453 Count = 0; 2454 DtPushSubtable (Subtable); 2455 while (*PFieldList) 2456 { 2457 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a, 2458 &Subtable, FALSE); 2459 if (ACPI_FAILURE (Status)) 2460 { 2461 return (Status); 2462 } 2463 if (!Subtable) 2464 { 2465 DtPopSubtable (); 2466 break; 2467 } 2468 2469 ParentTable = DtPeekSubtable (); 2470 DtInsertSubtable (ParentTable, Subtable); 2471 Count++; 2472 } 2473 2474 Interleave->LineCount = Count; 2475 DtPopSubtable (); 2476 break; 2477 2478 case ACPI_NFIT_TYPE_SMBIOS: 2479 2480 if (*PFieldList) 2481 { 2482 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a, 2483 &Subtable, TRUE); 2484 if (ACPI_FAILURE (Status)) 2485 { 2486 return (Status); 2487 } 2488 if (Subtable) 2489 { 2490 DtInsertSubtable (ParentTable, Subtable); 2491 } 2492 } 2493 break; 2494 2495 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 2496 2497 Count = 0; 2498 DtPushSubtable (Subtable); 2499 while (*PFieldList) 2500 { 2501 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a, 2502 &Subtable, FALSE); 2503 if (ACPI_FAILURE (Status)) 2504 { 2505 return (Status); 2506 } 2507 if (!Subtable) 2508 { 2509 DtPopSubtable (); 2510 break; 2511 } 2512 2513 ParentTable = DtPeekSubtable (); 2514 DtInsertSubtable (ParentTable, Subtable); 2515 Count++; 2516 } 2517 2518 Hint->HintCount = (UINT16) Count; 2519 DtPopSubtable (); 2520 break; 2521 2522 default: 2523 break; 2524 } 2525 } 2526 2527 return (AE_OK); 2528} 2529 2530 2531/****************************************************************************** 2532 * 2533 * FUNCTION: DtCompilePcct 2534 * 2535 * PARAMETERS: List - Current field list pointer 2536 * 2537 * RETURN: Status 2538 * 2539 * DESCRIPTION: Compile PCCT. 2540 * 2541 *****************************************************************************/ 2542 2543ACPI_STATUS 2544DtCompilePcct ( 2545 void **List) 2546{ 2547 ACPI_STATUS Status; 2548 DT_SUBTABLE *Subtable; 2549 DT_SUBTABLE *ParentTable; 2550 DT_FIELD **PFieldList = (DT_FIELD **) List; 2551 DT_FIELD *SubtableStart; 2552 ACPI_SUBTABLE_HEADER *PcctHeader; 2553 ACPI_DMTABLE_INFO *InfoTable; 2554 2555 2556 /* Main table */ 2557 2558 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct, 2559 &Subtable, TRUE); 2560 if (ACPI_FAILURE (Status)) 2561 { 2562 return (Status); 2563 } 2564 2565 ParentTable = DtPeekSubtable (); 2566 DtInsertSubtable (ParentTable, Subtable); 2567 2568 /* Subtables */ 2569 2570 while (*PFieldList) 2571 { 2572 SubtableStart = *PFieldList; 2573 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr, 2574 &Subtable, TRUE); 2575 if (ACPI_FAILURE (Status)) 2576 { 2577 return (Status); 2578 } 2579 2580 ParentTable = DtPeekSubtable (); 2581 DtInsertSubtable (ParentTable, Subtable); 2582 DtPushSubtable (Subtable); 2583 2584 PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 2585 2586 switch (PcctHeader->Type) 2587 { 2588 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 2589 2590 InfoTable = AcpiDmTableInfoPcct0; 2591 break; 2592 2593 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 2594 2595 InfoTable = AcpiDmTableInfoPcct1; 2596 break; 2597 2598 default: 2599 2600 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT"); 2601 return (AE_ERROR); 2602 } 2603 2604 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 2605 if (ACPI_FAILURE (Status)) 2606 { 2607 return (Status); 2608 } 2609 2610 ParentTable = DtPeekSubtable (); 2611 DtInsertSubtable (ParentTable, Subtable); 2612 DtPopSubtable (); 2613 } 2614 2615 return (AE_OK); 2616} 2617 2618 2619/****************************************************************************** 2620 * 2621 * FUNCTION: DtCompilePmtt 2622 * 2623 * PARAMETERS: List - Current field list pointer 2624 * 2625 * RETURN: Status 2626 * 2627 * DESCRIPTION: Compile PMTT. 2628 * 2629 *****************************************************************************/ 2630 2631ACPI_STATUS 2632DtCompilePmtt ( 2633 void **List) 2634{ 2635 ACPI_STATUS Status; 2636 DT_SUBTABLE *Subtable; 2637 DT_SUBTABLE *ParentTable; 2638 DT_FIELD **PFieldList = (DT_FIELD **) List; 2639 DT_FIELD *SubtableStart; 2640 ACPI_PMTT_HEADER *PmttHeader; 2641 ACPI_PMTT_CONTROLLER *PmttController; 2642 UINT16 DomainCount; 2643 UINT8 PrevType = ACPI_PMTT_TYPE_SOCKET; 2644 2645 2646 /* Main table */ 2647 2648 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE); 2649 if (ACPI_FAILURE (Status)) 2650 { 2651 return (Status); 2652 } 2653 2654 ParentTable = DtPeekSubtable (); 2655 DtInsertSubtable (ParentTable, Subtable); 2656 DtPushSubtable (Subtable); 2657 2658 while (*PFieldList) 2659 { 2660 SubtableStart = *PFieldList; 2661 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr, 2662 &Subtable, TRUE); 2663 if (ACPI_FAILURE (Status)) 2664 { 2665 return (Status); 2666 } 2667 2668 PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer); 2669 while (PrevType >= PmttHeader->Type) 2670 { 2671 DtPopSubtable (); 2672 2673 if (PrevType == ACPI_PMTT_TYPE_SOCKET) 2674 { 2675 break; 2676 } 2677 PrevType--; 2678 } 2679 PrevType = PmttHeader->Type; 2680 2681 ParentTable = DtPeekSubtable (); 2682 DtInsertSubtable (ParentTable, Subtable); 2683 DtPushSubtable (Subtable); 2684 2685 switch (PmttHeader->Type) 2686 { 2687 case ACPI_PMTT_TYPE_SOCKET: 2688 2689 /* Subtable: Socket Structure */ 2690 2691 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0, 2692 &Subtable, TRUE); 2693 if (ACPI_FAILURE (Status)) 2694 { 2695 return (Status); 2696 } 2697 2698 ParentTable = DtPeekSubtable (); 2699 DtInsertSubtable (ParentTable, Subtable); 2700 break; 2701 2702 case ACPI_PMTT_TYPE_CONTROLLER: 2703 2704 /* Subtable: Memory Controller Structure */ 2705 2706 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1, 2707 &Subtable, TRUE); 2708 if (ACPI_FAILURE (Status)) 2709 { 2710 return (Status); 2711 } 2712 2713 ParentTable = DtPeekSubtable (); 2714 DtInsertSubtable (ParentTable, Subtable); 2715 2716 PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER, 2717 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER))); 2718 DomainCount = PmttController->DomainCount; 2719 2720 while (DomainCount) 2721 { 2722 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a, 2723 &Subtable, TRUE); 2724 if (ACPI_FAILURE (Status)) 2725 { 2726 return (Status); 2727 } 2728 2729 DtInsertSubtable (ParentTable, Subtable); 2730 DomainCount--; 2731 } 2732 break; 2733 2734 case ACPI_PMTT_TYPE_DIMM: 2735 2736 /* Subtable: Physical Component Structure */ 2737 2738 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2, 2739 &Subtable, TRUE); 2740 if (ACPI_FAILURE (Status)) 2741 { 2742 return (Status); 2743 } 2744 2745 ParentTable = DtPeekSubtable (); 2746 DtInsertSubtable (ParentTable, Subtable); 2747 break; 2748 2749 default: 2750 2751 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT"); 2752 return (AE_ERROR); 2753 } 2754 } 2755 2756 return (Status); 2757} 2758 2759 2760/****************************************************************************** 2761 * 2762 * FUNCTION: DtCompileRsdt 2763 * 2764 * PARAMETERS: List - Current field list pointer 2765 * 2766 * RETURN: Status 2767 * 2768 * DESCRIPTION: Compile RSDT. 2769 * 2770 *****************************************************************************/ 2771 2772ACPI_STATUS 2773DtCompileRsdt ( 2774 void **List) 2775{ 2776 DT_SUBTABLE *Subtable; 2777 DT_SUBTABLE *ParentTable; 2778 DT_FIELD *FieldList = *(DT_FIELD **) List; 2779 UINT32 Address; 2780 2781 2782 ParentTable = DtPeekSubtable (); 2783 2784 while (FieldList) 2785 { 2786 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO); 2787 2788 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable); 2789 DtInsertSubtable (ParentTable, Subtable); 2790 FieldList = FieldList->Next; 2791 } 2792 2793 return (AE_OK); 2794} 2795 2796 2797/****************************************************************************** 2798 * 2799 * FUNCTION: DtCompileS3pt 2800 * 2801 * PARAMETERS: PFieldList - Current field list pointer 2802 * 2803 * RETURN: Status 2804 * 2805 * DESCRIPTION: Compile S3PT (Pointed to by FPDT) 2806 * 2807 *****************************************************************************/ 2808 2809ACPI_STATUS 2810DtCompileS3pt ( 2811 DT_FIELD **PFieldList) 2812{ 2813 ACPI_STATUS Status; 2814 ACPI_S3PT_HEADER *S3ptHeader; 2815 DT_SUBTABLE *Subtable; 2816 DT_SUBTABLE *ParentTable; 2817 ACPI_DMTABLE_INFO *InfoTable; 2818 DT_FIELD *SubtableStart; 2819 2820 2821 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt, 2822 &Gbl_RootTable, TRUE); 2823 if (ACPI_FAILURE (Status)) 2824 { 2825 return (Status); 2826 } 2827 2828 DtPushSubtable (Gbl_RootTable); 2829 2830 while (*PFieldList) 2831 { 2832 SubtableStart = *PFieldList; 2833 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr, 2834 &Subtable, TRUE); 2835 if (ACPI_FAILURE (Status)) 2836 { 2837 return (Status); 2838 } 2839 2840 ParentTable = DtPeekSubtable (); 2841 DtInsertSubtable (ParentTable, Subtable); 2842 DtPushSubtable (Subtable); 2843 2844 S3ptHeader = ACPI_CAST_PTR (ACPI_S3PT_HEADER, Subtable->Buffer); 2845 2846 switch (S3ptHeader->Type) 2847 { 2848 case ACPI_S3PT_TYPE_RESUME: 2849 2850 InfoTable = AcpiDmTableInfoS3pt0; 2851 break; 2852 2853 case ACPI_S3PT_TYPE_SUSPEND: 2854 2855 InfoTable = AcpiDmTableInfoS3pt1; 2856 break; 2857 2858 default: 2859 2860 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT"); 2861 return (AE_ERROR); 2862 } 2863 2864 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 2865 if (ACPI_FAILURE (Status)) 2866 { 2867 return (Status); 2868 } 2869 2870 ParentTable = DtPeekSubtable (); 2871 DtInsertSubtable (ParentTable, Subtable); 2872 DtPopSubtable (); 2873 } 2874 2875 return (AE_OK); 2876} 2877 2878 2879/****************************************************************************** 2880 * 2881 * FUNCTION: DtCompileSlic 2882 * 2883 * PARAMETERS: List - Current field list pointer 2884 * 2885 * RETURN: Status 2886 * 2887 * DESCRIPTION: Compile SLIC. 2888 * 2889 *****************************************************************************/ 2890 2891ACPI_STATUS 2892DtCompileSlic ( 2893 void **List) 2894{ 2895 ACPI_STATUS Status; 2896 DT_SUBTABLE *Subtable; 2897 DT_SUBTABLE *ParentTable; 2898 DT_FIELD **PFieldList = (DT_FIELD **) List; 2899 2900 2901 while (*PFieldList) 2902 { 2903 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic, 2904 &Subtable, TRUE); 2905 if (ACPI_FAILURE (Status)) 2906 { 2907 return (Status); 2908 } 2909 2910 ParentTable = DtPeekSubtable (); 2911 DtInsertSubtable (ParentTable, Subtable); 2912 DtPushSubtable (Subtable); 2913 DtPopSubtable (); 2914 } 2915 2916 return (AE_OK); 2917} 2918 2919 2920/****************************************************************************** 2921 * 2922 * FUNCTION: DtCompileSlit 2923 * 2924 * PARAMETERS: List - Current field list pointer 2925 * 2926 * RETURN: Status 2927 * 2928 * DESCRIPTION: Compile SLIT. 2929 * 2930 *****************************************************************************/ 2931 2932ACPI_STATUS 2933DtCompileSlit ( 2934 void **List) 2935{ 2936 ACPI_STATUS Status; 2937 DT_SUBTABLE *Subtable; 2938 DT_SUBTABLE *ParentTable; 2939 DT_FIELD **PFieldList = (DT_FIELD **) List; 2940 DT_FIELD *FieldList; 2941 UINT32 Localities; 2942 UINT8 *LocalityBuffer; 2943 2944 2945 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, 2946 &Subtable, TRUE); 2947 if (ACPI_FAILURE (Status)) 2948 { 2949 return (Status); 2950 } 2951 2952 ParentTable = DtPeekSubtable (); 2953 DtInsertSubtable (ParentTable, Subtable); 2954 2955 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); 2956 LocalityBuffer = UtLocalCalloc (Localities); 2957 2958 /* Compile each locality buffer */ 2959 2960 FieldList = *PFieldList; 2961 while (FieldList) 2962 { 2963 DtCompileBuffer (LocalityBuffer, 2964 FieldList->Value, FieldList, Localities); 2965 2966 DtCreateSubtable (LocalityBuffer, Localities, &Subtable); 2967 DtInsertSubtable (ParentTable, Subtable); 2968 FieldList = FieldList->Next; 2969 } 2970 2971 ACPI_FREE (LocalityBuffer); 2972 return (AE_OK); 2973} 2974 2975 2976/****************************************************************************** 2977 * 2978 * FUNCTION: DtCompileSrat 2979 * 2980 * PARAMETERS: List - Current field list pointer 2981 * 2982 * RETURN: Status 2983 * 2984 * DESCRIPTION: Compile SRAT. 2985 * 2986 *****************************************************************************/ 2987 2988ACPI_STATUS 2989DtCompileSrat ( 2990 void **List) 2991{ 2992 ACPI_STATUS Status; 2993 DT_SUBTABLE *Subtable; 2994 DT_SUBTABLE *ParentTable; 2995 DT_FIELD **PFieldList = (DT_FIELD **) List; 2996 DT_FIELD *SubtableStart; 2997 ACPI_SUBTABLE_HEADER *SratHeader; 2998 ACPI_DMTABLE_INFO *InfoTable; 2999 3000 3001 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat, 3002 &Subtable, TRUE); 3003 if (ACPI_FAILURE (Status)) 3004 { 3005 return (Status); 3006 } 3007 3008 ParentTable = DtPeekSubtable (); 3009 DtInsertSubtable (ParentTable, Subtable); 3010 3011 while (*PFieldList) 3012 { 3013 SubtableStart = *PFieldList; 3014 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr, 3015 &Subtable, TRUE); 3016 if (ACPI_FAILURE (Status)) 3017 { 3018 return (Status); 3019 } 3020 3021 ParentTable = DtPeekSubtable (); 3022 DtInsertSubtable (ParentTable, Subtable); 3023 DtPushSubtable (Subtable); 3024 3025 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 3026 3027 switch (SratHeader->Type) 3028 { 3029 case ACPI_SRAT_TYPE_CPU_AFFINITY: 3030 3031 InfoTable = AcpiDmTableInfoSrat0; 3032 break; 3033 3034 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 3035 3036 InfoTable = AcpiDmTableInfoSrat1; 3037 break; 3038 3039 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 3040 3041 InfoTable = AcpiDmTableInfoSrat2; 3042 break; 3043 3044 case ACPI_SRAT_TYPE_GICC_AFFINITY: 3045 3046 InfoTable = AcpiDmTableInfoSrat3; 3047 break; 3048 3049 default: 3050 3051 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT"); 3052 return (AE_ERROR); 3053 } 3054 3055 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 3056 if (ACPI_FAILURE (Status)) 3057 { 3058 return (Status); 3059 } 3060 3061 ParentTable = DtPeekSubtable (); 3062 DtInsertSubtable (ParentTable, Subtable); 3063 DtPopSubtable (); 3064 } 3065 3066 return (AE_OK); 3067} 3068 3069 3070/****************************************************************************** 3071 * 3072 * FUNCTION: DtCompileStao 3073 * 3074 * PARAMETERS: PFieldList - Current field list pointer 3075 * 3076 * RETURN: Status 3077 * 3078 * DESCRIPTION: Compile STAO. 3079 * 3080 *****************************************************************************/ 3081 3082ACPI_STATUS 3083DtCompileStao ( 3084 void **List) 3085{ 3086 DT_FIELD **PFieldList = (DT_FIELD **) List; 3087 DT_SUBTABLE *Subtable; 3088 DT_SUBTABLE *ParentTable; 3089 ACPI_STATUS Status; 3090 3091 3092 /* Compile the main table */ 3093 3094 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao, 3095 &Subtable, TRUE); 3096 if (ACPI_FAILURE (Status)) 3097 { 3098 return (Status); 3099 } 3100 3101 ParentTable = DtPeekSubtable (); 3102 DtInsertSubtable (ParentTable, Subtable); 3103 3104 /* Compile each ASCII namestring as a subtable */ 3105 3106 while (*PFieldList) 3107 { 3108 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr, 3109 &Subtable, TRUE); 3110 if (ACPI_FAILURE (Status)) 3111 { 3112 return (Status); 3113 } 3114 3115 ParentTable = DtPeekSubtable (); 3116 DtInsertSubtable (ParentTable, Subtable); 3117 } 3118 3119 return (AE_OK); 3120} 3121 3122 3123/****************************************************************************** 3124 * 3125 * FUNCTION: DtGetGenericTableInfo 3126 * 3127 * PARAMETERS: Name - Generic type name 3128 * 3129 * RETURN: Info entry 3130 * 3131 * DESCRIPTION: Obtain table info for a generic name entry 3132 * 3133 *****************************************************************************/ 3134 3135ACPI_DMTABLE_INFO * 3136DtGetGenericTableInfo ( 3137 char *Name) 3138{ 3139 ACPI_DMTABLE_INFO *Info; 3140 UINT32 i; 3141 3142 3143 if (!Name) 3144 { 3145 return (NULL); 3146 } 3147 3148 /* Search info table for name match */ 3149 3150 for (i = 0; ; i++) 3151 { 3152 Info = AcpiDmTableInfoGeneric[i]; 3153 if (Info->Opcode == ACPI_DMT_EXIT) 3154 { 3155 Info = NULL; 3156 break; 3157 } 3158 3159 /* Use caseless compare for generic keywords */ 3160 3161 if (!AcpiUtStricmp (Name, Info->Name)) 3162 { 3163 break; 3164 } 3165 } 3166 3167 return (Info); 3168} 3169 3170 3171/****************************************************************************** 3172 * 3173 * FUNCTION: DtCompileUefi 3174 * 3175 * PARAMETERS: List - Current field list pointer 3176 * 3177 * RETURN: Status 3178 * 3179 * DESCRIPTION: Compile UEFI. 3180 * 3181 *****************************************************************************/ 3182 3183ACPI_STATUS 3184DtCompileUefi ( 3185 void **List) 3186{ 3187 ACPI_STATUS Status; 3188 DT_SUBTABLE *Subtable; 3189 DT_SUBTABLE *ParentTable; 3190 DT_FIELD **PFieldList = (DT_FIELD **) List; 3191 UINT16 *DataOffset; 3192 3193 3194 /* Compile the predefined portion of the UEFI table */ 3195 3196 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi, 3197 &Subtable, TRUE); 3198 if (ACPI_FAILURE (Status)) 3199 { 3200 return (Status); 3201 } 3202 3203 DataOffset = (UINT16 *) (Subtable->Buffer + 16); 3204 *DataOffset = sizeof (ACPI_TABLE_UEFI); 3205 3206 ParentTable = DtPeekSubtable (); 3207 DtInsertSubtable (ParentTable, Subtable); 3208 3209 /* 3210 * Compile the "generic" portion of the UEFI table. This 3211 * part of the table is not predefined and any of the generic 3212 * operators may be used. 3213 */ 3214 3215 DtCompileGeneric ((void **) PFieldList, NULL, NULL); 3216 3217 return (AE_OK); 3218} 3219 3220 3221/****************************************************************************** 3222 * 3223 * FUNCTION: DtCompileVrtc 3224 * 3225 * PARAMETERS: List - Current field list pointer 3226 * 3227 * RETURN: Status 3228 * 3229 * DESCRIPTION: Compile VRTC. 3230 * 3231 *****************************************************************************/ 3232 3233ACPI_STATUS 3234DtCompileVrtc ( 3235 void **List) 3236{ 3237 ACPI_STATUS Status; 3238 3239 3240 Status = DtCompileTwoSubtables (List, 3241 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0); 3242 return (Status); 3243} 3244 3245 3246/****************************************************************************** 3247 * 3248 * FUNCTION: DtCompileWdat 3249 * 3250 * PARAMETERS: List - Current field list pointer 3251 * 3252 * RETURN: Status 3253 * 3254 * DESCRIPTION: Compile WDAT. 3255 * 3256 *****************************************************************************/ 3257 3258ACPI_STATUS 3259DtCompileWdat ( 3260 void **List) 3261{ 3262 ACPI_STATUS Status; 3263 3264 3265 Status = DtCompileTwoSubtables (List, 3266 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0); 3267 return (Status); 3268} 3269 3270 3271/****************************************************************************** 3272 * 3273 * FUNCTION: DtCompileWpbt 3274 * 3275 * PARAMETERS: List - Current field list pointer 3276 * 3277 * RETURN: Status 3278 * 3279 * DESCRIPTION: Compile WPBT. 3280 * 3281 *****************************************************************************/ 3282 3283ACPI_STATUS 3284DtCompileWpbt ( 3285 void **List) 3286{ 3287 DT_FIELD **PFieldList = (DT_FIELD **) List; 3288 DT_SUBTABLE *Subtable; 3289 DT_SUBTABLE *ParentTable; 3290 ACPI_TABLE_WPBT *Table; 3291 ACPI_STATUS Status; 3292 UINT16 Length; 3293 3294 3295 /* Compile the main table */ 3296 3297 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt, 3298 &Subtable, TRUE); 3299 if (ACPI_FAILURE (Status)) 3300 { 3301 return (Status); 3302 } 3303 3304 ParentTable = DtPeekSubtable (); 3305 DtInsertSubtable (ParentTable, Subtable); 3306 3307 /* Compile the argument list subtable */ 3308 3309 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0, 3310 &Subtable, TRUE); 3311 if (ACPI_FAILURE (Status)) 3312 { 3313 return (Status); 3314 } 3315 3316 /* Extract the length of the Arguments buffer, insert into main table */ 3317 3318 Length = (UINT16) Subtable->TotalLength; 3319 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer); 3320 Table->ArgumentsLength = Length; 3321 3322 ParentTable = DtPeekSubtable (); 3323 DtInsertSubtable (ParentTable, Subtable); 3324 return (AE_OK); 3325} 3326 3327 3328/****************************************************************************** 3329 * 3330 * FUNCTION: DtCompileXsdt 3331 * 3332 * PARAMETERS: List - Current field list pointer 3333 * 3334 * RETURN: Status 3335 * 3336 * DESCRIPTION: Compile XSDT. 3337 * 3338 *****************************************************************************/ 3339 3340ACPI_STATUS 3341DtCompileXsdt ( 3342 void **List) 3343{ 3344 DT_SUBTABLE *Subtable; 3345 DT_SUBTABLE *ParentTable; 3346 DT_FIELD *FieldList = *(DT_FIELD **) List; 3347 UINT64 Address; 3348 3349 3350 ParentTable = DtPeekSubtable (); 3351 3352 while (FieldList) 3353 { 3354 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO); 3355 3356 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable); 3357 DtInsertSubtable (ParentTable, Subtable); 3358 FieldList = FieldList->Next; 3359 } 3360 3361 return (AE_OK); 3362} 3363 3364 3365/****************************************************************************** 3366 * 3367 * FUNCTION: DtCompileGeneric 3368 * 3369 * PARAMETERS: List - Current field list pointer 3370 * Name - Field name to end generic compiling 3371 * Length - Compiled table length to return 3372 * 3373 * RETURN: Status 3374 * 3375 * DESCRIPTION: Compile generic unknown table. 3376 * 3377 *****************************************************************************/ 3378 3379ACPI_STATUS 3380DtCompileGeneric ( 3381 void **List, 3382 char *Name, 3383 UINT32 *Length) 3384{ 3385 ACPI_STATUS Status; 3386 DT_SUBTABLE *Subtable; 3387 DT_SUBTABLE *ParentTable; 3388 DT_FIELD **PFieldList = (DT_FIELD **) List; 3389 ACPI_DMTABLE_INFO *Info; 3390 3391 3392 ParentTable = DtPeekSubtable (); 3393 3394 /* 3395 * Compile the "generic" portion of the table. This 3396 * part of the table is not predefined and any of the generic 3397 * operators may be used. 3398 */ 3399 3400 /* Find any and all labels in the entire generic portion */ 3401 3402 DtDetectAllLabels (*PFieldList); 3403 3404 /* Now we can actually compile the parse tree */ 3405 3406 if (*Length) 3407 { 3408 *Length = 0; 3409 } 3410 while (*PFieldList) 3411 { 3412 if (Name && !ACPI_STRCMP ((*PFieldList)->Name, Name)) 3413 { 3414 break; 3415 } 3416 Info = DtGetGenericTableInfo ((*PFieldList)->Name); 3417 if (!Info) 3418 { 3419 sprintf (MsgBuffer, "Generic data type \"%s\" not found", 3420 (*PFieldList)->Name); 3421 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 3422 (*PFieldList), MsgBuffer); 3423 3424 *PFieldList = (*PFieldList)->Next; 3425 continue; 3426 } 3427 3428 Status = DtCompileTable (PFieldList, Info, 3429 &Subtable, TRUE); 3430 if (ACPI_SUCCESS (Status)) 3431 { 3432 DtInsertSubtable (ParentTable, Subtable); 3433 if (Length) 3434 { 3435 *Length += Subtable->Length; 3436 } 3437 } 3438 else 3439 { 3440 *PFieldList = (*PFieldList)->Next; 3441 3442 if (Status == AE_NOT_FOUND) 3443 { 3444 sprintf (MsgBuffer, "Generic data type \"%s\" not found", 3445 (*PFieldList)->Name); 3446 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 3447 (*PFieldList), MsgBuffer); 3448 } 3449 } 3450 } 3451 3452 return (AE_OK); 3453} 3454