sys/contrib/dev/acpica/source/compiler/dttable1.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dttable1.c - handling for specific ACPI tables
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2020, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************
 115  *
 116  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 /* Compile all complex data tables, signatures starting with A-I */
 153
 154 #include "aslcompiler.h"
 155
 156 #define _COMPONENT          DT_COMPILER
 157         ACPI_MODULE_NAME    ("dttable1")
 158
 159
 160 static ACPI_DMTABLE_INFO           TableInfoAsfAddress[] =
 161 {
 162     {ACPI_DMT_BUFFER,   0,               "Addresses", 0},
 163     {ACPI_DMT_EXIT,     0,               NULL, 0}
 164 };
 165
 166 static ACPI_DMTABLE_INFO           TableInfoDmarPciPath[] =
 167 {
 168     {ACPI_DMT_PCI_PATH, 0,               "PCI Path", 0},
 169     {ACPI_DMT_EXIT,     0,               NULL, 0}
 170 };
 171
 172
 173 /******************************************************************************
 174  *
 175  * FUNCTION:    DtCompileAsf
 176  *
 177  * PARAMETERS:  List                - Current field list pointer
 178  *
 179  * RETURN:      Status
 180  *
 181  * DESCRIPTION: Compile ASF!.
 182  *
 183  *****************************************************************************/
 184
 185 ACPI_STATUS
 186 DtCompileAsf (
 187     void                    **List)
 188 {
 189     ACPI_ASF_INFO           *AsfTable;
 190     DT_SUBTABLE             *Subtable;
 191     DT_SUBTABLE             *ParentTable;
 192     ACPI_DMTABLE_INFO       *InfoTable;
 193     ACPI_DMTABLE_INFO       *DataInfoTable = NULL;
 194     UINT32                  DataCount = 0;
 195     ACPI_STATUS             Status;
 196     UINT32                  i;
 197     DT_FIELD                **PFieldList = (DT_FIELD **) List;
 198     DT_FIELD                *SubtableStart;
 199
 200
 201     while (*PFieldList)
 202     {
 203         SubtableStart = *PFieldList;
 204         Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr,
 205             &Subtable);
 206         if (ACPI_FAILURE (Status))
 207         {
 208             return (Status);
 209         }
 210
 211         ParentTable = DtPeekSubtable ();
 212         DtInsertSubtable (ParentTable, Subtable);
 213         DtPushSubtable (Subtable);
 214
 215         AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer);
 216
 217         switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
 218         {
 219         case ACPI_ASF_TYPE_INFO:
 220
 221             InfoTable = AcpiDmTableInfoAsf0;
 222             break;
 223
 224         case ACPI_ASF_TYPE_ALERT:
 225
 226             InfoTable = AcpiDmTableInfoAsf1;
 227             break;
 228
 229         case ACPI_ASF_TYPE_CONTROL:
 230
 231             InfoTable = AcpiDmTableInfoAsf2;
 232             break;
 233
 234         case ACPI_ASF_TYPE_BOOT:
 235
 236             InfoTable = AcpiDmTableInfoAsf3;
 237             break;
 238
 239         case ACPI_ASF_TYPE_ADDRESS:
 240
 241             InfoTable = AcpiDmTableInfoAsf4;
 242             break;
 243
 244         default:
 245
 246             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
 247             return (AE_ERROR);
 248         }
 249
 250         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
 251         if (ACPI_FAILURE (Status))
 252         {
 253             return (Status);
 254         }
 255
 256         ParentTable = DtPeekSubtable ();
 257         DtInsertSubtable (ParentTable, Subtable);
 258
 259         switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
 260         {
 261         case ACPI_ASF_TYPE_INFO:
 262
 263             DataInfoTable = NULL;
 264             break;
 265
 266         case ACPI_ASF_TYPE_ALERT:
 267
 268             DataInfoTable = AcpiDmTableInfoAsf1a;
 269             DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT,
 270                 ACPI_SUB_PTR (UINT8, Subtable->Buffer,
 271                     sizeof (ACPI_ASF_HEADER)))->Alerts;
 272             break;
 273
 274         case ACPI_ASF_TYPE_CONTROL:
 275
 276             DataInfoTable = AcpiDmTableInfoAsf2a;
 277             DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE,
 278                 ACPI_SUB_PTR (UINT8, Subtable->Buffer,
 279                     sizeof (ACPI_ASF_HEADER)))->Controls;
 280             break;
 281
 282         case ACPI_ASF_TYPE_BOOT:
 283
 284             DataInfoTable = NULL;
 285             break;
 286
 287         case ACPI_ASF_TYPE_ADDRESS:
 288
 289             DataInfoTable = TableInfoAsfAddress;
 290             DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS,
 291                 ACPI_SUB_PTR (UINT8, Subtable->Buffer,
 292                     sizeof (ACPI_ASF_HEADER)))->Devices;
 293             break;
 294
 295         default:
 296
 297             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
 298             return (AE_ERROR);
 299         }
 300
 301         if (DataInfoTable)
 302         {
 303             switch (AsfTable->Header.Type & 0x7F)
 304             {
 305             case ACPI_ASF_TYPE_ADDRESS:
 306
 307                 while (DataCount > 0)
 308                 {
 309                     Status = DtCompileTable (PFieldList, DataInfoTable,
 310                         &Subtable);
 311                     if (ACPI_FAILURE (Status))
 312                     {
 313                         return (Status);
 314                     }
 315
 316                     DtInsertSubtable (ParentTable, Subtable);
 317                     DataCount = DataCount - Subtable->Length;
 318                 }
 319                 break;
 320
 321             default:
 322
 323                 for (i = 0; i < DataCount; i++)
 324                 {
 325                     Status = DtCompileTable (PFieldList, DataInfoTable,
 326                         &Subtable);
 327                     if (ACPI_FAILURE (Status))
 328                     {
 329                         return (Status);
 330                     }
 331
 332                     DtInsertSubtable (ParentTable, Subtable);
 333                 }
 334                 break;
 335             }
 336         }
 337
 338         DtPopSubtable ();
 339     }
 340
 341     return (AE_OK);
 342 }
 343
 344
 345 /******************************************************************************
 346  *
 347  * FUNCTION:    DtCompileCpep
 348  *
 349  * PARAMETERS:  List                - Current field list pointer
 350  *
 351  * RETURN:      Status
 352  *
 353  * DESCRIPTION: Compile CPEP.
 354  *
 355  *****************************************************************************/
 356
 357 ACPI_STATUS
 358 DtCompileCpep (
 359     void                    **List)
 360 {
 361     ACPI_STATUS             Status;
 362
 363
 364     Status = DtCompileTwoSubtables (List,
 365         AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0);
 366     return (Status);
 367 }
 368
 369
 370 /******************************************************************************
 371  *
 372  * FUNCTION:    DtCompileCsrt
 373  *
 374  * PARAMETERS:  List                - Current field list pointer
 375  *
 376  * RETURN:      Status
 377  *
 378  * DESCRIPTION: Compile CSRT.
 379  *
 380  *****************************************************************************/
 381
 382 ACPI_STATUS
 383 DtCompileCsrt (
 384     void                    **List)
 385 {
 386     ACPI_STATUS             Status = AE_OK;
 387     DT_SUBTABLE             *Subtable;
 388     DT_SUBTABLE             *ParentTable;
 389     DT_FIELD                **PFieldList = (DT_FIELD **) List;
 390     UINT32                  DescriptorCount;
 391     UINT32                  GroupLength;
 392
 393
 394     /* Subtables (Resource Groups) */
 395
 396     ParentTable = DtPeekSubtable ();
 397     while (*PFieldList)
 398     {
 399         /* Resource group subtable */
 400
 401         Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt0,
 402             &Subtable);
 403         if (ACPI_FAILURE (Status))
 404         {
 405             return (Status);
 406         }
 407
 408         /* Compute the number of resource descriptors */
 409
 410         GroupLength =
 411             (ACPI_CAST_PTR (ACPI_CSRT_GROUP,
 412                 Subtable->Buffer))->Length -
 413             (ACPI_CAST_PTR (ACPI_CSRT_GROUP,
 414                 Subtable->Buffer))->SharedInfoLength -
 415             sizeof (ACPI_CSRT_GROUP);
 416
 417         DescriptorCount = (GroupLength  /
 418             sizeof (ACPI_CSRT_DESCRIPTOR));
 419
 420         DtInsertSubtable (ParentTable, Subtable);
 421         DtPushSubtable (Subtable);
 422         ParentTable = DtPeekSubtable ();
 423
 424         /* Shared info subtable (One per resource group) */
 425
 426         Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt1,
 427             &Subtable);
 428         if (ACPI_FAILURE (Status))
 429         {
 430             return (Status);
 431         }
 432
 433         DtInsertSubtable (ParentTable, Subtable);
 434
 435         /* Sub-Subtables (Resource Descriptors) */
 436
 437         while (*PFieldList && DescriptorCount)
 438         {
 439
 440             Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2,
 441                 &Subtable);
 442             if (ACPI_FAILURE (Status))
 443             {
 444                 return (Status);
 445             }
 446
 447             DtInsertSubtable (ParentTable, Subtable);
 448
 449             DtPushSubtable (Subtable);
 450             ParentTable = DtPeekSubtable ();
 451             if (*PFieldList)
 452             {
 453                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2a,
 454                     &Subtable);
 455                 if (ACPI_FAILURE (Status))
 456                 {
 457                     return (Status);
 458                 }
 459                 if (Subtable)
 460                 {
 461                     DtInsertSubtable (ParentTable, Subtable);
 462                 }
 463             }
 464
 465             DtPopSubtable ();
 466             ParentTable = DtPeekSubtable ();
 467             DescriptorCount--;
 468         }
 469
 470         DtPopSubtable ();
 471         ParentTable = DtPeekSubtable ();
 472     }
 473
 474     return (Status);
 475 }
 476
 477
 478 /******************************************************************************
 479  *
 480  * FUNCTION:    DtCompileDbg2
 481  *
 482  * PARAMETERS:  List                - Current field list pointer
 483  *
 484  * RETURN:      Status
 485  *
 486  * DESCRIPTION: Compile DBG2.
 487  *
 488  *****************************************************************************/
 489
 490 ACPI_STATUS
 491 DtCompileDbg2 (
 492     void                    **List)
 493 {
 494     ACPI_STATUS             Status;
 495     DT_SUBTABLE             *Subtable;
 496     DT_SUBTABLE             *ParentTable;
 497     DT_FIELD                **PFieldList = (DT_FIELD **) List;
 498     UINT32                  SubtableCount;
 499     ACPI_DBG2_HEADER        *Dbg2Header;
 500     ACPI_DBG2_DEVICE        *DeviceInfo;
 501     UINT16                  CurrentOffset;
 502     UINT32                  i;
 503
 504
 505     /* Main table */
 506
 507     Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2, &Subtable);
 508     if (ACPI_FAILURE (Status))
 509     {
 510         return (Status);
 511     }
 512
 513     ParentTable = DtPeekSubtable ();
 514     DtInsertSubtable (ParentTable, Subtable);
 515
 516     /* Main table fields */
 517
 518     Dbg2Header = ACPI_CAST_PTR (ACPI_DBG2_HEADER, Subtable->Buffer);
 519     Dbg2Header->InfoOffset = sizeof (ACPI_TABLE_HEADER) + ACPI_PTR_DIFF (
 520         ACPI_ADD_PTR (UINT8, Dbg2Header, sizeof (ACPI_DBG2_HEADER)), Dbg2Header);
 521
 522     SubtableCount = Dbg2Header->InfoCount;
 523     DtPushSubtable (Subtable);
 524
 525     /* Process all Device Information subtables (Count = InfoCount) */
 526
 527     while (*PFieldList && SubtableCount)
 528     {
 529         /* Subtable: Debug Device Information */
 530
 531         Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Device,
 532             &Subtable);
 533         if (ACPI_FAILURE (Status))
 534         {
 535             return (Status);
 536         }
 537
 538         DeviceInfo = ACPI_CAST_PTR (ACPI_DBG2_DEVICE, Subtable->Buffer);
 539         CurrentOffset = (UINT16) sizeof (ACPI_DBG2_DEVICE);
 540
 541         ParentTable = DtPeekSubtable ();
 542         DtInsertSubtable (ParentTable, Subtable);
 543         DtPushSubtable (Subtable);
 544
 545         ParentTable = DtPeekSubtable ();
 546
 547         /* BaseAddressRegister GAS array (Required, size is RegisterCount) */
 548
 549         DeviceInfo->BaseAddressOffset = CurrentOffset;
 550         for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++)
 551         {
 552             Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Addr,
 553                 &Subtable);
 554             if (ACPI_FAILURE (Status))
 555             {
 556                 return (Status);
 557             }
 558
 559             CurrentOffset += (UINT16) sizeof (ACPI_GENERIC_ADDRESS);
 560             DtInsertSubtable (ParentTable, Subtable);
 561         }
 562
 563         /* AddressSize array (Required, size = RegisterCount) */
 564
 565         DeviceInfo->AddressSizeOffset = CurrentOffset;
 566         for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++)
 567         {
 568             Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Size,
 569                 &Subtable);
 570             if (ACPI_FAILURE (Status))
 571             {
 572                 return (Status);
 573             }
 574
 575             CurrentOffset += (UINT16) sizeof (UINT32);
 576             DtInsertSubtable (ParentTable, Subtable);
 577         }
 578
 579         /* NamespaceString device identifier (Required, size = NamePathLength) */
 580
 581         DeviceInfo->NamepathOffset = CurrentOffset;
 582         Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Name,
 583             &Subtable);
 584         if (ACPI_FAILURE (Status))
 585         {
 586             return (Status);
 587         }
 588
 589         /* Update the device info header */
 590
 591         DeviceInfo->NamepathLength = (UINT16) Subtable->Length;
 592         CurrentOffset += (UINT16) DeviceInfo->NamepathLength;
 593         DtInsertSubtable (ParentTable, Subtable);
 594
 595         /* OemData - Variable-length data (Optional, size = OemDataLength) */
 596
 597         Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2OemData,
 598             &Subtable);
 599         if (Status == AE_END_OF_TABLE)
 600         {
 601             /* optional field was not found and we're at the end of the file */
 602
 603             goto subtableDone;
 604         }
 605         else if (ACPI_FAILURE (Status))
 606         {
 607             return (Status);
 608         }
 609
 610         /* Update the device info header (zeros if no OEM data present) */
 611
 612         DeviceInfo->OemDataOffset = 0;
 613         DeviceInfo->OemDataLength = 0;
 614
 615         /* Optional subtable (OemData) */
 616
 617         if (Subtable && Subtable->Length)
 618         {
 619             DeviceInfo->OemDataOffset = CurrentOffset;
 620             DeviceInfo->OemDataLength = (UINT16) Subtable->Length;
 621
 622             DtInsertSubtable (ParentTable, Subtable);
 623         }
 624 subtableDone:
 625         SubtableCount--;
 626         DtPopSubtable (); /* Get next Device Information subtable */
 627     }
 628
 629     DtPopSubtable ();
 630     return (AE_OK);
 631 }
 632
 633
 634 /******************************************************************************
 635  *
 636  * FUNCTION:    DtCompileDmar
 637  *
 638  * PARAMETERS:  List                - Current field list pointer
 639  *
 640  * RETURN:      Status
 641  *
 642  * DESCRIPTION: Compile DMAR.
 643  *
 644  *****************************************************************************/
 645
 646 ACPI_STATUS
 647 DtCompileDmar (
 648     void                    **List)
 649 {
 650     ACPI_STATUS             Status;
 651     DT_SUBTABLE             *Subtable;
 652     DT_SUBTABLE             *ParentTable;
 653     DT_FIELD                **PFieldList = (DT_FIELD **) List;
 654     DT_FIELD                *SubtableStart;
 655     ACPI_DMTABLE_INFO       *InfoTable;
 656     ACPI_DMAR_HEADER        *DmarHeader;
 657     ACPI_DMAR_DEVICE_SCOPE  *DmarDeviceScope;
 658     UINT32                  DeviceScopeLength;
 659     UINT32                  PciPathLength;
 660
 661
 662     Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable);
 663     if (ACPI_FAILURE (Status))
 664     {
 665         return (Status);
 666     }
 667
 668     ParentTable = DtPeekSubtable ();
 669     DtInsertSubtable (ParentTable, Subtable);
 670     DtPushSubtable (Subtable);
 671
 672     while (*PFieldList)
 673     {
 674         /* DMAR Header */
 675
 676         SubtableStart = *PFieldList;
 677         Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarHdr,
 678             &Subtable);
 679         if (ACPI_FAILURE (Status))
 680         {
 681             return (Status);
 682         }
 683
 684         ParentTable = DtPeekSubtable ();
 685         DtInsertSubtable (ParentTable, Subtable);
 686         DtPushSubtable (Subtable);
 687
 688         DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer);
 689
 690         switch (DmarHeader->Type)
 691         {
 692         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 693
 694             InfoTable = AcpiDmTableInfoDmar0;
 695             break;
 696
 697         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
 698
 699             InfoTable = AcpiDmTableInfoDmar1;
 700             break;
 701
 702         case ACPI_DMAR_TYPE_ROOT_ATS:
 703
 704             InfoTable = AcpiDmTableInfoDmar2;
 705             break;
 706
 707         case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
 708
 709             InfoTable = AcpiDmTableInfoDmar3;
 710             break;
 711
 712         case ACPI_DMAR_TYPE_NAMESPACE:
 713
 714             InfoTable = AcpiDmTableInfoDmar4;
 715             break;
 716
 717         default:
 718
 719             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "DMAR");
 720             return (AE_ERROR);
 721         }
 722
 723         /* DMAR Subtable */
 724
 725         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
 726         if (ACPI_FAILURE (Status))
 727         {
 728             return (Status);
 729         }
 730
 731         ParentTable = DtPeekSubtable ();
 732         DtInsertSubtable (ParentTable, Subtable);
 733
 734         /*
 735          * Optional Device Scope subtables
 736          */
 737         if ((DmarHeader->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
 738             (DmarHeader->Type == ACPI_DMAR_TYPE_NAMESPACE))
 739         {
 740             /* These types do not support device scopes */
 741
 742             DtPopSubtable ();
 743             continue;
 744         }
 745
 746         DtPushSubtable (Subtable);
 747         DeviceScopeLength = DmarHeader->Length - Subtable->Length -
 748             ParentTable->Length;
 749         while (DeviceScopeLength)
 750         {
 751             Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope,
 752                 &Subtable);
 753             if (Status == AE_NOT_FOUND)
 754             {
 755                 break;
 756             }
 757
 758             ParentTable = DtPeekSubtable ();
 759             DtInsertSubtable (ParentTable, Subtable);
 760             DtPushSubtable (Subtable);
 761
 762             DmarDeviceScope = ACPI_CAST_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable->Buffer);
 763
 764             /* Optional PCI Paths */
 765
 766             PciPathLength = DmarDeviceScope->Length - Subtable->Length;
 767             while (PciPathLength)
 768             {
 769                 Status = DtCompileTable (PFieldList, TableInfoDmarPciPath,
 770                     &Subtable);
 771                 if (Status == AE_NOT_FOUND)
 772                 {
 773                     DtPopSubtable ();
 774                     break;
 775                 }
 776
 777                 ParentTable = DtPeekSubtable ();
 778                 DtInsertSubtable (ParentTable, Subtable);
 779                 PciPathLength -= Subtable->Length;
 780             }
 781
 782             DtPopSubtable ();
 783             DeviceScopeLength -= DmarDeviceScope->Length;
 784         }
 785
 786         DtPopSubtable ();
 787         DtPopSubtable ();
 788     }
 789
 790     return (AE_OK);
 791 }
 792
 793
 794 /******************************************************************************
 795  *
 796  * FUNCTION:    DtCompileDrtm
 797  *
 798  * PARAMETERS:  List                - Current field list pointer
 799  *
 800  * RETURN:      Status
 801  *
 802  * DESCRIPTION: Compile DRTM.
 803  *
 804  *****************************************************************************/
 805
 806 ACPI_STATUS
 807 DtCompileDrtm (
 808     void                    **List)
 809 {
 810     ACPI_STATUS             Status;
 811     DT_SUBTABLE             *Subtable;
 812     DT_SUBTABLE             *ParentTable;
 813     DT_FIELD                **PFieldList = (DT_FIELD **) List;
 814     UINT32                  Count;
 815     /* ACPI_TABLE_DRTM         *Drtm; */
 816     ACPI_DRTM_VTABLE_LIST   *DrtmVtl;
 817     ACPI_DRTM_RESOURCE_LIST *DrtmRl;
 818     /* ACPI_DRTM_DPS_ID        *DrtmDps; */
 819
 820
 821     ParentTable = DtPeekSubtable ();
 822
 823     /* Compile DRTM header */
 824
 825     Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm,
 826         &Subtable);
 827     if (ACPI_FAILURE (Status))
 828     {
 829         return (Status);
 830     }
 831     DtInsertSubtable (ParentTable, Subtable);
 832
 833     /*
 834      * Using ACPI_SUB_PTR, We needn't define a separate structure. Care
 835      * should be taken to avoid accessing ACPI_TABLE_HADER fields.
 836      */
 837 #if 0
 838     Drtm = ACPI_SUB_PTR (ACPI_TABLE_DRTM,
 839         Subtable->Buffer, sizeof (ACPI_TABLE_HEADER));
 840 #endif
 841     /* Compile VTL */
 842
 843     Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0,
 844         &Subtable);
 845     if (ACPI_FAILURE (Status))
 846     {
 847         return (Status);
 848     }
 849
 850     DtInsertSubtable (ParentTable, Subtable);
 851     DrtmVtl = ACPI_CAST_PTR (ACPI_DRTM_VTABLE_LIST, Subtable->Buffer);
 852
 853     DtPushSubtable (Subtable);
 854     ParentTable = DtPeekSubtable ();
 855     Count = 0;
 856
 857     while (*PFieldList)
 858     {
 859         Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0a,
 860             &Subtable);
 861         if (ACPI_FAILURE (Status))
 862         {
 863             return (Status);
 864         }
 865         if (!Subtable)
 866         {
 867             break;
 868         }
 869         DtInsertSubtable (ParentTable, Subtable);
 870         Count++;
 871     }
 872
 873     DrtmVtl->ValidatedTableCount = Count;
 874     DtPopSubtable ();
 875     ParentTable = DtPeekSubtable ();
 876
 877     /* Compile RL */
 878
 879     Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1,
 880         &Subtable);
 881     if (ACPI_FAILURE (Status))
 882     {
 883         return (Status);
 884     }
 885
 886     DtInsertSubtable (ParentTable, Subtable);
 887     DrtmRl = ACPI_CAST_PTR (ACPI_DRTM_RESOURCE_LIST, Subtable->Buffer);
 888
 889     DtPushSubtable (Subtable);
 890     ParentTable = DtPeekSubtable ();
 891     Count = 0;
 892
 893     while (*PFieldList)
 894     {
 895         Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1a,
 896             &Subtable);
 897         if (ACPI_FAILURE (Status))
 898         {
 899             return (Status);
 900         }
 901
 902         if (!Subtable)
 903         {
 904             break;
 905         }
 906
 907         DtInsertSubtable (ParentTable, Subtable);
 908         Count++;
 909     }
 910
 911     DrtmRl->ResourceCount = Count;
 912     DtPopSubtable ();
 913     ParentTable = DtPeekSubtable ();
 914
 915     /* Compile DPS */
 916
 917     Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm2,
 918         &Subtable);
 919     if (ACPI_FAILURE (Status))
 920     {
 921         return (Status);
 922     }
 923     DtInsertSubtable (ParentTable, Subtable);
 924     /* DrtmDps = ACPI_CAST_PTR (ACPI_DRTM_DPS_ID, Subtable->Buffer);*/
 925
 926
 927     return (AE_OK);
 928 }
 929
 930
 931 /******************************************************************************
 932  *
 933  * FUNCTION:    DtCompileEinj
 934  *
 935  * PARAMETERS:  List                - Current field list pointer
 936  *
 937  * RETURN:      Status
 938  *
 939  * DESCRIPTION: Compile EINJ.
 940  *
 941  *****************************************************************************/
 942
 943 ACPI_STATUS
 944 DtCompileEinj (
 945     void                    **List)
 946 {
 947     ACPI_STATUS             Status;
 948
 949
 950     Status = DtCompileTwoSubtables (List,
 951         AcpiDmTableInfoEinj, AcpiDmTableInfoEinj0);
 952     return (Status);
 953 }
 954
 955
 956 /******************************************************************************
 957  *
 958  * FUNCTION:    DtCompileErst
 959  *
 960  * PARAMETERS:  List                - Current field list pointer
 961  *
 962  * RETURN:      Status
 963  *
 964  * DESCRIPTION: Compile ERST.
 965  *
 966  *****************************************************************************/
 967
 968 ACPI_STATUS
 969 DtCompileErst (
 970     void                    **List)
 971 {
 972     ACPI_STATUS             Status;
 973
 974
 975     Status = DtCompileTwoSubtables (List,
 976         AcpiDmTableInfoErst, AcpiDmTableInfoEinj0);
 977     return (Status);
 978 }
 979
 980
 981 /******************************************************************************
 982  *
 983  * FUNCTION:    DtCompileGtdt
 984  *
 985  * PARAMETERS:  List                - Current field list pointer
 986  *
 987  * RETURN:      Status
 988  *
 989  * DESCRIPTION: Compile GTDT.
 990  *
 991  *****************************************************************************/
 992
 993 ACPI_STATUS
 994 DtCompileGtdt (
 995     void                    **List)
 996 {
 997     ACPI_STATUS             Status;
 998     DT_SUBTABLE             *Subtable;
 999     DT_SUBTABLE             *ParentTable;
1000     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1001     DT_FIELD                *SubtableStart;
1002     ACPI_SUBTABLE_HEADER    *GtdtHeader;
1003     ACPI_DMTABLE_INFO       *InfoTable;
1004     UINT32                  GtCount;
1005     ACPI_TABLE_HEADER       *Header;
1006
1007
1008     ParentTable = DtPeekSubtable ();
1009
1010     Header = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer);
1011
1012     /* Compile the main table */
1013
1014     Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt,
1015         &Subtable);
1016     if (ACPI_FAILURE (Status))
1017     {
1018         return (Status);
1019     }
1020
1021     /* GTDT revision 3 later contains 2 extra fields before subtables */
1022
1023     if (Header->Revision > 2)
1024     {
1025         ParentTable = DtPeekSubtable ();
1026         DtInsertSubtable (ParentTable, Subtable);
1027
1028         Status = DtCompileTable (PFieldList,
1029             AcpiDmTableInfoGtdtEl2, &Subtable);
1030         if (ACPI_FAILURE (Status))
1031         {
1032             return (Status);
1033         }
1034     }
1035
1036     ParentTable = DtPeekSubtable ();
1037     DtInsertSubtable (ParentTable, Subtable);
1038
1039     while (*PFieldList)
1040     {
1041         SubtableStart = *PFieldList;
1042         Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdtHdr,
1043             &Subtable);
1044         if (ACPI_FAILURE (Status))
1045         {
1046             return (Status);
1047         }
1048
1049         ParentTable = DtPeekSubtable ();
1050         DtInsertSubtable (ParentTable, Subtable);
1051         DtPushSubtable (Subtable);
1052
1053         GtdtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1054
1055         switch (GtdtHeader->Type)
1056         {
1057         case ACPI_GTDT_TYPE_TIMER_BLOCK:
1058
1059             InfoTable = AcpiDmTableInfoGtdt0;
1060             break;
1061
1062         case ACPI_GTDT_TYPE_WATCHDOG:
1063
1064             InfoTable = AcpiDmTableInfoGtdt1;
1065             break;
1066
1067         default:
1068
1069             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "GTDT");
1070             return (AE_ERROR);
1071         }
1072
1073         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1074         if (ACPI_FAILURE (Status))
1075         {
1076             return (Status);
1077         }
1078
1079         ParentTable = DtPeekSubtable ();
1080         DtInsertSubtable (ParentTable, Subtable);
1081
1082         /*
1083          * Additional GT block subtable data
1084          */
1085
1086         switch (GtdtHeader->Type)
1087         {
1088         case ACPI_GTDT_TYPE_TIMER_BLOCK:
1089
1090             DtPushSubtable (Subtable);
1091             ParentTable = DtPeekSubtable ();
1092
1093             GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1094                 Subtable->Buffer - sizeof(ACPI_GTDT_HEADER)))->TimerCount;
1095
1096             while (GtCount)
1097             {
1098                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt0a,
1099                     &Subtable);
1100                 if (ACPI_FAILURE (Status))
1101                 {
1102                     return (Status);
1103                 }
1104
1105                 DtInsertSubtable (ParentTable, Subtable);
1106                 GtCount--;
1107             }
1108
1109             DtPopSubtable ();
1110             break;
1111
1112         default:
1113
1114             break;
1115         }
1116
1117         DtPopSubtable ();
1118     }
1119
1120     return (AE_OK);
1121 }
1122
1123
1124 /******************************************************************************
1125  *
1126  * FUNCTION:    DtCompileFpdt
1127  *
1128  * PARAMETERS:  List                - Current field list pointer
1129  *
1130  * RETURN:      Status
1131  *
1132  * DESCRIPTION: Compile FPDT.
1133  *
1134  *****************************************************************************/
1135
1136 ACPI_STATUS
1137 DtCompileFpdt (
1138     void                    **List)
1139 {
1140     ACPI_STATUS             Status;
1141     ACPI_FPDT_HEADER        *FpdtHeader;
1142     DT_SUBTABLE             *Subtable;
1143     DT_SUBTABLE             *ParentTable;
1144     ACPI_DMTABLE_INFO       *InfoTable;
1145     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1146     DT_FIELD                *SubtableStart;
1147
1148
1149     while (*PFieldList)
1150     {
1151         SubtableStart = *PFieldList;
1152         Status = DtCompileTable (PFieldList, AcpiDmTableInfoFpdtHdr,
1153             &Subtable);
1154         if (ACPI_FAILURE (Status))
1155         {
1156             return (Status);
1157         }
1158
1159         ParentTable = DtPeekSubtable ();
1160         DtInsertSubtable (ParentTable, Subtable);
1161         DtPushSubtable (Subtable);
1162
1163         FpdtHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
1164
1165         switch (FpdtHeader->Type)
1166         {
1167         case ACPI_FPDT_TYPE_BOOT:
1168
1169             InfoTable = AcpiDmTableInfoFpdt0;
1170             break;
1171
1172         case ACPI_FPDT_TYPE_S3PERF:
1173
1174             InfoTable = AcpiDmTableInfoFpdt1;
1175             break;
1176
1177         default:
1178
1179             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "FPDT");
1180             return (AE_ERROR);
1181             break;
1182         }
1183
1184         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1185         if (ACPI_FAILURE (Status))
1186         {
1187             return (Status);
1188         }
1189
1190         ParentTable = DtPeekSubtable ();
1191         DtInsertSubtable (ParentTable, Subtable);
1192         DtPopSubtable ();
1193     }
1194
1195     return (AE_OK);
1196 }
1197
1198
1199 /******************************************************************************
1200  *
1201  * FUNCTION:    DtCompileHest
1202  *
1203  * PARAMETERS:  List                - Current field list pointer
1204  *
1205  * RETURN:      Status
1206  *
1207  * DESCRIPTION: Compile HEST.
1208  *
1209  *****************************************************************************/
1210
1211 ACPI_STATUS
1212 DtCompileHest (
1213     void                    **List)
1214 {
1215     ACPI_STATUS             Status;
1216     DT_SUBTABLE             *Subtable;
1217     DT_SUBTABLE             *ParentTable;
1218     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1219     DT_FIELD                *SubtableStart;
1220     ACPI_DMTABLE_INFO       *InfoTable;
1221     UINT16                  Type;
1222     UINT32                  BankCount;
1223
1224
1225     Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest,
1226         &Subtable);
1227     if (ACPI_FAILURE (Status))
1228     {
1229         return (Status);
1230     }
1231
1232     ParentTable = DtPeekSubtable ();
1233     DtInsertSubtable (ParentTable, Subtable);
1234
1235     while (*PFieldList)
1236     {
1237         /* Get subtable type */
1238
1239         SubtableStart = *PFieldList;
1240         DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0);
1241
1242         switch (Type)
1243         {
1244         case ACPI_HEST_TYPE_IA32_CHECK:
1245
1246             InfoTable = AcpiDmTableInfoHest0;
1247             break;
1248
1249         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1250
1251             InfoTable = AcpiDmTableInfoHest1;
1252             break;
1253
1254         case ACPI_HEST_TYPE_IA32_NMI:
1255
1256             InfoTable = AcpiDmTableInfoHest2;
1257             break;
1258
1259         case ACPI_HEST_TYPE_AER_ROOT_PORT:
1260
1261             InfoTable = AcpiDmTableInfoHest6;
1262             break;
1263
1264         case ACPI_HEST_TYPE_AER_ENDPOINT:
1265
1266             InfoTable = AcpiDmTableInfoHest7;
1267             break;
1268
1269         case ACPI_HEST_TYPE_AER_BRIDGE:
1270
1271             InfoTable = AcpiDmTableInfoHest8;
1272             break;
1273
1274         case ACPI_HEST_TYPE_GENERIC_ERROR:
1275
1276             InfoTable = AcpiDmTableInfoHest9;
1277             break;
1278
1279         case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
1280
1281             InfoTable = AcpiDmTableInfoHest10;
1282             break;
1283
1284         case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1285
1286             InfoTable = AcpiDmTableInfoHest11;
1287             break;
1288
1289         default:
1290
1291             /* Cannot continue on unknown type */
1292
1293             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HEST");
1294             return (AE_ERROR);
1295         }
1296
1297         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1298         if (ACPI_FAILURE (Status))
1299         {
1300             return (Status);
1301         }
1302
1303         DtInsertSubtable (ParentTable, Subtable);
1304
1305         /*
1306          * Additional subtable data - IA32 Error Bank(s)
1307          */
1308         BankCount = 0;
1309         switch (Type)
1310         {
1311         case ACPI_HEST_TYPE_IA32_CHECK:
1312
1313             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1314                 Subtable->Buffer))->NumHardwareBanks;
1315             break;
1316
1317         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1318
1319             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1320                 Subtable->Buffer))->NumHardwareBanks;
1321             break;
1322
1323         case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1324
1325             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
1326                 Subtable->Buffer))->NumHardwareBanks;
1327             break;
1328
1329         default:
1330
1331             break;
1332         }
1333
1334         while (BankCount)
1335         {
1336             Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank,
1337                 &Subtable);
1338             if (ACPI_FAILURE (Status))
1339             {
1340                 return (Status);
1341             }
1342
1343             DtInsertSubtable (ParentTable, Subtable);
1344             BankCount--;
1345         }
1346     }
1347
1348     return (AE_OK);
1349 }
1350
1351
1352 /******************************************************************************
1353  *
1354  * FUNCTION:    DtCompileHmat
1355  *
1356  * PARAMETERS:  List                - Current field list pointer
1357  *
1358  * RETURN:      Status
1359  *
1360  * DESCRIPTION: Compile HMAT.
1361  *
1362  *****************************************************************************/
1363
1364 ACPI_STATUS
1365 DtCompileHmat (
1366     void                    **List)
1367 {
1368     ACPI_STATUS             Status;
1369     DT_SUBTABLE             *Subtable;
1370     DT_SUBTABLE             *ParentTable;
1371     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1372     DT_FIELD                *SubtableStart;
1373     DT_FIELD                *EntryStart;
1374     ACPI_HMAT_STRUCTURE     *HmatStruct;
1375     ACPI_HMAT_LOCALITY      *HmatLocality;
1376     ACPI_HMAT_CACHE         *HmatCache;
1377     ACPI_DMTABLE_INFO       *InfoTable;
1378     UINT32                  IntPDNumber;
1379     UINT32                  TgtPDNumber;
1380     UINT64                  EntryNumber;
1381     UINT16                  SMBIOSHandleNumber;
1382
1383
1384     ParentTable = DtPeekSubtable ();
1385
1386     Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmat,
1387         &Subtable);
1388     if (ACPI_FAILURE (Status))
1389     {
1390         return (Status);
1391     }
1392     DtInsertSubtable (ParentTable, Subtable);
1393
1394     while (*PFieldList)
1395     {
1396         /* Compile HMAT structure header */
1397
1398         SubtableStart = *PFieldList;
1399         Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmatHdr,
1400             &Subtable);
1401         if (ACPI_FAILURE (Status))
1402         {
1403             return (Status);
1404         }
1405         DtInsertSubtable (ParentTable, Subtable);
1406
1407         HmatStruct = ACPI_CAST_PTR (ACPI_HMAT_STRUCTURE, Subtable->Buffer);
1408         HmatStruct->Length = Subtable->Length;
1409
1410         /* Compile HMAT structure body */
1411
1412         switch (HmatStruct->Type)
1413         {
1414         case ACPI_HMAT_TYPE_ADDRESS_RANGE:
1415
1416             InfoTable = AcpiDmTableInfoHmat0;
1417             break;
1418
1419         case ACPI_HMAT_TYPE_LOCALITY:
1420
1421             InfoTable = AcpiDmTableInfoHmat1;
1422             break;
1423
1424         case ACPI_HMAT_TYPE_CACHE:
1425
1426             InfoTable = AcpiDmTableInfoHmat2;
1427             break;
1428
1429         default:
1430
1431             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HMAT");
1432             return (AE_ERROR);
1433         }
1434
1435         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1436         if (ACPI_FAILURE (Status))
1437         {
1438             return (Status);
1439         }
1440         DtInsertSubtable (ParentTable, Subtable);
1441         HmatStruct->Length += Subtable->Length;
1442
1443         /* Compile HMAT structure additionals */
1444
1445         switch (HmatStruct->Type)
1446         {
1447         case ACPI_HMAT_TYPE_LOCALITY:
1448
1449             HmatLocality = ACPI_SUB_PTR (ACPI_HMAT_LOCALITY,
1450                 Subtable->Buffer, sizeof (ACPI_HMAT_STRUCTURE));
1451
1452             /* Compile initiator proximity domain list */
1453
1454             IntPDNumber = 0;
1455             while (*PFieldList)
1456             {
1457                 Status = DtCompileTable (PFieldList,
1458                     AcpiDmTableInfoHmat1a, &Subtable);
1459                 if (ACPI_FAILURE (Status))
1460                 {
1461                     return (Status);
1462                 }
1463                 if (!Subtable)
1464                 {
1465                     break;
1466                 }
1467                 DtInsertSubtable (ParentTable, Subtable);
1468                 HmatStruct->Length += Subtable->Length;
1469                 IntPDNumber++;
1470             }
1471             HmatLocality->NumberOfInitiatorPDs = IntPDNumber;
1472
1473             /* Compile target proximity domain list */
1474
1475             TgtPDNumber = 0;
1476             while (*PFieldList)
1477             {
1478                 Status = DtCompileTable (PFieldList,
1479                     AcpiDmTableInfoHmat1b, &Subtable);
1480                 if (ACPI_FAILURE (Status))
1481                 {
1482                     return (Status);
1483                 }
1484                 if (!Subtable)
1485                 {
1486                     break;
1487                 }
1488                 DtInsertSubtable (ParentTable, Subtable);
1489                 HmatStruct->Length += Subtable->Length;
1490                 TgtPDNumber++;
1491             }
1492             HmatLocality->NumberOfTargetPDs = TgtPDNumber;
1493
1494             /* Save start of the entries for reporting errors */
1495
1496             EntryStart = *PFieldList;
1497
1498             /* Compile latency/bandwidth entries */
1499
1500             EntryNumber = 0;
1501             while (*PFieldList)
1502             {
1503                 Status = DtCompileTable (PFieldList,
1504                     AcpiDmTableInfoHmat1c, &Subtable);
1505                 if (ACPI_FAILURE (Status))
1506                 {
1507                     return (Status);
1508                 }
1509                 if (!Subtable)
1510                 {
1511                     break;
1512                 }
1513                 DtInsertSubtable (ParentTable, Subtable);
1514                 HmatStruct->Length += Subtable->Length;
1515                 EntryNumber++;
1516             }
1517
1518             /* Validate number of entries */
1519
1520             if (EntryNumber !=
1521                 ((UINT64)IntPDNumber * (UINT64)TgtPDNumber))
1522             {
1523                 DtFatal (ASL_MSG_INVALID_EXPRESSION, EntryStart, "HMAT");
1524                 return (AE_ERROR);
1525             }
1526             break;
1527
1528         case ACPI_HMAT_TYPE_CACHE:
1529
1530             /* Compile SMBIOS handles */
1531
1532             HmatCache = ACPI_SUB_PTR (ACPI_HMAT_CACHE,
1533                 Subtable->Buffer, sizeof (ACPI_HMAT_STRUCTURE));
1534             SMBIOSHandleNumber = 0;
1535             while (*PFieldList)
1536             {
1537                 Status = DtCompileTable (PFieldList,
1538                     AcpiDmTableInfoHmat2a, &Subtable);
1539                 if (ACPI_FAILURE (Status))
1540                 {
1541                     return (Status);
1542                 }
1543                 if (!Subtable)
1544                 {
1545                     break;
1546                 }
1547                 DtInsertSubtable (ParentTable, Subtable);
1548                 HmatStruct->Length += Subtable->Length;
1549                 SMBIOSHandleNumber++;
1550             }
1551             HmatCache->NumberOfSMBIOSHandles = SMBIOSHandleNumber;
1552             break;
1553
1554         default:
1555
1556             break;
1557         }
1558     }
1559
1560     return (AE_OK);
1561 }
1562
1563
1564 /******************************************************************************
1565  *
1566  * FUNCTION:    DtCompileIort
1567  *
1568  * PARAMETERS:  List                - Current field list pointer
1569  *
1570  * RETURN:      Status
1571  *
1572  * DESCRIPTION: Compile IORT.
1573  *
1574  *****************************************************************************/
1575
1576 ACPI_STATUS
1577 DtCompileIort (
1578     void                    **List)
1579 {
1580     ACPI_STATUS             Status;
1581     DT_SUBTABLE             *Subtable;
1582     DT_SUBTABLE             *ParentTable;
1583     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1584     DT_FIELD                *SubtableStart;
1585     ACPI_TABLE_IORT         *Iort;
1586     ACPI_IORT_NODE          *IortNode;
1587     ACPI_IORT_ITS_GROUP     *IortItsGroup;
1588     ACPI_IORT_SMMU          *IortSmmu;
1589     UINT32                  NodeNumber;
1590     UINT32                  NodeLength;
1591     UINT32                  IdMappingNumber;
1592     UINT32                  ItsNumber;
1593     UINT32                  ContextIrptNumber;
1594     UINT32                  PmuIrptNumber;
1595     UINT32                  PaddingLength;
1596
1597
1598     ParentTable = DtPeekSubtable ();
1599
1600     Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort,
1601         &Subtable);
1602     if (ACPI_FAILURE (Status))
1603     {
1604         return (Status);
1605     }
1606     DtInsertSubtable (ParentTable, Subtable);
1607
1608     /*
1609      * Using ACPI_SUB_PTR, We needn't define a separate structure. Care
1610      * should be taken to avoid accessing ACPI_TABLE_HEADER fields.
1611      */
1612     Iort = ACPI_SUB_PTR (ACPI_TABLE_IORT,
1613         Subtable->Buffer, sizeof (ACPI_TABLE_HEADER));
1614
1615     /*
1616      * OptionalPadding - Variable-length data
1617      * (Optional, size = OffsetToNodes - sizeof (ACPI_TABLE_IORT))
1618      * Optionally allows the generic data types to be used for filling
1619      * this field.
1620      */
1621     Iort->NodeOffset = sizeof (ACPI_TABLE_IORT);
1622     Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortPad,
1623         &Subtable);
1624     if (ACPI_FAILURE (Status))
1625     {
1626         return (Status);
1627     }
1628     if (Subtable)
1629     {
1630         DtInsertSubtable (ParentTable, Subtable);
1631         Iort->NodeOffset += Subtable->Length;
1632     }
1633     else
1634     {
1635         Status = DtCompileGeneric (ACPI_CAST_PTR (void *, PFieldList),
1636             AcpiDmTableInfoIortHdr[0].Name, &PaddingLength);
1637         if (ACPI_FAILURE (Status))
1638         {
1639             return (Status);
1640         }
1641         Iort->NodeOffset += PaddingLength;
1642     }
1643
1644     NodeNumber = 0;
1645     while (*PFieldList)
1646     {
1647         SubtableStart = *PFieldList;
1648         Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortHdr,
1649             &Subtable);
1650         if (ACPI_FAILURE (Status))
1651         {
1652             return (Status);
1653         }
1654
1655         DtInsertSubtable (ParentTable, Subtable);
1656         IortNode = ACPI_CAST_PTR (ACPI_IORT_NODE, Subtable->Buffer);
1657         NodeLength = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
1658
1659         DtPushSubtable (Subtable);
1660         ParentTable = DtPeekSubtable ();
1661
1662         switch (IortNode->Type)
1663         {
1664         case ACPI_IORT_NODE_ITS_GROUP:
1665
1666             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0,
1667                 &Subtable);
1668             if (ACPI_FAILURE (Status))
1669             {
1670                 return (Status);
1671             }
1672
1673             DtInsertSubtable (ParentTable, Subtable);
1674             IortItsGroup = ACPI_CAST_PTR (ACPI_IORT_ITS_GROUP, Subtable->Buffer);
1675             NodeLength += Subtable->Length;
1676
1677             ItsNumber = 0;
1678             while (*PFieldList)
1679             {
1680                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0a,
1681                     &Subtable);
1682                 if (ACPI_FAILURE (Status))
1683                 {
1684                     return (Status);
1685                 }
1686                 if (!Subtable)
1687                 {
1688                     break;
1689                 }
1690
1691                 DtInsertSubtable (ParentTable, Subtable);
1692                 NodeLength += Subtable->Length;
1693                 ItsNumber++;
1694             }
1695
1696             IortItsGroup->ItsCount = ItsNumber;
1697             break;
1698
1699         case ACPI_IORT_NODE_NAMED_COMPONENT:
1700
1701             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1,
1702                 &Subtable);
1703             if (ACPI_FAILURE (Status))
1704             {
1705                 return (Status);
1706             }
1707
1708             DtInsertSubtable (ParentTable, Subtable);
1709             NodeLength += Subtable->Length;
1710
1711             /*
1712              * Padding - Variable-length data
1713              * Optionally allows the offset of the ID mappings to be used
1714              * for filling this field.
1715              */
1716             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1a,
1717                 &Subtable);
1718             if (ACPI_FAILURE (Status))
1719             {
1720                 return (Status);
1721             }
1722
1723             if (Subtable)
1724             {
1725                 DtInsertSubtable (ParentTable, Subtable);
1726                 NodeLength += Subtable->Length;
1727             }
1728             else
1729             {
1730                 if (NodeLength > IortNode->MappingOffset)
1731                 {
1732                     return (AE_BAD_DATA);
1733                 }
1734
1735                 if (NodeLength < IortNode->MappingOffset)
1736                 {
1737                     Status = DtCompilePadding (
1738                         IortNode->MappingOffset - NodeLength,
1739                         &Subtable);
1740                     if (ACPI_FAILURE (Status))
1741                     {
1742                         return (Status);
1743                     }
1744
1745                     DtInsertSubtable (ParentTable, Subtable);
1746                     NodeLength = IortNode->MappingOffset;
1747                 }
1748             }
1749             break;
1750
1751         case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
1752
1753             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort2,
1754                 &Subtable);
1755             if (ACPI_FAILURE (Status))
1756             {
1757                 return (Status);
1758             }
1759
1760             DtInsertSubtable (ParentTable, Subtable);
1761             NodeLength += Subtable->Length;
1762             break;
1763
1764         case ACPI_IORT_NODE_SMMU:
1765
1766             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3,
1767                 &Subtable);
1768             if (ACPI_FAILURE (Status))
1769             {
1770                 return (Status);
1771             }
1772
1773             DtInsertSubtable (ParentTable, Subtable);
1774             IortSmmu = ACPI_CAST_PTR (ACPI_IORT_SMMU, Subtable->Buffer);
1775             NodeLength += Subtable->Length;
1776
1777             /* Compile global interrupt array */
1778
1779             IortSmmu->GlobalInterruptOffset = NodeLength;
1780             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3a,
1781                 &Subtable);
1782             if (ACPI_FAILURE (Status))
1783             {
1784                 return (Status);
1785             }
1786
1787             DtInsertSubtable (ParentTable, Subtable);
1788             NodeLength += Subtable->Length;
1789
1790             /* Compile context interrupt array */
1791
1792             ContextIrptNumber = 0;
1793             IortSmmu->ContextInterruptOffset = NodeLength;
1794             while (*PFieldList)
1795             {
1796                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3b,
1797                     &Subtable);
1798                 if (ACPI_FAILURE (Status))
1799                 {
1800                     return (Status);
1801                 }
1802
1803                 if (!Subtable)
1804                 {
1805                     break;
1806                 }
1807
1808                 DtInsertSubtable (ParentTable, Subtable);
1809                 NodeLength += Subtable->Length;
1810                 ContextIrptNumber++;
1811             }
1812
1813             IortSmmu->ContextInterruptCount = ContextIrptNumber;
1814
1815             /* Compile PMU interrupt array */
1816
1817             PmuIrptNumber = 0;
1818             IortSmmu->PmuInterruptOffset = NodeLength;
1819             while (*PFieldList)
1820             {
1821                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3c,
1822                     &Subtable);
1823                 if (ACPI_FAILURE (Status))
1824                 {
1825                     return (Status);
1826                 }
1827
1828                 if (!Subtable)
1829                 {
1830                     break;
1831                 }
1832
1833                 DtInsertSubtable (ParentTable, Subtable);
1834                 NodeLength += Subtable->Length;
1835                 PmuIrptNumber++;
1836             }
1837
1838             IortSmmu->PmuInterruptCount = PmuIrptNumber;
1839             break;
1840
1841         case ACPI_IORT_NODE_SMMU_V3:
1842
1843             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort4,
1844                 &Subtable);
1845             if (ACPI_FAILURE (Status))
1846             {
1847                 return (Status);
1848             }
1849
1850             DtInsertSubtable (ParentTable, Subtable);
1851             NodeLength += Subtable->Length;
1852             break;
1853
1854         case ACPI_IORT_NODE_PMCG:
1855
1856             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort5,
1857                 &Subtable);
1858             if (ACPI_FAILURE (Status))
1859             {
1860                 return (Status);
1861             }
1862
1863             DtInsertSubtable (ParentTable, Subtable);
1864             NodeLength += Subtable->Length;
1865             break;
1866
1867         default:
1868
1869             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IORT");
1870             return (AE_ERROR);
1871         }
1872
1873         /* Compile Array of ID mappings */
1874
1875         IortNode->MappingOffset = NodeLength;
1876         IdMappingNumber = 0;
1877         while (*PFieldList)
1878         {
1879             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortMap,
1880                 &Subtable);
1881             if (ACPI_FAILURE (Status))
1882             {
1883                 return (Status);
1884             }
1885
1886             if (!Subtable)
1887             {
1888                 break;
1889             }
1890
1891             DtInsertSubtable (ParentTable, Subtable);
1892             NodeLength += sizeof (ACPI_IORT_ID_MAPPING);
1893             IdMappingNumber++;
1894         }
1895
1896         IortNode->MappingCount = IdMappingNumber;
1897         if (!IdMappingNumber)
1898         {
1899             IortNode->MappingOffset = 0;
1900         }
1901
1902         /*
1903          * Node length can be determined by DT_LENGTH option
1904          * IortNode->Length = NodeLength;
1905          */
1906         DtPopSubtable ();
1907         ParentTable = DtPeekSubtable ();
1908         NodeNumber++;
1909     }
1910
1911     Iort->NodeCount = NodeNumber;
1912     return (AE_OK);
1913 }
1914
1915
1916 /******************************************************************************
1917  *
1918  * FUNCTION:    DtCompileIvrs
1919  *
1920  * PARAMETERS:  List                - Current field list pointer
1921  *
1922  * RETURN:      Status
1923  *
1924  * DESCRIPTION: Compile IVRS.
1925  *
1926  *****************************************************************************/
1927
1928 ACPI_STATUS
1929 DtCompileIvrs (
1930     void                    **List)
1931 {
1932     ACPI_STATUS             Status;
1933     DT_SUBTABLE             *Subtable;
1934     DT_SUBTABLE             *ParentTable;
1935     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1936     DT_FIELD                *SubtableStart;
1937     ACPI_DMTABLE_INFO       *InfoTable;
1938     ACPI_IVRS_HEADER        *IvrsHeader;
1939     UINT8                   EntryType;
1940
1941
1942     Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs,
1943         &Subtable);
1944     if (ACPI_FAILURE (Status))
1945     {
1946         return (Status);
1947     }
1948
1949     ParentTable = DtPeekSubtable ();
1950     DtInsertSubtable (ParentTable, Subtable);
1951
1952     while (*PFieldList)
1953     {
1954         SubtableStart = *PFieldList;
1955         Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHdr,
1956             &Subtable);
1957         if (ACPI_FAILURE (Status))
1958         {
1959             return (Status);
1960         }
1961
1962         ParentTable = DtPeekSubtable ();
1963         DtInsertSubtable (ParentTable, Subtable);
1964         DtPushSubtable (Subtable);
1965
1966         IvrsHeader = ACPI_CAST_PTR (ACPI_IVRS_HEADER, Subtable->Buffer);
1967
1968         switch (IvrsHeader->Type)
1969         {
1970         case ACPI_IVRS_TYPE_HARDWARE1:
1971
1972             InfoTable = AcpiDmTableInfoIvrs0;
1973             break;
1974
1975         case ACPI_IVRS_TYPE_HARDWARE2:
1976
1977             InfoTable = AcpiDmTableInfoIvrs01;
1978             break;
1979
1980         case ACPI_IVRS_TYPE_MEMORY1:
1981         case ACPI_IVRS_TYPE_MEMORY2:
1982         case ACPI_IVRS_TYPE_MEMORY3:
1983
1984             InfoTable = AcpiDmTableInfoIvrs1;
1985             break;
1986
1987         default:
1988
1989             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IVRS");
1990             return (AE_ERROR);
1991         }
1992
1993         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1994         if (ACPI_FAILURE (Status))
1995         {
1996             return (Status);
1997         }
1998
1999         ParentTable = DtPeekSubtable ();
2000         DtInsertSubtable (ParentTable, Subtable);
2001
2002         if (IvrsHeader->Type == ACPI_IVRS_TYPE_HARDWARE1 ||
2003             IvrsHeader->Type == ACPI_IVRS_TYPE_HARDWARE2)
2004         {
2005             while (*PFieldList &&
2006                 !strcmp ((*PFieldList)->Name, "Entry Type"))
2007             {
2008                 SubtableStart = *PFieldList;
2009                 DtCompileInteger (&EntryType, *PFieldList, 1, 0);
2010
2011                 switch (EntryType)
2012                 {
2013                 /* 4-byte device entries */
2014
2015                 case ACPI_IVRS_TYPE_PAD4:
2016                 case ACPI_IVRS_TYPE_ALL:
2017                 case ACPI_IVRS_TYPE_SELECT:
2018                 case ACPI_IVRS_TYPE_START:
2019                 case ACPI_IVRS_TYPE_END:
2020
2021                     InfoTable = AcpiDmTableInfoIvrs4;
2022                     break;
2023
2024                 /* 8-byte entries, type A */
2025
2026                 case ACPI_IVRS_TYPE_ALIAS_SELECT:
2027                 case ACPI_IVRS_TYPE_ALIAS_START:
2028
2029                     InfoTable = AcpiDmTableInfoIvrs8a;
2030                     break;
2031
2032                 /* 8-byte entries, type B */
2033
2034                 case ACPI_IVRS_TYPE_PAD8:
2035                 case ACPI_IVRS_TYPE_EXT_SELECT:
2036                 case ACPI_IVRS_TYPE_EXT_START:
2037
2038                     InfoTable = AcpiDmTableInfoIvrs8b;
2039                     break;
2040
2041                 /* 8-byte entries, type C */
2042
2043                 case ACPI_IVRS_TYPE_SPECIAL:
2044
2045                     InfoTable = AcpiDmTableInfoIvrs8c;
2046                     break;
2047
2048                 default:
2049
2050                     DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart,
2051                         "IVRS Device Entry");
2052                     return (AE_ERROR);
2053                 }
2054
2055                 Status = DtCompileTable (PFieldList, InfoTable,
2056                     &Subtable);
2057                 if (ACPI_FAILURE (Status))
2058                 {
2059                     return (Status);
2060                 }
2061
2062                 DtInsertSubtable (ParentTable, Subtable);
2063             }
2064         }
2065
2066         DtPopSubtable ();
2067     }
2068
2069     return (AE_OK);
2070 }