Home | History | Annotate | Line # | Download | only in compiler
dttable2.c revision 1.1.1.2 
      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         case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
    762 
    763             InfoTable = AcpiDmTableInfoPcct2;
    764             break;
    765 
    766         default:
    767 
    768             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT");
    769             return (AE_ERROR);
    770         }
    771 
    772         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
    773         if (ACPI_FAILURE (Status))
    774         {
    775             return (Status);
    776         }
    777 
    778         ParentTable = DtPeekSubtable ();
    779         DtInsertSubtable (ParentTable, Subtable);
    780         DtPopSubtable ();
    781     }
    782 
    783     return (AE_OK);
    784 }
    785 
    786 
    787 /******************************************************************************
    788  *
    789  * FUNCTION:    DtCompilePmtt
    790  *
    791  * PARAMETERS:  List                - Current field list pointer
    792  *
    793  * RETURN:      Status
    794  *
    795  * DESCRIPTION: Compile PMTT.
    796  *
    797  *****************************************************************************/
    798 
    799 ACPI_STATUS
    800 DtCompilePmtt (
    801     void                    **List)
    802 {
    803     ACPI_STATUS             Status;
    804     DT_SUBTABLE             *Subtable;
    805     DT_SUBTABLE             *ParentTable;
    806     DT_FIELD                **PFieldList = (DT_FIELD **) List;
    807     DT_FIELD                *SubtableStart;
    808     ACPI_PMTT_HEADER        *PmttHeader;
    809     ACPI_PMTT_CONTROLLER    *PmttController;
    810     UINT16                  DomainCount;
    811     UINT8                   PrevType = ACPI_PMTT_TYPE_SOCKET;
    812 
    813 
    814     /* Main table */
    815 
    816     Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE);
    817     if (ACPI_FAILURE (Status))
    818     {
    819         return (Status);
    820     }
    821 
    822     ParentTable = DtPeekSubtable ();
    823     DtInsertSubtable (ParentTable, Subtable);
    824     DtPushSubtable (Subtable);
    825 
    826     while (*PFieldList)
    827     {
    828         SubtableStart = *PFieldList;
    829         Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr,
    830             &Subtable, TRUE);
    831         if (ACPI_FAILURE (Status))
    832         {
    833             return (Status);
    834         }
    835 
    836         PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer);
    837         while (PrevType >= PmttHeader->Type)
    838         {
    839             DtPopSubtable ();
    840 
    841             if (PrevType == ACPI_PMTT_TYPE_SOCKET)
    842             {
    843                 break;
    844             }
    845 
    846             PrevType--;
    847         }
    848 
    849         PrevType = PmttHeader->Type;
    850 
    851         ParentTable = DtPeekSubtable ();
    852         DtInsertSubtable (ParentTable, Subtable);
    853         DtPushSubtable (Subtable);
    854 
    855         switch (PmttHeader->Type)
    856         {
    857         case ACPI_PMTT_TYPE_SOCKET:
    858 
    859             /* Subtable: Socket Structure */
    860 
    861             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0,
    862                 &Subtable, TRUE);
    863             if (ACPI_FAILURE (Status))
    864             {
    865                 return (Status);
    866             }
    867 
    868             ParentTable = DtPeekSubtable ();
    869             DtInsertSubtable (ParentTable, Subtable);
    870             break;
    871 
    872         case ACPI_PMTT_TYPE_CONTROLLER:
    873 
    874             /* Subtable: Memory Controller Structure */
    875 
    876             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1,
    877                 &Subtable, TRUE);
    878             if (ACPI_FAILURE (Status))
    879             {
    880                 return (Status);
    881             }
    882 
    883             ParentTable = DtPeekSubtable ();
    884             DtInsertSubtable (ParentTable, Subtable);
    885 
    886             PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER,
    887                 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER)));
    888             DomainCount = PmttController->DomainCount;
    889 
    890             while (DomainCount)
    891             {
    892                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a,
    893                     &Subtable, TRUE);
    894                 if (ACPI_FAILURE (Status))
    895                 {
    896                     return (Status);
    897                 }
    898 
    899                 DtInsertSubtable (ParentTable, Subtable);
    900                 DomainCount--;
    901             }
    902             break;
    903 
    904         case ACPI_PMTT_TYPE_DIMM:
    905 
    906             /* Subtable: Physical Component Structure */
    907 
    908             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2,
    909                 &Subtable, TRUE);
    910             if (ACPI_FAILURE (Status))
    911             {
    912                 return (Status);
    913             }
    914 
    915             ParentTable = DtPeekSubtable ();
    916             DtInsertSubtable (ParentTable, Subtable);
    917             break;
    918 
    919         default:
    920 
    921             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT");
    922             return (AE_ERROR);
    923         }
    924     }
    925 
    926     return (Status);
    927 }
    928 
    929 
    930 /******************************************************************************
    931  *
    932  * FUNCTION:    DtCompileRsdt
    933  *
    934  * PARAMETERS:  List                - Current field list pointer
    935  *
    936  * RETURN:      Status
    937  *
    938  * DESCRIPTION: Compile RSDT.
    939  *
    940  *****************************************************************************/
    941 
    942 ACPI_STATUS
    943 DtCompileRsdt (
    944     void                    **List)
    945 {
    946     DT_SUBTABLE             *Subtable;
    947     DT_SUBTABLE             *ParentTable;
    948     DT_FIELD                *FieldList = *(DT_FIELD **) List;
    949     UINT32                  Address;
    950 
    951 
    952     ParentTable = DtPeekSubtable ();
    953 
    954     while (FieldList)
    955     {
    956         DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO);
    957 
    958         DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable);
    959         DtInsertSubtable (ParentTable, Subtable);
    960         FieldList = FieldList->Next;
    961     }
    962 
    963     return (AE_OK);
    964 }
    965 
    966 
    967 /******************************************************************************
    968  *
    969  * FUNCTION:    DtCompileS3pt
    970  *
    971  * PARAMETERS:  PFieldList          - Current field list pointer
    972  *
    973  * RETURN:      Status
    974  *
    975  * DESCRIPTION: Compile S3PT (Pointed to by FPDT)
    976  *
    977  *****************************************************************************/
    978 
    979 ACPI_STATUS
    980 DtCompileS3pt (
    981     DT_FIELD                **PFieldList)
    982 {
    983     ACPI_STATUS             Status;
    984     ACPI_FPDT_HEADER        *S3ptHeader;
    985     DT_SUBTABLE             *Subtable;
    986     DT_SUBTABLE             *ParentTable;
    987     ACPI_DMTABLE_INFO       *InfoTable;
    988     DT_FIELD                *SubtableStart;
    989 
    990 
    991     Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
    992         &Gbl_RootTable, TRUE);
    993     if (ACPI_FAILURE (Status))
    994     {
    995         return (Status);
    996     }
    997 
    998     DtPushSubtable (Gbl_RootTable);
    999 
   1000     while (*PFieldList)
   1001     {
   1002         SubtableStart = *PFieldList;
   1003         Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr,
   1004             &Subtable, TRUE);
   1005         if (ACPI_FAILURE (Status))
   1006         {
   1007             return (Status);
   1008         }
   1009 
   1010         ParentTable = DtPeekSubtable ();
   1011         DtInsertSubtable (ParentTable, Subtable);
   1012         DtPushSubtable (Subtable);
   1013 
   1014         S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
   1015 
   1016         switch (S3ptHeader->Type)
   1017         {
   1018         case ACPI_S3PT_TYPE_RESUME:
   1019 
   1020             InfoTable = AcpiDmTableInfoS3pt0;
   1021             break;
   1022 
   1023         case ACPI_S3PT_TYPE_SUSPEND:
   1024 
   1025             InfoTable = AcpiDmTableInfoS3pt1;
   1026             break;
   1027 
   1028         default:
   1029 
   1030             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT");
   1031             return (AE_ERROR);
   1032         }
   1033 
   1034         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
   1035         if (ACPI_FAILURE (Status))
   1036         {
   1037             return (Status);
   1038         }
   1039 
   1040         ParentTable = DtPeekSubtable ();
   1041         DtInsertSubtable (ParentTable, Subtable);
   1042         DtPopSubtable ();
   1043     }
   1044 
   1045     return (AE_OK);
   1046 }
   1047 
   1048 
   1049 /******************************************************************************
   1050  *
   1051  * FUNCTION:    DtCompileSlic
   1052  *
   1053  * PARAMETERS:  List                - Current field list pointer
   1054  *
   1055  * RETURN:      Status
   1056  *
   1057  * DESCRIPTION: Compile SLIC.
   1058  *
   1059  *****************************************************************************/
   1060 
   1061 ACPI_STATUS
   1062 DtCompileSlic (
   1063     void                    **List)
   1064 {
   1065     ACPI_STATUS             Status;
   1066     DT_SUBTABLE             *Subtable;
   1067     DT_SUBTABLE             *ParentTable;
   1068     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1069 
   1070 
   1071     while (*PFieldList)
   1072     {
   1073         Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic,
   1074             &Subtable, TRUE);
   1075         if (ACPI_FAILURE (Status))
   1076         {
   1077             return (Status);
   1078         }
   1079 
   1080         ParentTable = DtPeekSubtable ();
   1081         DtInsertSubtable (ParentTable, Subtable);
   1082         DtPushSubtable (Subtable);
   1083         DtPopSubtable ();
   1084     }
   1085 
   1086     return (AE_OK);
   1087 }
   1088 
   1089 
   1090 /******************************************************************************
   1091  *
   1092  * FUNCTION:    DtCompileSlit
   1093  *
   1094  * PARAMETERS:  List                - Current field list pointer
   1095  *
   1096  * RETURN:      Status
   1097  *
   1098  * DESCRIPTION: Compile SLIT.
   1099  *
   1100  *****************************************************************************/
   1101 
   1102 ACPI_STATUS
   1103 DtCompileSlit (
   1104     void                    **List)
   1105 {
   1106     ACPI_STATUS             Status;
   1107     DT_SUBTABLE             *Subtable;
   1108     DT_SUBTABLE             *ParentTable;
   1109     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1110     DT_FIELD                *FieldList;
   1111     UINT32                  Localities;
   1112     UINT8                   *LocalityBuffer;
   1113 
   1114 
   1115     Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
   1116         &Subtable, TRUE);
   1117     if (ACPI_FAILURE (Status))
   1118     {
   1119         return (Status);
   1120     }
   1121 
   1122     ParentTable = DtPeekSubtable ();
   1123     DtInsertSubtable (ParentTable, Subtable);
   1124 
   1125     Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
   1126     LocalityBuffer = UtLocalCalloc (Localities);
   1127 
   1128     /* Compile each locality buffer */
   1129 
   1130     FieldList = *PFieldList;
   1131     while (FieldList)
   1132     {
   1133         DtCompileBuffer (LocalityBuffer,
   1134             FieldList->Value, FieldList, Localities);
   1135 
   1136         DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
   1137         DtInsertSubtable (ParentTable, Subtable);
   1138         FieldList = FieldList->Next;
   1139     }
   1140 
   1141     ACPI_FREE (LocalityBuffer);
   1142     return (AE_OK);
   1143 }
   1144 
   1145 
   1146 /******************************************************************************
   1147  *
   1148  * FUNCTION:    DtCompileSrat
   1149  *
   1150  * PARAMETERS:  List                - Current field list pointer
   1151  *
   1152  * RETURN:      Status
   1153  *
   1154  * DESCRIPTION: Compile SRAT.
   1155  *
   1156  *****************************************************************************/
   1157 
   1158 ACPI_STATUS
   1159 DtCompileSrat (
   1160     void                    **List)
   1161 {
   1162     ACPI_STATUS             Status;
   1163     DT_SUBTABLE             *Subtable;
   1164     DT_SUBTABLE             *ParentTable;
   1165     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1166     DT_FIELD                *SubtableStart;
   1167     ACPI_SUBTABLE_HEADER    *SratHeader;
   1168     ACPI_DMTABLE_INFO       *InfoTable;
   1169 
   1170 
   1171     Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
   1172         &Subtable, TRUE);
   1173     if (ACPI_FAILURE (Status))
   1174     {
   1175         return (Status);
   1176     }
   1177 
   1178     ParentTable = DtPeekSubtable ();
   1179     DtInsertSubtable (ParentTable, Subtable);
   1180 
   1181     while (*PFieldList)
   1182     {
   1183         SubtableStart = *PFieldList;
   1184         Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
   1185             &Subtable, TRUE);
   1186         if (ACPI_FAILURE (Status))
   1187         {
   1188             return (Status);
   1189         }
   1190 
   1191         ParentTable = DtPeekSubtable ();
   1192         DtInsertSubtable (ParentTable, Subtable);
   1193         DtPushSubtable (Subtable);
   1194 
   1195         SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
   1196 
   1197         switch (SratHeader->Type)
   1198         {
   1199         case ACPI_SRAT_TYPE_CPU_AFFINITY:
   1200 
   1201             InfoTable = AcpiDmTableInfoSrat0;
   1202             break;
   1203 
   1204         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
   1205 
   1206             InfoTable = AcpiDmTableInfoSrat1;
   1207             break;
   1208 
   1209         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
   1210 
   1211             InfoTable = AcpiDmTableInfoSrat2;
   1212             break;
   1213 
   1214         case ACPI_SRAT_TYPE_GICC_AFFINITY:
   1215 
   1216             InfoTable = AcpiDmTableInfoSrat3;
   1217             break;
   1218 
   1219         default:
   1220 
   1221             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
   1222             return (AE_ERROR);
   1223         }
   1224 
   1225         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
   1226         if (ACPI_FAILURE (Status))
   1227         {
   1228             return (Status);
   1229         }
   1230 
   1231         ParentTable = DtPeekSubtable ();
   1232         DtInsertSubtable (ParentTable, Subtable);
   1233         DtPopSubtable ();
   1234     }
   1235 
   1236     return (AE_OK);
   1237 }
   1238 
   1239 
   1240 /******************************************************************************
   1241  *
   1242  * FUNCTION:    DtCompileStao
   1243  *
   1244  * PARAMETERS:  PFieldList          - Current field list pointer
   1245  *
   1246  * RETURN:      Status
   1247  *
   1248  * DESCRIPTION: Compile STAO.
   1249  *
   1250  *****************************************************************************/
   1251 
   1252 ACPI_STATUS
   1253 DtCompileStao (
   1254     void                    **List)
   1255 {
   1256     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1257     DT_SUBTABLE             *Subtable;
   1258     DT_SUBTABLE             *ParentTable;
   1259     ACPI_STATUS             Status;
   1260 
   1261 
   1262     /* Compile the main table */
   1263 
   1264     Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao,
   1265         &Subtable, TRUE);
   1266     if (ACPI_FAILURE (Status))
   1267     {
   1268         return (Status);
   1269     }
   1270 
   1271     ParentTable = DtPeekSubtable ();
   1272     DtInsertSubtable (ParentTable, Subtable);
   1273 
   1274     /* Compile each ASCII namestring as a subtable */
   1275 
   1276     while (*PFieldList)
   1277     {
   1278         Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr,
   1279             &Subtable, TRUE);
   1280         if (ACPI_FAILURE (Status))
   1281         {
   1282             return (Status);
   1283         }
   1284 
   1285         ParentTable = DtPeekSubtable ();
   1286         DtInsertSubtable (ParentTable, Subtable);
   1287     }
   1288 
   1289     return (AE_OK);
   1290 }
   1291 
   1292 
   1293 /******************************************************************************
   1294  *
   1295  * FUNCTION:    DtCompileTcpa
   1296  *
   1297  * PARAMETERS:  PFieldList          - Current field list pointer
   1298  *
   1299  * RETURN:      Status
   1300  *
   1301  * DESCRIPTION: Compile TCPA.
   1302  *
   1303  *****************************************************************************/
   1304 
   1305 ACPI_STATUS
   1306 DtCompileTcpa (
   1307     void                    **List)
   1308 {
   1309     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1310     DT_SUBTABLE             *Subtable;
   1311     ACPI_TABLE_TCPA_HDR     *TcpaHeader;
   1312     DT_SUBTABLE             *ParentTable;
   1313     ACPI_STATUS             Status;
   1314 
   1315 
   1316     /* Compile the main table */
   1317 
   1318     Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
   1319         &Subtable, TRUE);
   1320     if (ACPI_FAILURE (Status))
   1321     {
   1322         return (Status);
   1323     }
   1324 
   1325     ParentTable = DtPeekSubtable ();
   1326     DtInsertSubtable (ParentTable, Subtable);
   1327 
   1328     /*
   1329      * Examine the PlatformClass field to determine the table type.
   1330      * Either a client or server table. Only one.
   1331      */
   1332     TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
   1333 
   1334     switch (TcpaHeader->PlatformClass)
   1335     {
   1336     case ACPI_TCPA_CLIENT_TABLE:
   1337 
   1338         Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
   1339             &Subtable, TRUE);
   1340         break;
   1341 
   1342     case ACPI_TCPA_SERVER_TABLE:
   1343 
   1344         Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
   1345             &Subtable, TRUE);
   1346         break;
   1347 
   1348     default:
   1349 
   1350         AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
   1351             TcpaHeader->PlatformClass);
   1352         Status = AE_ERROR;
   1353         break;
   1354     }
   1355 
   1356     ParentTable = DtPeekSubtable ();
   1357     DtInsertSubtable (ParentTable, Subtable);
   1358     return (Status);
   1359 }
   1360 
   1361 
   1362 /******************************************************************************
   1363  *
   1364  * FUNCTION:    DtGetGenericTableInfo
   1365  *
   1366  * PARAMETERS:  Name                - Generic type name
   1367  *
   1368  * RETURN:      Info entry
   1369  *
   1370  * DESCRIPTION: Obtain table info for a generic name entry
   1371  *
   1372  *****************************************************************************/
   1373 
   1374 ACPI_DMTABLE_INFO *
   1375 DtGetGenericTableInfo (
   1376     char                    *Name)
   1377 {
   1378     ACPI_DMTABLE_INFO       *Info;
   1379     UINT32                  i;
   1380 
   1381 
   1382     if (!Name)
   1383     {
   1384         return (NULL);
   1385     }
   1386 
   1387     /* Search info table for name match */
   1388 
   1389     for (i = 0; ; i++)
   1390     {
   1391         Info = AcpiDmTableInfoGeneric[i];
   1392         if (Info->Opcode == ACPI_DMT_EXIT)
   1393         {
   1394             Info = NULL;
   1395             break;
   1396         }
   1397 
   1398         /* Use caseless compare for generic keywords */
   1399 
   1400         if (!AcpiUtStricmp (Name, Info->Name))
   1401         {
   1402             break;
   1403         }
   1404     }
   1405 
   1406     return (Info);
   1407 }
   1408 
   1409 
   1410 /******************************************************************************
   1411  *
   1412  * FUNCTION:    DtCompileUefi
   1413  *
   1414  * PARAMETERS:  List                - Current field list pointer
   1415  *
   1416  * RETURN:      Status
   1417  *
   1418  * DESCRIPTION: Compile UEFI.
   1419  *
   1420  *****************************************************************************/
   1421 
   1422 ACPI_STATUS
   1423 DtCompileUefi (
   1424     void                    **List)
   1425 {
   1426     ACPI_STATUS             Status;
   1427     DT_SUBTABLE             *Subtable;
   1428     DT_SUBTABLE             *ParentTable;
   1429     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1430     UINT16                  *DataOffset;
   1431 
   1432 
   1433     /* Compile the predefined portion of the UEFI table */
   1434 
   1435     Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
   1436         &Subtable, TRUE);
   1437     if (ACPI_FAILURE (Status))
   1438     {
   1439         return (Status);
   1440     }
   1441 
   1442     DataOffset = (UINT16 *) (Subtable->Buffer + 16);
   1443     *DataOffset = sizeof (ACPI_TABLE_UEFI);
   1444 
   1445     ParentTable = DtPeekSubtable ();
   1446     DtInsertSubtable (ParentTable, Subtable);
   1447 
   1448     /*
   1449      * Compile the "generic" portion of the UEFI table. This
   1450      * part of the table is not predefined and any of the generic
   1451      * operators may be used.
   1452      */
   1453     DtCompileGeneric ((void **) PFieldList, NULL, NULL);
   1454     return (AE_OK);
   1455 }
   1456 
   1457 
   1458 /******************************************************************************
   1459  *
   1460  * FUNCTION:    DtCompileVrtc
   1461  *
   1462  * PARAMETERS:  List                - Current field list pointer
   1463  *
   1464  * RETURN:      Status
   1465  *
   1466  * DESCRIPTION: Compile VRTC.
   1467  *
   1468  *****************************************************************************/
   1469 
   1470 ACPI_STATUS
   1471 DtCompileVrtc (
   1472     void                    **List)
   1473 {
   1474     ACPI_STATUS             Status;
   1475 
   1476 
   1477     Status = DtCompileTwoSubtables (List,
   1478         AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0);
   1479     return (Status);
   1480 }
   1481 
   1482 
   1483 /******************************************************************************
   1484  *
   1485  * FUNCTION:    DtCompileWdat
   1486  *
   1487  * PARAMETERS:  List                - Current field list pointer
   1488  *
   1489  * RETURN:      Status
   1490  *
   1491  * DESCRIPTION: Compile WDAT.
   1492  *
   1493  *****************************************************************************/
   1494 
   1495 ACPI_STATUS
   1496 DtCompileWdat (
   1497     void                    **List)
   1498 {
   1499     ACPI_STATUS             Status;
   1500 
   1501 
   1502     Status = DtCompileTwoSubtables (List,
   1503         AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
   1504     return (Status);
   1505 }
   1506 
   1507 
   1508 /******************************************************************************
   1509  *
   1510  * FUNCTION:    DtCompileWpbt
   1511  *
   1512  * PARAMETERS:  List                - Current field list pointer
   1513  *
   1514  * RETURN:      Status
   1515  *
   1516  * DESCRIPTION: Compile WPBT.
   1517  *
   1518  *****************************************************************************/
   1519 
   1520 ACPI_STATUS
   1521 DtCompileWpbt (
   1522     void                    **List)
   1523 {
   1524     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1525     DT_SUBTABLE             *Subtable;
   1526     DT_SUBTABLE             *ParentTable;
   1527     ACPI_TABLE_WPBT         *Table;
   1528     ACPI_STATUS             Status;
   1529     UINT16                  Length;
   1530 
   1531 
   1532     /* Compile the main table */
   1533 
   1534     Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt,
   1535         &Subtable, TRUE);
   1536     if (ACPI_FAILURE (Status))
   1537     {
   1538         return (Status);
   1539     }
   1540 
   1541     ParentTable = DtPeekSubtable ();
   1542     DtInsertSubtable (ParentTable, Subtable);
   1543 
   1544     /* Compile the argument list subtable */
   1545 
   1546     Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0,
   1547         &Subtable, TRUE);
   1548     if (ACPI_FAILURE (Status))
   1549     {
   1550         return (Status);
   1551     }
   1552 
   1553     /* Extract the length of the Arguments buffer, insert into main table */
   1554 
   1555     Length = (UINT16) Subtable->TotalLength;
   1556     Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer);
   1557     Table->ArgumentsLength = Length;
   1558 
   1559     ParentTable = DtPeekSubtable ();
   1560     DtInsertSubtable (ParentTable, Subtable);
   1561     return (AE_OK);
   1562 }
   1563 
   1564 
   1565 /******************************************************************************
   1566  *
   1567  * FUNCTION:    DtCompileXsdt
   1568  *
   1569  * PARAMETERS:  List                - Current field list pointer
   1570  *
   1571  * RETURN:      Status
   1572  *
   1573  * DESCRIPTION: Compile XSDT.
   1574  *
   1575  *****************************************************************************/
   1576 
   1577 ACPI_STATUS
   1578 DtCompileXsdt (
   1579     void                    **List)
   1580 {
   1581     DT_SUBTABLE             *Subtable;
   1582     DT_SUBTABLE             *ParentTable;
   1583     DT_FIELD                *FieldList = *(DT_FIELD **) List;
   1584     UINT64                  Address;
   1585 
   1586 
   1587     ParentTable = DtPeekSubtable ();
   1588 
   1589     while (FieldList)
   1590     {
   1591         DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
   1592 
   1593         DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
   1594         DtInsertSubtable (ParentTable, Subtable);
   1595         FieldList = FieldList->Next;
   1596     }
   1597 
   1598     return (AE_OK);
   1599 }
   1600 
   1601 
   1602 /******************************************************************************
   1603  *
   1604  * FUNCTION:    DtCompileGeneric
   1605  *
   1606  * PARAMETERS:  List                - Current field list pointer
   1607  *              Name                - Field name to end generic compiling
   1608  *              Length              - Compiled table length to return
   1609  *
   1610  * RETURN:      Status
   1611  *
   1612  * DESCRIPTION: Compile generic unknown table.
   1613  *
   1614  *****************************************************************************/
   1615 
   1616 ACPI_STATUS
   1617 DtCompileGeneric (
   1618     void                    **List,
   1619     char                    *Name,
   1620     UINT32                  *Length)
   1621 {
   1622     ACPI_STATUS             Status;
   1623     DT_SUBTABLE             *Subtable;
   1624     DT_SUBTABLE             *ParentTable;
   1625     DT_FIELD                **PFieldList = (DT_FIELD **) List;
   1626     ACPI_DMTABLE_INFO       *Info;
   1627 
   1628 
   1629     ParentTable = DtPeekSubtable ();
   1630 
   1631     /*
   1632      * Compile the "generic" portion of the table. This
   1633      * part of the table is not predefined and any of the generic
   1634      * operators may be used.
   1635      */
   1636 
   1637     /* Find any and all labels in the entire generic portion */
   1638 
   1639     DtDetectAllLabels (*PFieldList);
   1640 
   1641     /* Now we can actually compile the parse tree */
   1642 
   1643     if (Length && *Length)
   1644     {
   1645         *Length = 0;
   1646     }
   1647     while (*PFieldList)
   1648     {
   1649         if (Name && !strcmp ((*PFieldList)->Name, Name))
   1650         {
   1651             break;
   1652         }
   1653 
   1654         Info = DtGetGenericTableInfo ((*PFieldList)->Name);
   1655         if (!Info)
   1656         {
   1657             sprintf (MsgBuffer, "Generic data type \"%s\" not found",
   1658                 (*PFieldList)->Name);
   1659             DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
   1660                 (*PFieldList), MsgBuffer);
   1661 
   1662             *PFieldList = (*PFieldList)->Next;
   1663             continue;
   1664         }
   1665 
   1666         Status = DtCompileTable (PFieldList, Info,
   1667             &Subtable, TRUE);
   1668         if (ACPI_SUCCESS (Status))
   1669         {
   1670             DtInsertSubtable (ParentTable, Subtable);
   1671             if (Length)
   1672             {
   1673                 *Length += Subtable->Length;
   1674             }
   1675         }
   1676         else
   1677         {
   1678             *PFieldList = (*PFieldList)->Next;
   1679 
   1680             if (Status == AE_NOT_FOUND)
   1681             {
   1682                 sprintf (MsgBuffer, "Generic data type \"%s\" not found",
   1683                     (*PFieldList)->Name);
   1684                 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
   1685                     (*PFieldList), MsgBuffer);
   1686             }
   1687         }
   1688     }
   1689 
   1690     return (AE_OK);
   1691 }
   1692