Home | History | Annotate | Line # | Download | only in compiler
dttable2.c revision 1.1.1.1 
      1 /******************************************************************************
      2  *
      3  * Module Name: dttable2.c - handling for specific ACPI tables
      4  *
      5  *****************************************************************************/
      6 
      7 /*
      8  * Copyright (C) 2000 - 2016, Intel Corp.
      9  * All rights reserved.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions, and the following disclaimer,
     16  *    without modification.
     17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
     18  *    substantially similar to the "NO WARRANTY" disclaimer below
     19  *    ("Disclaimer") and any redistribution must be conditioned upon
     20  *    including a substantially similar Disclaimer requirement for further
     21  *    binary redistribution.
     22  * 3. Neither the names of the above-listed copyright holders nor the names
     23  *    of any contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * Alternatively, this software may be distributed under the terms of the
     27  * GNU General Public License ("GPL") version 2 as published by the Free
     28  * Software Foundation.
     29  *
     30  * NO WARRANTY
     31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
     34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     41  * POSSIBILITY OF SUCH DAMAGES.
     42  */
     43 
     44 /* Compile all complex data tables, signatures starting with L-Z */
     45 
     46 #include "aslcompiler.h"
     47 #include "dtcompiler.h"
     48 
     49 #define _COMPONENT          DT_COMPILER
     50         ACPI_MODULE_NAME    ("dttable2")
     51 
     52 
     53 /******************************************************************************
     54  *
     55  * FUNCTION:    DtCompileLpit
     56  *
     57  * PARAMETERS:  List                - Current field list pointer
     58  *
     59  * RETURN:      Status
     60  *
     61  * DESCRIPTION: Compile LPIT.
     62  *
     63  *****************************************************************************/
     64 
     65 ACPI_STATUS
     66 DtCompileLpit (
     67     void                    **List)
     68 {
     69     ACPI_STATUS             Status;
     70     DT_SUBTABLE             *Subtable;
     71     DT_SUBTABLE             *ParentTable;
     72     DT_FIELD                **PFieldList = (DT_FIELD **) List;
     73     DT_FIELD                *SubtableStart;
     74     ACPI_DMTABLE_INFO       *InfoTable;
     75     ACPI_LPIT_HEADER        *LpitHeader;
     76 
     77 
     78     /* Note: Main table consists only of the standard ACPI table header */
     79 
     80     while (*PFieldList)
     81     {
     82         SubtableStart = *PFieldList;
     83 
     84         /* LPIT Subtable header */
     85 
     86         Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr,
     87             &Subtable, TRUE);
     88         if (ACPI_FAILURE (Status))
     89         {
     90             return (Status);
     91         }
     92 
     93         ParentTable = DtPeekSubtable ();
     94         DtInsertSubtable (ParentTable, Subtable);
     95         DtPushSubtable (Subtable);
     96 
     97         LpitHeader = ACPI_CAST_PTR (ACPI_LPIT_HEADER, Subtable->Buffer);
     98 
     99         switch (LpitHeader->Type)
    100         {
    101         case ACPI_LPIT_TYPE_NATIVE_CSTATE:
    102 
    103             InfoTable = AcpiDmTableInfoLpit0;
    104             break;
    105 
    106         default:
    107 
    108             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "LPIT");
    109             return (AE_ERROR);
    110         }
    111 
    112         /* LPIT Subtable */
    113 
    114         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
    115         if (ACPI_FAILURE (Status))
    116         {
    117             return (Status);
    118         }
    119 
    120         ParentTable = DtPeekSubtable ();
    121         DtInsertSubtable (ParentTable, Subtable);
    122         DtPopSubtable ();
    123     }
    124 
    125     return (AE_OK);
    126 }
    127 
    128 
    129 /******************************************************************************
    130  *
    131  * FUNCTION:    DtCompileMadt
    132  *
    133  * PARAMETERS:  List                - Current field list pointer
    134  *
    135  * RETURN:      Status
    136  *
    137  * DESCRIPTION: Compile MADT.
    138  *
    139  *****************************************************************************/
    140 
    141 ACPI_STATUS
    142 DtCompileMadt (
    143     void                    **List)
    144 {
    145     ACPI_STATUS             Status;
    146     DT_SUBTABLE             *Subtable;
    147     DT_SUBTABLE             *ParentTable;
    148     DT_FIELD                **PFieldList = (DT_FIELD **) List;
    149     DT_FIELD                *SubtableStart;
    150     ACPI_SUBTABLE_HEADER    *MadtHeader;
    151     ACPI_DMTABLE_INFO       *InfoTable;
    152 
    153 
    154     Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt,
    155         &Subtable, TRUE);
    156     if (ACPI_FAILURE (Status))
    157     {
    158         return (Status);
    159     }
    160 
    161     ParentTable = DtPeekSubtable ();
    162     DtInsertSubtable (ParentTable, Subtable);
    163 
    164     while (*PFieldList)
    165     {
    166         SubtableStart = *PFieldList;
    167         Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr,
    168             &Subtable, TRUE);
    169         if (ACPI_FAILURE (Status))
    170         {
    171             return (Status);
    172         }
    173 
    174         ParentTable = DtPeekSubtable ();
    175         DtInsertSubtable (ParentTable, Subtable);
    176         DtPushSubtable (Subtable);
    177 
    178         MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
    179 
    180         switch (MadtHeader->Type)
    181         {
    182         case ACPI_MADT_TYPE_LOCAL_APIC:
    183 
    184             InfoTable = AcpiDmTableInfoMadt0;
    185             break;
    186 
    187         case ACPI_MADT_TYPE_IO_APIC:
    188 
    189             InfoTable = AcpiDmTableInfoMadt1;
    190             break;
    191 
    192         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
    193 
    194             InfoTable = AcpiDmTableInfoMadt2;
    195             break;
    196 
    197         case ACPI_MADT_TYPE_NMI_SOURCE:
    198 
    199             InfoTable = AcpiDmTableInfoMadt3;
    200             break;
    201 
    202         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
    203 
    204             InfoTable = AcpiDmTableInfoMadt4;
    205             break;
    206 
    207         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
    208 
    209             InfoTable = AcpiDmTableInfoMadt5;
    210             break;
    211 
    212         case ACPI_MADT_TYPE_IO_SAPIC:
    213 
    214             InfoTable = AcpiDmTableInfoMadt6;
    215             break;
    216 
    217         case ACPI_MADT_TYPE_LOCAL_SAPIC:
    218 
    219             InfoTable = AcpiDmTableInfoMadt7;
    220             break;
    221 
    222         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
    223 
    224             InfoTable = AcpiDmTableInfoMadt8;
    225             break;
    226 
    227         case ACPI_MADT_TYPE_LOCAL_X2APIC:
    228 
    229             InfoTable = AcpiDmTableInfoMadt9;
    230             break;
    231 
    232         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
    233 
    234             InfoTable = AcpiDmTableInfoMadt10;
    235             break;
    236 
    237         case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
    238 
    239             InfoTable = AcpiDmTableInfoMadt11;
    240             break;
    241 
    242         case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
    243 
    244             InfoTable = AcpiDmTableInfoMadt12;
    245             break;
    246 
    247         case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
    248 
    249             InfoTable = AcpiDmTableInfoMadt13;
    250             break;
    251 
    252         case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
    253 
    254             InfoTable = AcpiDmTableInfoMadt14;
    255             break;
    256 
    257         case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
    258 
    259             InfoTable = AcpiDmTableInfoMadt15;
    260             break;
    261 
    262         default:
    263 
    264             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT");
    265             return (AE_ERROR);
    266         }
    267 
    268         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
    269         if (ACPI_FAILURE (Status))
    270         {
    271             return (Status);
    272         }
    273 
    274         ParentTable = DtPeekSubtable ();
    275         DtInsertSubtable (ParentTable, Subtable);
    276         DtPopSubtable ();
    277     }
    278 
    279     return (AE_OK);
    280 }
    281 
    282 
    283 /******************************************************************************
    284  *
    285  * FUNCTION:    DtCompileMcfg
    286  *
    287  * PARAMETERS:  List                - Current field list pointer
    288  *
    289  * RETURN:      Status
    290  *
    291  * DESCRIPTION: Compile MCFG.
    292  *
    293  *****************************************************************************/
    294 
    295 ACPI_STATUS
    296 DtCompileMcfg (
    297     void                    **List)
    298 {
    299     ACPI_STATUS             Status;
    300 
    301 
    302     Status = DtCompileTwoSubtables (List,
    303         AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0);
    304     return (Status);
    305 }
    306 
    307 
    308 /******************************************************************************
    309  *
    310  * FUNCTION:    DtCompileMpst
    311  *
    312  * PARAMETERS:  List                - Current field list pointer
    313  *
    314  * RETURN:      Status
    315  *
    316  * DESCRIPTION: Compile MPST.
    317  *
    318  *****************************************************************************/
    319 
    320 ACPI_STATUS
    321 DtCompileMpst (
    322     void                    **List)
    323 {
    324     ACPI_STATUS             Status;
    325     DT_SUBTABLE             *Subtable;
    326     DT_SUBTABLE             *ParentTable;
    327     DT_FIELD                **PFieldList = (DT_FIELD **) List;
    328     ACPI_MPST_CHANNEL       *MpstChannelInfo;
    329     ACPI_MPST_POWER_NODE    *MpstPowerNode;
    330     ACPI_MPST_DATA_HDR      *MpstDataHeader;
    331     UINT16                  SubtableCount;
    332     UINT32                  PowerStateCount;
    333     UINT32                  ComponentCount;
    334 
    335 
    336     /* Main table */
    337 
    338     Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable, TRUE);
    339     if (ACPI_FAILURE (Status))
    340     {
    341         return (Status);
    342     }
    343 
    344     ParentTable = DtPeekSubtable ();
    345     DtInsertSubtable (ParentTable, Subtable);
    346     DtPushSubtable (Subtable);
    347 
    348     MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer);
    349     SubtableCount = MpstChannelInfo->PowerNodeCount;
    350 
    351     while (*PFieldList && SubtableCount)
    352     {
    353         /* Subtable: Memory Power Node(s) */
    354 
    355         Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0,
    356             &Subtable, TRUE);
    357         if (ACPI_FAILURE (Status))
    358         {
    359             return (Status);
    360         }
    361 
    362         ParentTable = DtPeekSubtable ();
    363         DtInsertSubtable (ParentTable, Subtable);
    364         DtPushSubtable (Subtable);
    365 
    366         MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer);
    367         PowerStateCount = MpstPowerNode->NumPowerStates;
    368         ComponentCount = MpstPowerNode->NumPhysicalComponents;
    369 
    370         ParentTable = DtPeekSubtable ();
    371 
    372         /* Sub-subtables - Memory Power State Structure(s) */
    373 
    374         while (*PFieldList && PowerStateCount)
    375         {
    376             Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A,
    377                 &Subtable, TRUE);
    378             if (ACPI_FAILURE (Status))
    379             {
    380                 return (Status);
    381             }
    382 
    383             DtInsertSubtable (ParentTable, Subtable);
    384             PowerStateCount--;
    385         }
    386 
    387         /* Sub-subtables - Physical Component ID Structure(s) */
    388 
    389         while (*PFieldList && ComponentCount)
    390         {
    391             Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B,
    392                 &Subtable, TRUE);
    393             if (ACPI_FAILURE (Status))
    394             {
    395                 return (Status);
    396             }
    397 
    398             DtInsertSubtable (ParentTable, Subtable);
    399             ComponentCount--;
    400         }
    401 
    402         SubtableCount--;
    403         DtPopSubtable ();
    404     }
    405 
    406     /* Subtable: Count of Memory Power State Characteristic structures */
    407 
    408     DtPopSubtable ();
    409 
    410     Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable, TRUE);
    411     if (ACPI_FAILURE (Status))
    412     {
    413         return (Status);
    414     }
    415 
    416     ParentTable = DtPeekSubtable ();
    417     DtInsertSubtable (ParentTable, Subtable);
    418     DtPushSubtable (Subtable);
    419 
    420     MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer);
    421     SubtableCount = MpstDataHeader->CharacteristicsCount;
    422 
    423     ParentTable = DtPeekSubtable ();
    424 
    425     /* Subtable: Memory Power State Characteristics structure(s) */
    426 
    427     while (*PFieldList && SubtableCount)
    428     {
    429         Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2,
    430             &Subtable, TRUE);
    431         if (ACPI_FAILURE (Status))
    432         {
    433             return (Status);
    434         }
    435 
    436         DtInsertSubtable (ParentTable, Subtable);
    437         SubtableCount--;
    438     }
    439 
    440     DtPopSubtable ();
    441     return (AE_OK);
    442 }
    443 
    444 
    445 /******************************************************************************
    446  *
    447  * FUNCTION:    DtCompileMsct
    448  *
    449  * PARAMETERS:  List                - Current field list pointer
    450  *
    451  * RETURN:      Status
    452  *
    453  * DESCRIPTION: Compile MSCT.
    454  *
    455  *****************************************************************************/
    456 
    457 ACPI_STATUS
    458 DtCompileMsct (
    459     void                    **List)
    460 {
    461     ACPI_STATUS             Status;
    462 
    463 
    464     Status = DtCompileTwoSubtables (List,
    465         AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0);
    466     return (Status);
    467 }
    468 
    469 
    470 /******************************************************************************
    471  *
    472  * FUNCTION:    DtCompileMtmr
    473  *
    474  * PARAMETERS:  List                - Current field list pointer
    475  *
    476  * RETURN:      Status
    477  *
    478  * DESCRIPTION: Compile MTMR.
    479  *
    480  *****************************************************************************/
    481 
    482 ACPI_STATUS
    483 DtCompileMtmr (
    484     void                    **List)
    485 {
    486     ACPI_STATUS             Status;
    487 
    488 
    489     Status = DtCompileTwoSubtables (List,
    490         AcpiDmTableInfoMtmr, AcpiDmTableInfoMtmr0);
    491     return (Status);
    492 }
    493 
    494 
    495 /******************************************************************************
    496  *
    497  * FUNCTION:    DtCompileNfit
    498  *
    499  * PARAMETERS:  List                - Current field list pointer
    500  *
    501  * RETURN:      Status
    502  *
    503  * DESCRIPTION: Compile NFIT.
    504  *
    505  *****************************************************************************/
    506 
    507 ACPI_STATUS
    508 DtCompileNfit (
    509     void                    **List)
    510 {
    511     ACPI_STATUS             Status;
    512     DT_SUBTABLE             *Subtable;
    513     DT_SUBTABLE             *ParentTable;
    514     DT_FIELD                **PFieldList = (DT_FIELD **) List;
    515     DT_FIELD                *SubtableStart;
    516     ACPI_NFIT_HEADER        *NfitHeader;
    517     ACPI_DMTABLE_INFO       *InfoTable;
    518     UINT32                  Count;
    519     ACPI_NFIT_INTERLEAVE    *Interleave = NULL;
    520     ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
    521 
    522 
    523     /* Main table */
    524 
    525     Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit,
    526         &Subtable, TRUE);
    527     if (ACPI_FAILURE (Status))
    528     {
    529         return (Status);
    530     }
    531 
    532     ParentTable = DtPeekSubtable ();
    533     DtInsertSubtable (ParentTable, Subtable);
    534     DtPushSubtable (Subtable);
    535 
    536     /* Subtables */
    537 
    538     while (*PFieldList)
    539     {
    540         SubtableStart = *PFieldList;
    541         Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr,
    542             &Subtable, TRUE);
    543         if (ACPI_FAILURE (Status))
    544         {
    545             return (Status);
    546         }
    547 
    548         ParentTable = DtPeekSubtable ();
    549         DtInsertSubtable (ParentTable, Subtable);
    550         DtPushSubtable (Subtable);
    551 
    552         NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer);
    553 
    554         switch (NfitHeader->Type)
    555         {
    556         case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
    557 
    558             InfoTable = AcpiDmTableInfoNfit0;
    559             break;
    560 
    561         case ACPI_NFIT_TYPE_MEMORY_MAP:
    562 
    563             InfoTable = AcpiDmTableInfoNfit1;
    564             break;
    565 
    566         case ACPI_NFIT_TYPE_INTERLEAVE:
    567 
    568             Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer);
    569             InfoTable = AcpiDmTableInfoNfit2;
    570             break;
    571 
    572         case ACPI_NFIT_TYPE_SMBIOS:
    573 
    574             InfoTable = AcpiDmTableInfoNfit3;
    575             break;
    576 
    577         case ACPI_NFIT_TYPE_CONTROL_REGION:
    578 
    579             InfoTable = AcpiDmTableInfoNfit4;
    580             break;
    581 
    582         case ACPI_NFIT_TYPE_DATA_REGION:
    583 
    584             InfoTable = AcpiDmTableInfoNfit5;
    585             break;
    586 
    587         case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
    588 
    589             Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer);
    590             InfoTable = AcpiDmTableInfoNfit6;
    591             break;
    592 
    593         default:
    594 
    595             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT");
    596             return (AE_ERROR);
    597         }
    598 
    599         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
    600         if (ACPI_FAILURE (Status))
    601         {
    602             return (Status);
    603         }
    604 
    605         ParentTable = DtPeekSubtable ();
    606         DtInsertSubtable (ParentTable, Subtable);
    607         DtPopSubtable ();
    608 
    609         switch (NfitHeader->Type)
    610         {
    611         case ACPI_NFIT_TYPE_INTERLEAVE:
    612 
    613             Count = 0;
    614             DtPushSubtable (Subtable);
    615             while (*PFieldList)
    616             {
    617                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a,
    618                     &Subtable, FALSE);
    619                 if (ACPI_FAILURE (Status))
    620                 {
    621                     return (Status);
    622                 }
    623 
    624                 if (!Subtable)
    625                 {
    626                     DtPopSubtable ();
    627                     break;
    628                 }
    629 
    630                 ParentTable = DtPeekSubtable ();
    631                 DtInsertSubtable (ParentTable, Subtable);
    632                 Count++;
    633             }
    634 
    635             Interleave->LineCount = Count;
    636             DtPopSubtable ();
    637             break;
    638 
    639         case ACPI_NFIT_TYPE_SMBIOS:
    640 
    641             if (*PFieldList)
    642             {
    643                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a,
    644                     &Subtable, TRUE);
    645                 if (ACPI_FAILURE (Status))
    646                 {
    647                     return (Status);
    648                 }
    649 
    650                 if (Subtable)
    651                 {
    652                     DtInsertSubtable (ParentTable, Subtable);
    653                 }
    654             }
    655             break;
    656 
    657         case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
    658 
    659             Count = 0;
    660             DtPushSubtable (Subtable);
    661             while (*PFieldList)
    662             {
    663                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a,
    664                     &Subtable, FALSE);
    665                 if (ACPI_FAILURE (Status))
    666                 {
    667                     return (Status);
    668                 }
    669 
    670                 if (!Subtable)
    671                 {
    672                     DtPopSubtable ();
    673                     break;
    674                 }
    675 
    676                 ParentTable = DtPeekSubtable ();
    677                 DtInsertSubtable (ParentTable, Subtable);
    678                 Count++;
    679             }
    680 
    681             Hint->HintCount = (UINT16) Count;
    682             DtPopSubtable ();
    683             break;
    684 
    685         default:
    686             break;
    687         }
    688     }
    689 
    690     return (AE_OK);
    691 }
    692 
    693 
    694 /******************************************************************************
    695  *
    696  * FUNCTION:    DtCompilePcct
    697  *
    698  * PARAMETERS:  List                - Current field list pointer
    699  *
    700  * RETURN:      Status
    701  *
    702  * DESCRIPTION: Compile PCCT.
    703  *
    704  *****************************************************************************/
    705 
    706 ACPI_STATUS
    707 DtCompilePcct (
    708     void                    **List)
    709 {
    710     ACPI_STATUS             Status;
    711     DT_SUBTABLE             *Subtable;
    712     DT_SUBTABLE             *ParentTable;
    713     DT_FIELD                **PFieldList = (DT_FIELD **) List;
    714     DT_FIELD                *SubtableStart;
    715     ACPI_SUBTABLE_HEADER    *PcctHeader;
    716     ACPI_DMTABLE_INFO       *InfoTable;
    717 
    718 
    719     /* Main table */
    720 
    721     Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct,
    722         &Subtable, TRUE);
    723     if (ACPI_FAILURE (Status))
    724     {
    725         return (Status);
    726     }
    727 
    728     ParentTable = DtPeekSubtable ();
    729     DtInsertSubtable (ParentTable, Subtable);
    730 
    731     /* Subtables */
    732 
    733     while (*PFieldList)
    734     {
    735         SubtableStart = *PFieldList;
    736         Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr,
    737             &Subtable, TRUE);
    738         if (ACPI_FAILURE (Status))
    739         {
    740             return (Status);
    741         }
    742 
    743         ParentTable = DtPeekSubtable ();
    744         DtInsertSubtable (ParentTable, Subtable);
    745         DtPushSubtable (Subtable);
    746 
    747         PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
    748 
    749         switch (PcctHeader->Type)
    750         {
    751         case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
    752 
    753             InfoTable = AcpiDmTableInfoPcct0;
    754             break;
    755 
    756         case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
    757 
    758             InfoTable = AcpiDmTableInfoPcct1;
    759             break;
    760 
    761         default:
    762 
    763             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT");
    764             return (AE_ERROR);
    765         }
    766 
    767         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
    768         if (ACPI_FAILURE (Status))
    769         {
    770             return (Status);
    771         }
    772 
    773         ParentTable = DtPeekSubtable ();
    774         DtInsertSubtable (ParentTable, Subtable);
    775         DtPopSubtable ();
    776     }
    777 
    778     return (AE_OK);
    779 }
    780 
    781 
    782 /******************************************************************************
    783  *
    784  * FUNCTION:    DtCompilePmtt
    785  *
    786  * PARAMETERS:  List                - Current field list pointer
    787  *
    788  * RETURN:      Status
    789  *
    790  * DESCRIPTION: Compile PMTT.
    791  *
    792  *****************************************************************************/
    793 
    794 ACPI_STATUS
    795 DtCompilePmtt (
    796     void                    **List)
    797 {
    798     ACPI_STATUS             Status;
    799     DT_SUBTABLE             *Subtable;
    800     DT_SUBTABLE             *ParentTable;
    801     DT_FIELD                **PFieldList = (DT_FIELD **) List;
    802     DT_FIELD                *SubtableStart;
    803     ACPI_PMTT_HEADER        *PmttHeader;
    804     ACPI_PMTT_CONTROLLER    *PmttController;
    805     UINT16                  DomainCount;
    806     UINT8                   PrevType = ACPI_PMTT_TYPE_SOCKET;
    807 
    808 
    809     /* Main table */
    810 
    811     Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE);
    812     if (ACPI_FAILURE (Status))
    813     {
    814         return (Status);
    815     }
    816 
    817     ParentTable = DtPeekSubtable ();
    818     DtInsertSubtable (ParentTable, Subtable);
    819     DtPushSubtable (Subtable);
    820 
    821     while (*PFieldList)
    822     {
    823         SubtableStart = *PFieldList;
    824         Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr,
    825             &Subtable, TRUE);
    826         if (ACPI_FAILURE (Status))
    827         {
    828             return (Status);
    829         }
    830 
    831         PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer);
    832         while (PrevType >= PmttHeader->Type)
    833         {
    834             DtPopSubtable ();
    835 
    836             if (PrevType == ACPI_PMTT_TYPE_SOCKET)
    837             {
    838                 break;
    839             }
    840 
    841             PrevType--;
    842         }
    843 
    844         PrevType = PmttHeader->Type;
    845 
    846         ParentTable = DtPeekSubtable ();
    847         DtInsertSubtable (ParentTable, Subtable);
    848         DtPushSubtable (Subtable);
    849 
    850         switch (PmttHeader->Type)
    851         {
    852         case ACPI_PMTT_TYPE_SOCKET:
    853 
    854             /* Subtable: Socket Structure */
    855 
    856             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0,
    857                 &Subtable, TRUE);
    858             if (ACPI_FAILURE (Status))
    859             {
    860                 return (Status);
    861             }
    862 
    863             ParentTable = DtPeekSubtable ();
    864             DtInsertSubtable (ParentTable, Subtable);
    865             break;
    866 
    867         case ACPI_PMTT_TYPE_CONTROLLER:
    868 
    869             /* Subtable: Memory Controller Structure */
    870 
    871             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1,
    872                 &Subtable, TRUE);
    873             if (ACPI_FAILURE (Status))
    874             {
    875                 return (Status);
    876             }
    877 
    878             ParentTable = DtPeekSubtable ();
    879             DtInsertSubtable (ParentTable, Subtable);
    880 
    881             PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER,
    882                 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER)));
    883             DomainCount = PmttController->DomainCount;
    884 
    885             while (DomainCount)
    886             {
    887                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a,
    888                     &Subtable, TRUE);
    889                 if (ACPI_FAILURE (Status))
    890                 {
    891                     return (Status);
    892                 }
    893 
    894                 DtInsertSubtable (ParentTable, Subtable);
    895                 DomainCount--;
    896             }
    897             break;
    898 
    899         case ACPI_PMTT_TYPE_DIMM:
    900 
    901             /* Subtable: Physical Component Structure */
    902 
    903             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2,
    904                 &Subtable, TRUE);
    905             if (ACPI_FAILURE (Status))
    906             {
    907                 return (Status);
    908             }
    909 
    910             ParentTable = DtPeekSubtable ();
    911             DtInsertSubtable (ParentTable, Subtable);
    912             break;
    913 
    914         default:
    915 
    916             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT");
    917             return (AE_ERROR);
    918         }
    919     }
    920 
    921     return (Status);
    922 }
    923 
    924 
    925 /******************************************************************************
    926  *
    927  * FUNCTION:    DtCompileRsdt
    928  *
    929  * PARAMETERS:  List                - Current field list pointer
    930  *
    931  * RETURN:      Status
    932  *
    933  * DESCRIPTION: Compile RSDT.
    934  *
    935  *****************************************************************************/
    936 
    937 ACPI_STATUS
    938 DtCompileRsdt (
    939     void                    **List)
    940 {
    941     DT_SUBTABLE             *Subtable;
    942     DT_SUBTABLE             *ParentTable;
    943     DT_FIELD                *FieldList = *(DT_FIELD **) List;
    944     UINT32                  Address;
    945 
    946 
    947     ParentTable = DtPeekSubtable ();
    948 
    949     while (FieldList)
    950     {
    951         DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO);
    952 
    953         DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable);
    954         DtInsertSubtable (ParentTable, Subtable);
    955         FieldList = FieldList->Next;
    956     }
    957 
    958     return (AE_OK);
    959 }
    960 
    961 
    962 /******************************************************************************
    963  *
    964  * FUNCTION:    DtCompileS3pt
    965  *
    966  * PARAMETERS:  PFieldList          - Current field list pointer
    967  *
    968  * RETURN:      Status
    969  *
    970  * DESCRIPTION: Compile S3PT (Pointed to by FPDT)
    971  *
    972  *****************************************************************************/
    973 
    974 ACPI_STATUS
    975 DtCompileS3pt (
    976     DT_FIELD                **PFieldList)
    977 {
    978     ACPI_STATUS             Status;
    979     ACPI_S3PT_HEADER        *S3ptHeader;
    980     DT_SUBTABLE             *Subtable;
    981     DT_SUBTABLE             *ParentTable;
    982     ACPI_DMTABLE_INFO       *InfoTable;
    983     DT_FIELD                *SubtableStart;
    984 
    985 
    986     Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
    987         &Gbl_RootTable, TRUE);
    988     if (ACPI_FAILURE (Status))
    989     {
    990         return (Status);
    991     }
    992 
    993     DtPushSubtable (Gbl_RootTable);
    994 
    995     while (*PFieldList)
    996     {
    997         SubtableStart = *PFieldList;
    998         Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr,
    999             &Subtable, TRUE);
   1000         if (ACPI_FAILURE (Status))
   1001         {
   1002             return (Status);
   1003         }
   1004 
   1005         ParentTable = DtPeekSubtable ();
   1006         DtInsertSubtable (ParentTable, Subtable);
   1007         DtPushSubtable (Subtable);
   1008 
   1009         S3ptHeader = ACPI_CAST_PTR (ACPI_S3PT_HEADER, Subtable->Buffer);
   1010 
   1011         switch (S3ptHeader->Type)
   1012         {
   1013         case ACPI_S3PT_TYPE_RESUME:
   1014 
   1015             InfoTable = AcpiDmTableInfoS3pt0;
   1016             break;
   1017 
   1018         case ACPI_S3PT_TYPE_SUSPEND:
   1019 
   1020             InfoTable = AcpiDmTableInfoS3pt1;
   1021             break;
   1022 
   1023         default:
   1024 
   1025             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT");
   1026             return (AE_ERROR);
   1027         }
   1028 
   1029         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
   1030         if (ACPI_FAILURE (Status))
   1031         {
   1032             return (Status);
   1033         }
   1034 
   1035         ParentTable = DtPeekSubtable ();
   1036         DtInsertSubtable (ParentTable, Subtable);
   1037         DtPopSubtable ();
   1038     }
   1039 
   1040     return (AE_OK);
   1041 }
   1042 
   1043 
   1044 /******************************************************************************
   1045  *
   1046  * FUNCTION:    DtCompileSlic
   1047  *
   1048  * PARAMETERS:  List                - Current field list pointer
   1049  *
   1050  * RETURN:      Status
   1051  *
   1052  * DESCRIPTION: Compile SLIC.
   1053  *
   1054  *****************************************************************************/
   1055 
   1056 ACPI_STATUS
   1057 DtCompileSlic (
   1058     void                    **List)
   1059 {
   1060     ACPI_STATUS             Status;
   1061     DT_SUBTABLE             *Subtable;
   1062     DT_SUBTABLE             *ParentTable;
   1063     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1064 
   1065 
   1066     while (*PFieldList)
   1067     {
   1068         Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic,
   1069             &Subtable, TRUE);
   1070         if (ACPI_FAILURE (Status))
   1071         {
   1072             return (Status);
   1073         }
   1074 
   1075         ParentTable = DtPeekSubtable ();
   1076         DtInsertSubtable (ParentTable, Subtable);
   1077         DtPushSubtable (Subtable);
   1078         DtPopSubtable ();
   1079     }
   1080 
   1081     return (AE_OK);
   1082 }
   1083 
   1084 
   1085 /******************************************************************************
   1086  *
   1087  * FUNCTION:    DtCompileSlit
   1088  *
   1089  * PARAMETERS:  List                - Current field list pointer
   1090  *
   1091  * RETURN:      Status
   1092  *
   1093  * DESCRIPTION: Compile SLIT.
   1094  *
   1095  *****************************************************************************/
   1096 
   1097 ACPI_STATUS
   1098 DtCompileSlit (
   1099     void                    **List)
   1100 {
   1101     ACPI_STATUS             Status;
   1102     DT_SUBTABLE             *Subtable;
   1103     DT_SUBTABLE             *ParentTable;
   1104     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1105     DT_FIELD                *FieldList;
   1106     UINT32                  Localities;
   1107     UINT8                   *LocalityBuffer;
   1108 
   1109 
   1110     Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
   1111         &Subtable, TRUE);
   1112     if (ACPI_FAILURE (Status))
   1113     {
   1114         return (Status);
   1115     }
   1116 
   1117     ParentTable = DtPeekSubtable ();
   1118     DtInsertSubtable (ParentTable, Subtable);
   1119 
   1120     Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
   1121     LocalityBuffer = UtLocalCalloc (Localities);
   1122 
   1123     /* Compile each locality buffer */
   1124 
   1125     FieldList = *PFieldList;
   1126     while (FieldList)
   1127     {
   1128         DtCompileBuffer (LocalityBuffer,
   1129             FieldList->Value, FieldList, Localities);
   1130 
   1131         DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
   1132         DtInsertSubtable (ParentTable, Subtable);
   1133         FieldList = FieldList->Next;
   1134     }
   1135 
   1136     ACPI_FREE (LocalityBuffer);
   1137     return (AE_OK);
   1138 }
   1139 
   1140 
   1141 /******************************************************************************
   1142  *
   1143  * FUNCTION:    DtCompileSrat
   1144  *
   1145  * PARAMETERS:  List                - Current field list pointer
   1146  *
   1147  * RETURN:      Status
   1148  *
   1149  * DESCRIPTION: Compile SRAT.
   1150  *
   1151  *****************************************************************************/
   1152 
   1153 ACPI_STATUS
   1154 DtCompileSrat (
   1155     void                    **List)
   1156 {
   1157     ACPI_STATUS             Status;
   1158     DT_SUBTABLE             *Subtable;
   1159     DT_SUBTABLE             *ParentTable;
   1160     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1161     DT_FIELD                *SubtableStart;
   1162     ACPI_SUBTABLE_HEADER    *SratHeader;
   1163     ACPI_DMTABLE_INFO       *InfoTable;
   1164 
   1165 
   1166     Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
   1167         &Subtable, TRUE);
   1168     if (ACPI_FAILURE (Status))
   1169     {
   1170         return (Status);
   1171     }
   1172 
   1173     ParentTable = DtPeekSubtable ();
   1174     DtInsertSubtable (ParentTable, Subtable);
   1175 
   1176     while (*PFieldList)
   1177     {
   1178         SubtableStart = *PFieldList;
   1179         Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
   1180             &Subtable, TRUE);
   1181         if (ACPI_FAILURE (Status))
   1182         {
   1183             return (Status);
   1184         }
   1185 
   1186         ParentTable = DtPeekSubtable ();
   1187         DtInsertSubtable (ParentTable, Subtable);
   1188         DtPushSubtable (Subtable);
   1189 
   1190         SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
   1191 
   1192         switch (SratHeader->Type)
   1193         {
   1194         case ACPI_SRAT_TYPE_CPU_AFFINITY:
   1195 
   1196             InfoTable = AcpiDmTableInfoSrat0;
   1197             break;
   1198 
   1199         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
   1200 
   1201             InfoTable = AcpiDmTableInfoSrat1;
   1202             break;
   1203 
   1204         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
   1205 
   1206             InfoTable = AcpiDmTableInfoSrat2;
   1207             break;
   1208 
   1209         case ACPI_SRAT_TYPE_GICC_AFFINITY:
   1210 
   1211             InfoTable = AcpiDmTableInfoSrat3;
   1212             break;
   1213 
   1214         default:
   1215 
   1216             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
   1217             return (AE_ERROR);
   1218         }
   1219 
   1220         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
   1221         if (ACPI_FAILURE (Status))
   1222         {
   1223             return (Status);
   1224         }
   1225 
   1226         ParentTable = DtPeekSubtable ();
   1227         DtInsertSubtable (ParentTable, Subtable);
   1228         DtPopSubtable ();
   1229     }
   1230 
   1231     return (AE_OK);
   1232 }
   1233 
   1234 
   1235 /******************************************************************************
   1236  *
   1237  * FUNCTION:    DtCompileStao
   1238  *
   1239  * PARAMETERS:  PFieldList          - Current field list pointer
   1240  *
   1241  * RETURN:      Status
   1242  *
   1243  * DESCRIPTION: Compile STAO.
   1244  *
   1245  *****************************************************************************/
   1246 
   1247 ACPI_STATUS
   1248 DtCompileStao (
   1249     void                    **List)
   1250 {
   1251     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1252     DT_SUBTABLE             *Subtable;
   1253     DT_SUBTABLE             *ParentTable;
   1254     ACPI_STATUS             Status;
   1255 
   1256 
   1257     /* Compile the main table */
   1258 
   1259     Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao,
   1260         &Subtable, TRUE);
   1261     if (ACPI_FAILURE (Status))
   1262     {
   1263         return (Status);
   1264     }
   1265 
   1266     ParentTable = DtPeekSubtable ();
   1267     DtInsertSubtable (ParentTable, Subtable);
   1268 
   1269     /* Compile each ASCII namestring as a subtable */
   1270 
   1271     while (*PFieldList)
   1272     {
   1273         Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr,
   1274             &Subtable, TRUE);
   1275         if (ACPI_FAILURE (Status))
   1276         {
   1277             return (Status);
   1278         }
   1279 
   1280         ParentTable = DtPeekSubtable ();
   1281         DtInsertSubtable (ParentTable, Subtable);
   1282     }
   1283 
   1284     return (AE_OK);
   1285 }
   1286 
   1287 
   1288 /******************************************************************************
   1289  *
   1290  * FUNCTION:    DtCompileTcpa
   1291  *
   1292  * PARAMETERS:  PFieldList          - Current field list pointer
   1293  *
   1294  * RETURN:      Status
   1295  *
   1296  * DESCRIPTION: Compile TCPA.
   1297  *
   1298  *****************************************************************************/
   1299 
   1300 ACPI_STATUS
   1301 DtCompileTcpa (
   1302     void                    **List)
   1303 {
   1304     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1305     DT_SUBTABLE             *Subtable;
   1306     ACPI_TABLE_TCPA_HDR     *TcpaHeader;
   1307     DT_SUBTABLE             *ParentTable;
   1308     ACPI_STATUS             Status;
   1309 
   1310 
   1311     /* Compile the main table */
   1312 
   1313     Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
   1314         &Subtable, TRUE);
   1315     if (ACPI_FAILURE (Status))
   1316     {
   1317         return (Status);
   1318     }
   1319 
   1320     ParentTable = DtPeekSubtable ();
   1321     DtInsertSubtable (ParentTable, Subtable);
   1322 
   1323     /*
   1324      * Examine the PlatformClass field to determine the table type.
   1325      * Either a client or server table. Only one.
   1326      */
   1327     TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
   1328 
   1329     switch (TcpaHeader->PlatformClass)
   1330     {
   1331     case ACPI_TCPA_CLIENT_TABLE:
   1332 
   1333         Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
   1334             &Subtable, TRUE);
   1335         break;
   1336 
   1337     case ACPI_TCPA_SERVER_TABLE:
   1338 
   1339         Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
   1340             &Subtable, TRUE);
   1341         break;
   1342 
   1343     default:
   1344 
   1345         AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
   1346             TcpaHeader->PlatformClass);
   1347         Status = AE_ERROR;
   1348         break;
   1349     }
   1350 
   1351     ParentTable = DtPeekSubtable ();
   1352     DtInsertSubtable (ParentTable, Subtable);
   1353     return (Status);
   1354 }
   1355 
   1356 
   1357 /******************************************************************************
   1358  *
   1359  * FUNCTION:    DtGetGenericTableInfo
   1360  *
   1361  * PARAMETERS:  Name                - Generic type name
   1362  *
   1363  * RETURN:      Info entry
   1364  *
   1365  * DESCRIPTION: Obtain table info for a generic name entry
   1366  *
   1367  *****************************************************************************/
   1368 
   1369 ACPI_DMTABLE_INFO *
   1370 DtGetGenericTableInfo (
   1371     char                    *Name)
   1372 {
   1373     ACPI_DMTABLE_INFO       *Info;
   1374     UINT32                  i;
   1375 
   1376 
   1377     if (!Name)
   1378     {
   1379         return (NULL);
   1380     }
   1381 
   1382     /* Search info table for name match */
   1383 
   1384     for (i = 0; ; i++)
   1385     {
   1386         Info = AcpiDmTableInfoGeneric[i];
   1387         if (Info->Opcode == ACPI_DMT_EXIT)
   1388         {
   1389             Info = NULL;
   1390             break;
   1391         }
   1392 
   1393         /* Use caseless compare for generic keywords */
   1394 
   1395         if (!AcpiUtStricmp (Name, Info->Name))
   1396         {
   1397             break;
   1398         }
   1399     }
   1400 
   1401     return (Info);
   1402 }
   1403 
   1404 
   1405 /******************************************************************************
   1406  *
   1407  * FUNCTION:    DtCompileUefi
   1408  *
   1409  * PARAMETERS:  List                - Current field list pointer
   1410  *
   1411  * RETURN:      Status
   1412  *
   1413  * DESCRIPTION: Compile UEFI.
   1414  *
   1415  *****************************************************************************/
   1416 
   1417 ACPI_STATUS
   1418 DtCompileUefi (
   1419     void                    **List)
   1420 {
   1421     ACPI_STATUS             Status;
   1422     DT_SUBTABLE             *Subtable;
   1423     DT_SUBTABLE             *ParentTable;
   1424     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1425     UINT16                  *DataOffset;
   1426 
   1427 
   1428     /* Compile the predefined portion of the UEFI table */
   1429 
   1430     Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
   1431         &Subtable, TRUE);
   1432     if (ACPI_FAILURE (Status))
   1433     {
   1434         return (Status);
   1435     }
   1436 
   1437     DataOffset = (UINT16 *) (Subtable->Buffer + 16);
   1438     *DataOffset = sizeof (ACPI_TABLE_UEFI);
   1439 
   1440     ParentTable = DtPeekSubtable ();
   1441     DtInsertSubtable (ParentTable, Subtable);
   1442 
   1443     /*
   1444      * Compile the "generic" portion of the UEFI table. This
   1445      * part of the table is not predefined and any of the generic
   1446      * operators may be used.
   1447      */
   1448     DtCompileGeneric ((void **) PFieldList, NULL, NULL);
   1449     return (AE_OK);
   1450 }
   1451 
   1452 
   1453 /******************************************************************************
   1454  *
   1455  * FUNCTION:    DtCompileVrtc
   1456  *
   1457  * PARAMETERS:  List                - Current field list pointer
   1458  *
   1459  * RETURN:      Status
   1460  *
   1461  * DESCRIPTION: Compile VRTC.
   1462  *
   1463  *****************************************************************************/
   1464 
   1465 ACPI_STATUS
   1466 DtCompileVrtc (
   1467     void                    **List)
   1468 {
   1469     ACPI_STATUS             Status;
   1470 
   1471 
   1472     Status = DtCompileTwoSubtables (List,
   1473         AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0);
   1474     return (Status);
   1475 }
   1476 
   1477 
   1478 /******************************************************************************
   1479  *
   1480  * FUNCTION:    DtCompileWdat
   1481  *
   1482  * PARAMETERS:  List                - Current field list pointer
   1483  *
   1484  * RETURN:      Status
   1485  *
   1486  * DESCRIPTION: Compile WDAT.
   1487  *
   1488  *****************************************************************************/
   1489 
   1490 ACPI_STATUS
   1491 DtCompileWdat (
   1492     void                    **List)
   1493 {
   1494     ACPI_STATUS             Status;
   1495 
   1496 
   1497     Status = DtCompileTwoSubtables (List,
   1498         AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
   1499     return (Status);
   1500 }
   1501 
   1502 
   1503 /******************************************************************************
   1504  *
   1505  * FUNCTION:    DtCompileWpbt
   1506  *
   1507  * PARAMETERS:  List                - Current field list pointer
   1508  *
   1509  * RETURN:      Status
   1510  *
   1511  * DESCRIPTION: Compile WPBT.
   1512  *
   1513  *****************************************************************************/
   1514 
   1515 ACPI_STATUS
   1516 DtCompileWpbt (
   1517     void                    **List)
   1518 {
   1519     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1520     DT_SUBTABLE             *Subtable;
   1521     DT_SUBTABLE             *ParentTable;
   1522     ACPI_TABLE_WPBT         *Table;
   1523     ACPI_STATUS             Status;
   1524     UINT16                  Length;
   1525 
   1526 
   1527     /* Compile the main table */
   1528 
   1529     Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt,
   1530         &Subtable, TRUE);
   1531     if (ACPI_FAILURE (Status))
   1532     {
   1533         return (Status);
   1534     }
   1535 
   1536     ParentTable = DtPeekSubtable ();
   1537     DtInsertSubtable (ParentTable, Subtable);
   1538 
   1539     /* Compile the argument list subtable */
   1540 
   1541     Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0,
   1542         &Subtable, TRUE);
   1543     if (ACPI_FAILURE (Status))
   1544     {
   1545         return (Status);
   1546     }
   1547 
   1548     /* Extract the length of the Arguments buffer, insert into main table */
   1549 
   1550     Length = (UINT16) Subtable->TotalLength;
   1551     Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer);
   1552     Table->ArgumentsLength = Length;
   1553 
   1554     ParentTable = DtPeekSubtable ();
   1555     DtInsertSubtable (ParentTable, Subtable);
   1556     return (AE_OK);
   1557 }
   1558 
   1559 
   1560 /******************************************************************************
   1561  *
   1562  * FUNCTION:    DtCompileXsdt
   1563  *
   1564  * PARAMETERS:  List                - Current field list pointer
   1565  *
   1566  * RETURN:      Status
   1567  *
   1568  * DESCRIPTION: Compile XSDT.
   1569  *
   1570  *****************************************************************************/
   1571 
   1572 ACPI_STATUS
   1573 DtCompileXsdt (
   1574     void                    **List)
   1575 {
   1576     DT_SUBTABLE             *Subtable;
   1577     DT_SUBTABLE             *ParentTable;
   1578     DT_FIELD                *FieldList = *(DT_FIELD **) List;
   1579     UINT64                  Address;
   1580 
   1581 
   1582     ParentTable = DtPeekSubtable ();
   1583 
   1584     while (FieldList)
   1585     {
   1586         DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
   1587 
   1588         DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
   1589         DtInsertSubtable (ParentTable, Subtable);
   1590         FieldList = FieldList->Next;
   1591     }
   1592 
   1593     return (AE_OK);
   1594 }
   1595 
   1596 
   1597 /******************************************************************************
   1598  *
   1599  * FUNCTION:    DtCompileGeneric
   1600  *
   1601  * PARAMETERS:  List                - Current field list pointer
   1602  *              Name                - Field name to end generic compiling
   1603  *              Length              - Compiled table length to return
   1604  *
   1605  * RETURN:      Status
   1606  *
   1607  * DESCRIPTION: Compile generic unknown table.
   1608  *
   1609  *****************************************************************************/
   1610 
   1611 ACPI_STATUS
   1612 DtCompileGeneric (
   1613     void                    **List,
   1614     char                    *Name,
   1615     UINT32                  *Length)
   1616 {
   1617     ACPI_STATUS             Status;
   1618     DT_SUBTABLE             *Subtable;
   1619     DT_SUBTABLE             *ParentTable;
   1620     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1621     ACPI_DMTABLE_INFO       *Info;
   1622 
   1623 
   1624     ParentTable = DtPeekSubtable ();
   1625 
   1626     /*
   1627      * Compile the "generic" portion of the table. This
   1628      * part of the table is not predefined and any of the generic
   1629      * operators may be used.
   1630      */
   1631 
   1632     /* Find any and all labels in the entire generic portion */
   1633 
   1634     DtDetectAllLabels (*PFieldList);
   1635 
   1636     /* Now we can actually compile the parse tree */
   1637 
   1638     if (Length && *Length)
   1639     {
   1640         *Length = 0;
   1641     }
   1642     while (*PFieldList)
   1643     {
   1644         if (Name && !strcmp ((*PFieldList)->Name, Name))
   1645         {
   1646             break;
   1647         }
   1648 
   1649         Info = DtGetGenericTableInfo ((*PFieldList)->Name);
   1650         if (!Info)
   1651         {
   1652             sprintf (MsgBuffer, "Generic data type \"%s\" not found",
   1653                 (*PFieldList)->Name);
   1654             DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
   1655                 (*PFieldList), MsgBuffer);
   1656 
   1657             *PFieldList = (*PFieldList)->Next;
   1658             continue;
   1659         }
   1660 
   1661         Status = DtCompileTable (PFieldList, Info,
   1662             &Subtable, TRUE);
   1663         if (ACPI_SUCCESS (Status))
   1664         {
   1665             DtInsertSubtable (ParentTable, Subtable);
   1666             if (Length)
   1667             {
   1668                 *Length += Subtable->Length;
   1669             }
   1670         }
   1671         else
   1672         {
   1673             *PFieldList = (*PFieldList)->Next;
   1674 
   1675             if (Status == AE_NOT_FOUND)
   1676             {
   1677                 sprintf (MsgBuffer, "Generic data type \"%s\" not found",
   1678                     (*PFieldList)->Name);
   1679                 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
   1680                     (*PFieldList), MsgBuffer);
   1681             }
   1682         }
   1683     }
   1684 
   1685     return (AE_OK);
   1686 }
   1687