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 - 2018, 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 seperate 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
1006
1007     Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt,
1008         &Subtable);
1009     if (ACPI_FAILURE (Status))
1010     {
1011         return (Status);
1012     }
1013
1014     ParentTable = DtPeekSubtable ();
1015     DtInsertSubtable (ParentTable, Subtable);
1016
1017     while (*PFieldList)
1018     {
1019         SubtableStart = *PFieldList;
1020         Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdtHdr,
1021             &Subtable);
1022         if (ACPI_FAILURE (Status))
1023         {
1024             return (Status);
1025         }
1026
1027         ParentTable = DtPeekSubtable ();
1028         DtInsertSubtable (ParentTable, Subtable);
1029         DtPushSubtable (Subtable);
1030
1031         GtdtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1032
1033         switch (GtdtHeader->Type)
1034         {
1035         case ACPI_GTDT_TYPE_TIMER_BLOCK:
1036
1037             InfoTable = AcpiDmTableInfoGtdt0;
1038             break;
1039
1040         case ACPI_GTDT_TYPE_WATCHDOG:
1041
1042             InfoTable = AcpiDmTableInfoGtdt1;
1043             break;
1044
1045         default:
1046
1047             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "GTDT");
1048             return (AE_ERROR);
1049         }
1050
1051         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1052         if (ACPI_FAILURE (Status))
1053         {
1054             return (Status);
1055         }
1056
1057         ParentTable = DtPeekSubtable ();
1058         DtInsertSubtable (ParentTable, Subtable);
1059
1060         /*
1061          * Additional GT block subtable data
1062          */
1063
1064         switch (GtdtHeader->Type)
1065         {
1066         case ACPI_GTDT_TYPE_TIMER_BLOCK:
1067
1068             DtPushSubtable (Subtable);
1069             ParentTable = DtPeekSubtable ();
1070
1071             GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1072                 Subtable->Buffer - sizeof(ACPI_GTDT_HEADER)))->TimerCount;
1073
1074             while (GtCount)
1075             {
1076                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt0a,
1077                     &Subtable);
1078                 if (ACPI_FAILURE (Status))
1079                 {
1080                     return (Status);
1081                 }
1082
1083                 DtInsertSubtable (ParentTable, Subtable);
1084                 GtCount--;
1085             }
1086
1087             DtPopSubtable ();
1088             break;
1089
1090         default:
1091
1092             break;
1093         }
1094
1095         DtPopSubtable ();
1096     }
1097
1098     return (AE_OK);
1099 }
1100
1101
1102 /******************************************************************************
1103  *
1104  * FUNCTION:    DtCompileFpdt
1105  *
1106  * PARAMETERS:  List                - Current field list pointer
1107  *
1108  * RETURN:      Status
1109  *
1110  * DESCRIPTION: Compile FPDT.
1111  *
1112  *****************************************************************************/
1113
1114 ACPI_STATUS
1115 DtCompileFpdt (
1116     void                    **List)
1117 {
1118     ACPI_STATUS             Status;
1119     ACPI_FPDT_HEADER        *FpdtHeader;
1120     DT_SUBTABLE             *Subtable;
1121     DT_SUBTABLE             *ParentTable;
1122     ACPI_DMTABLE_INFO       *InfoTable;
1123     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1124     DT_FIELD                *SubtableStart;
1125
1126
1127     while (*PFieldList)
1128     {
1129         SubtableStart = *PFieldList;
1130         Status = DtCompileTable (PFieldList, AcpiDmTableInfoFpdtHdr,
1131             &Subtable);
1132         if (ACPI_FAILURE (Status))
1133         {
1134             return (Status);
1135         }
1136
1137         ParentTable = DtPeekSubtable ();
1138         DtInsertSubtable (ParentTable, Subtable);
1139         DtPushSubtable (Subtable);
1140
1141         FpdtHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
1142
1143         switch (FpdtHeader->Type)
1144         {
1145         case ACPI_FPDT_TYPE_BOOT:
1146
1147             InfoTable = AcpiDmTableInfoFpdt0;
1148             break;
1149
1150         case ACPI_FPDT_TYPE_S3PERF:
1151
1152             InfoTable = AcpiDmTableInfoFpdt1;
1153             break;
1154
1155         default:
1156
1157             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "FPDT");
1158             return (AE_ERROR);
1159             break;
1160         }
1161
1162         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1163         if (ACPI_FAILURE (Status))
1164         {
1165             return (Status);
1166         }
1167
1168         ParentTable = DtPeekSubtable ();
1169         DtInsertSubtable (ParentTable, Subtable);
1170         DtPopSubtable ();
1171     }
1172
1173     return (AE_OK);
1174 }
1175
1176
1177 /******************************************************************************
1178  *
1179  * FUNCTION:    DtCompileHest
1180  *
1181  * PARAMETERS:  List                - Current field list pointer
1182  *
1183  * RETURN:      Status
1184  *
1185  * DESCRIPTION: Compile HEST.
1186  *
1187  *****************************************************************************/
1188
1189 ACPI_STATUS
1190 DtCompileHest (
1191     void                    **List)
1192 {
1193     ACPI_STATUS             Status;
1194     DT_SUBTABLE             *Subtable;
1195     DT_SUBTABLE             *ParentTable;
1196     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1197     DT_FIELD                *SubtableStart;
1198     ACPI_DMTABLE_INFO       *InfoTable;
1199     UINT16                  Type;
1200     UINT32                  BankCount;
1201
1202
1203     Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest,
1204         &Subtable);
1205     if (ACPI_FAILURE (Status))
1206     {
1207         return (Status);
1208     }
1209
1210     ParentTable = DtPeekSubtable ();
1211     DtInsertSubtable (ParentTable, Subtable);
1212
1213     while (*PFieldList)
1214     {
1215         /* Get subtable type */
1216
1217         SubtableStart = *PFieldList;
1218         DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0);
1219
1220         switch (Type)
1221         {
1222         case ACPI_HEST_TYPE_IA32_CHECK:
1223
1224             InfoTable = AcpiDmTableInfoHest0;
1225             break;
1226
1227         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1228
1229             InfoTable = AcpiDmTableInfoHest1;
1230             break;
1231
1232         case ACPI_HEST_TYPE_IA32_NMI:
1233
1234             InfoTable = AcpiDmTableInfoHest2;
1235             break;
1236
1237         case ACPI_HEST_TYPE_AER_ROOT_PORT:
1238
1239             InfoTable = AcpiDmTableInfoHest6;
1240             break;
1241
1242         case ACPI_HEST_TYPE_AER_ENDPOINT:
1243
1244             InfoTable = AcpiDmTableInfoHest7;
1245             break;
1246
1247         case ACPI_HEST_TYPE_AER_BRIDGE:
1248
1249             InfoTable = AcpiDmTableInfoHest8;
1250             break;
1251
1252         case ACPI_HEST_TYPE_GENERIC_ERROR:
1253
1254             InfoTable = AcpiDmTableInfoHest9;
1255             break;
1256
1257         case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
1258
1259             InfoTable = AcpiDmTableInfoHest10;
1260             break;
1261
1262         case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1263
1264             InfoTable = AcpiDmTableInfoHest11;
1265             break;
1266
1267         default:
1268
1269             /* Cannot continue on unknown type */
1270
1271             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HEST");
1272             return (AE_ERROR);
1273         }
1274
1275         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1276         if (ACPI_FAILURE (Status))
1277         {
1278             return (Status);
1279         }
1280
1281         DtInsertSubtable (ParentTable, Subtable);
1282
1283         /*
1284          * Additional subtable data - IA32 Error Bank(s)
1285          */
1286         BankCount = 0;
1287         switch (Type)
1288         {
1289         case ACPI_HEST_TYPE_IA32_CHECK:
1290
1291             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1292                 Subtable->Buffer))->NumHardwareBanks;
1293             break;
1294
1295         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1296
1297             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1298                 Subtable->Buffer))->NumHardwareBanks;
1299             break;
1300
1301         case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1302
1303             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
1304                 Subtable->Buffer))->NumHardwareBanks;
1305             break;
1306
1307         default:
1308
1309             break;
1310         }
1311
1312         while (BankCount)
1313         {
1314             Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank,
1315                 &Subtable);
1316             if (ACPI_FAILURE (Status))
1317             {
1318                 return (Status);
1319             }
1320
1321             DtInsertSubtable (ParentTable, Subtable);
1322             BankCount--;
1323         }
1324     }
1325
1326     return (AE_OK);
1327 }
1328
1329
1330 /******************************************************************************
1331  *
1332  * FUNCTION:    DtCompileHmat
1333  *
1334  * PARAMETERS:  List                - Current field list pointer
1335  *
1336  * RETURN:      Status
1337  *
1338  * DESCRIPTION: Compile HMAT.
1339  *
1340  *****************************************************************************/
1341
1342 ACPI_STATUS
1343 DtCompileHmat (
1344     void                    **List)
1345 {
1346     ACPI_STATUS             Status;
1347     DT_SUBTABLE             *Subtable;
1348     DT_SUBTABLE             *ParentTable;
1349     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1350     DT_FIELD                *SubtableStart;
1351     DT_FIELD                *EntryStart;
1352     ACPI_HMAT_STRUCTURE     *HmatStruct;
1353     ACPI_HMAT_LOCALITY      *HmatLocality;
1354     ACPI_HMAT_CACHE         *HmatCache;
1355     ACPI_DMTABLE_INFO       *InfoTable;
1356     UINT32                  IntPDNumber;
1357     UINT32                  TgtPDNumber;
1358     UINT64                  EntryNumber;
1359     UINT16                  SMBIOSHandleNumber;
1360
1361
1362     ParentTable = DtPeekSubtable ();
1363
1364     Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmat,
1365         &Subtable);
1366     if (ACPI_FAILURE (Status))
1367     {
1368         return (Status);
1369     }
1370     DtInsertSubtable (ParentTable, Subtable);
1371
1372     while (*PFieldList)
1373     {
1374         /* Compile HMAT structure header */
1375
1376         SubtableStart = *PFieldList;
1377         Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmatHdr,
1378             &Subtable);
1379         if (ACPI_FAILURE (Status))
1380         {
1381             return (Status);
1382         }
1383         DtInsertSubtable (ParentTable, Subtable);
1384
1385         HmatStruct = ACPI_CAST_PTR (ACPI_HMAT_STRUCTURE, Subtable->Buffer);
1386         HmatStruct->Length = Subtable->Length;
1387
1388         /* Compile HMAT structure body */
1389
1390         switch (HmatStruct->Type)
1391         {
1392         case ACPI_HMAT_TYPE_ADDRESS_RANGE:
1393
1394             InfoTable = AcpiDmTableInfoHmat0;
1395             break;
1396
1397         case ACPI_HMAT_TYPE_LOCALITY:
1398
1399             InfoTable = AcpiDmTableInfoHmat1;
1400             break;
1401
1402         case ACPI_HMAT_TYPE_CACHE:
1403
1404             InfoTable = AcpiDmTableInfoHmat2;
1405             break;
1406
1407         default:
1408
1409             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HMAT");
1410             return (AE_ERROR);
1411         }
1412
1413         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1414         if (ACPI_FAILURE (Status))
1415         {
1416             return (Status);
1417         }
1418         DtInsertSubtable (ParentTable, Subtable);
1419         HmatStruct->Length += Subtable->Length;
1420
1421         /* Compile HMAT structure additionals */
1422
1423         switch (HmatStruct->Type)
1424         {
1425         case ACPI_HMAT_TYPE_LOCALITY:
1426
1427             HmatLocality = ACPI_SUB_PTR (ACPI_HMAT_LOCALITY,
1428                 Subtable->Buffer, sizeof (ACPI_HMAT_STRUCTURE));
1429
1430             /* Compile initiator proximity domain list */
1431
1432             IntPDNumber = 0;
1433             while (*PFieldList)
1434             {
1435                 Status = DtCompileTable (PFieldList,
1436                     AcpiDmTableInfoHmat1a, &Subtable);
1437                 if (ACPI_FAILURE (Status))
1438                 {
1439                     return (Status);
1440                 }
1441                 if (!Subtable)
1442                 {
1443                     break;
1444                 }
1445                 DtInsertSubtable (ParentTable, Subtable);
1446                 HmatStruct->Length += Subtable->Length;
1447                 IntPDNumber++;
1448             }
1449             HmatLocality->NumberOfInitiatorPDs = IntPDNumber;
1450
1451             /* Compile target proximity domain list */
1452
1453             TgtPDNumber = 0;
1454             while (*PFieldList)
1455             {
1456                 Status = DtCompileTable (PFieldList,
1457                     AcpiDmTableInfoHmat1b, &Subtable);
1458                 if (ACPI_FAILURE (Status))
1459                 {
1460                     return (Status);
1461                 }
1462                 if (!Subtable)
1463                 {
1464                     break;
1465                 }
1466                 DtInsertSubtable (ParentTable, Subtable);
1467                 HmatStruct->Length += Subtable->Length;
1468                 TgtPDNumber++;
1469             }
1470             HmatLocality->NumberOfTargetPDs = TgtPDNumber;
1471
1472             /* Save start of the entries for reporting errors */
1473
1474             EntryStart = *PFieldList;
1475
1476             /* Compile latency/bandwidth entries */
1477
1478             EntryNumber = 0;
1479             while (*PFieldList)
1480             {
1481                 Status = DtCompileTable (PFieldList,
1482                     AcpiDmTableInfoHmat1c, &Subtable);
1483                 if (ACPI_FAILURE (Status))
1484                 {
1485                     return (Status);
1486                 }
1487                 if (!Subtable)
1488                 {
1489                     break;
1490                 }
1491                 DtInsertSubtable (ParentTable, Subtable);
1492                 HmatStruct->Length += Subtable->Length;
1493                 EntryNumber++;
1494             }
1495
1496             /* Validate number of entries */
1497
1498             if (EntryNumber !=
1499                 ((UINT64)IntPDNumber * (UINT64)TgtPDNumber))
1500             {
1501                 DtFatal (ASL_MSG_INVALID_EXPRESSION, EntryStart, "HMAT");
1502                 return (AE_ERROR);
1503             }
1504             break;
1505
1506         case ACPI_HMAT_TYPE_CACHE:
1507
1508             /* Compile SMBIOS handles */
1509
1510             HmatCache = ACPI_SUB_PTR (ACPI_HMAT_CACHE,
1511                 Subtable->Buffer, sizeof (ACPI_HMAT_STRUCTURE));
1512             SMBIOSHandleNumber = 0;
1513             while (*PFieldList)
1514             {
1515                 Status = DtCompileTable (PFieldList,
1516                     AcpiDmTableInfoHmat2a, &Subtable);
1517                 if (ACPI_FAILURE (Status))
1518                 {
1519                     return (Status);
1520                 }
1521                 if (!Subtable)
1522                 {
1523                     break;
1524                 }
1525                 DtInsertSubtable (ParentTable, Subtable);
1526                 HmatStruct->Length += Subtable->Length;
1527                 SMBIOSHandleNumber++;
1528             }
1529             HmatCache->NumberOfSMBIOSHandles = SMBIOSHandleNumber;
1530             break;
1531
1532         default:
1533
1534             break;
1535         }
1536     }
1537
1538     return (AE_OK);
1539 }
1540
1541
1542 /******************************************************************************
1543  *
1544  * FUNCTION:    DtCompileIort
1545  *
1546  * PARAMETERS:  List                - Current field list pointer
1547  *
1548  * RETURN:      Status
1549  *
1550  * DESCRIPTION: Compile IORT.
1551  *
1552  *****************************************************************************/
1553
1554 ACPI_STATUS
1555 DtCompileIort (
1556     void                    **List)
1557 {
1558     ACPI_STATUS             Status;
1559     DT_SUBTABLE             *Subtable;
1560     DT_SUBTABLE             *ParentTable;
1561     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1562     DT_FIELD                *SubtableStart;
1563     ACPI_TABLE_IORT         *Iort;
1564     ACPI_IORT_NODE          *IortNode;
1565     ACPI_IORT_ITS_GROUP     *IortItsGroup;
1566     ACPI_IORT_SMMU          *IortSmmu;
1567     UINT32                  NodeNumber;
1568     UINT32                  NodeLength;
1569     UINT32                  IdMappingNumber;
1570     UINT32                  ItsNumber;
1571     UINT32                  ContextIrptNumber;
1572     UINT32                  PmuIrptNumber;
1573     UINT32                  PaddingLength;
1574
1575
1576     ParentTable = DtPeekSubtable ();
1577
1578     Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort,
1579         &Subtable);
1580     if (ACPI_FAILURE (Status))
1581     {
1582         return (Status);
1583     }
1584     DtInsertSubtable (ParentTable, Subtable);
1585
1586     /*
1587      * Using ACPI_SUB_PTR, We needn't define a separate structure. Care
1588      * should be taken to avoid accessing ACPI_TABLE_HEADER fields.
1589      */
1590     Iort = ACPI_SUB_PTR (ACPI_TABLE_IORT,
1591         Subtable->Buffer, sizeof (ACPI_TABLE_HEADER));
1592
1593     /*
1594      * OptionalPadding - Variable-length data
1595      * (Optional, size = OffsetToNodes - sizeof (ACPI_TABLE_IORT))
1596      * Optionally allows the generic data types to be used for filling
1597      * this field.
1598      */
1599     Iort->NodeOffset = sizeof (ACPI_TABLE_IORT);
1600     Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortPad,
1601         &Subtable);
1602     if (ACPI_FAILURE (Status))
1603     {
1604         return (Status);
1605     }
1606     if (Subtable)
1607     {
1608         DtInsertSubtable (ParentTable, Subtable);
1609         Iort->NodeOffset += Subtable->Length;
1610     }
1611     else
1612     {
1613         Status = DtCompileGeneric (ACPI_CAST_PTR (void *, PFieldList),
1614             AcpiDmTableInfoIortHdr[0].Name, &PaddingLength);
1615         if (ACPI_FAILURE (Status))
1616         {
1617             return (Status);
1618         }
1619         Iort->NodeOffset += PaddingLength;
1620     }
1621
1622     NodeNumber = 0;
1623     while (*PFieldList)
1624     {
1625         SubtableStart = *PFieldList;
1626         Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortHdr,
1627             &Subtable);
1628         if (ACPI_FAILURE (Status))
1629         {
1630             return (Status);
1631         }
1632
1633         DtInsertSubtable (ParentTable, Subtable);
1634         IortNode = ACPI_CAST_PTR (ACPI_IORT_NODE, Subtable->Buffer);
1635         NodeLength = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
1636
1637         DtPushSubtable (Subtable);
1638         ParentTable = DtPeekSubtable ();
1639
1640         switch (IortNode->Type)
1641         {
1642         case ACPI_IORT_NODE_ITS_GROUP:
1643
1644             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0,
1645                 &Subtable);
1646             if (ACPI_FAILURE (Status))
1647             {
1648                 return (Status);
1649             }
1650
1651             DtInsertSubtable (ParentTable, Subtable);
1652             IortItsGroup = ACPI_CAST_PTR (ACPI_IORT_ITS_GROUP, Subtable->Buffer);
1653             NodeLength += Subtable->Length;
1654
1655             ItsNumber = 0;
1656             while (*PFieldList)
1657             {
1658                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0a,
1659                     &Subtable);
1660                 if (ACPI_FAILURE (Status))
1661                 {
1662                     return (Status);
1663                 }
1664                 if (!Subtable)
1665                 {
1666                     break;
1667                 }
1668
1669                 DtInsertSubtable (ParentTable, Subtable);
1670                 NodeLength += Subtable->Length;
1671                 ItsNumber++;
1672             }
1673
1674             IortItsGroup->ItsCount = ItsNumber;
1675             break;
1676
1677         case ACPI_IORT_NODE_NAMED_COMPONENT:
1678
1679             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1,
1680                 &Subtable);
1681             if (ACPI_FAILURE (Status))
1682             {
1683                 return (Status);
1684             }
1685
1686             DtInsertSubtable (ParentTable, Subtable);
1687             NodeLength += Subtable->Length;
1688
1689             /*
1690              * Padding - Variable-length data
1691              * Optionally allows the offset of the ID mappings to be used
1692              * for filling this field.
1693              */
1694             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1a,
1695                 &Subtable);
1696             if (ACPI_FAILURE (Status))
1697             {
1698                 return (Status);
1699             }
1700
1701             if (Subtable)
1702             {
1703                 DtInsertSubtable (ParentTable, Subtable);
1704                 NodeLength += Subtable->Length;
1705             }
1706             else
1707             {
1708                 if (NodeLength > IortNode->MappingOffset)
1709                 {
1710                     return (AE_BAD_DATA);
1711                 }
1712
1713                 if (NodeLength < IortNode->MappingOffset)
1714                 {
1715                     Status = DtCompilePadding (
1716                         IortNode->MappingOffset - NodeLength,
1717                         &Subtable);
1718                     if (ACPI_FAILURE (Status))
1719                     {
1720                         return (Status);
1721                     }
1722
1723                     DtInsertSubtable (ParentTable, Subtable);
1724                     NodeLength = IortNode->MappingOffset;
1725                 }
1726             }
1727             break;
1728
1729         case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
1730
1731             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort2,
1732                 &Subtable);
1733             if (ACPI_FAILURE (Status))
1734             {
1735                 return (Status);
1736             }
1737
1738             DtInsertSubtable (ParentTable, Subtable);
1739             NodeLength += Subtable->Length;
1740             break;
1741
1742         case ACPI_IORT_NODE_SMMU:
1743
1744             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3,
1745                 &Subtable);
1746             if (ACPI_FAILURE (Status))
1747             {
1748                 return (Status);
1749             }
1750
1751             DtInsertSubtable (ParentTable, Subtable);
1752             IortSmmu = ACPI_CAST_PTR (ACPI_IORT_SMMU, Subtable->Buffer);
1753             NodeLength += Subtable->Length;
1754
1755             /* Compile global interrupt array */
1756
1757             IortSmmu->GlobalInterruptOffset = NodeLength;
1758             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3a,
1759                 &Subtable);
1760             if (ACPI_FAILURE (Status))
1761             {
1762                 return (Status);
1763             }
1764
1765             DtInsertSubtable (ParentTable, Subtable);
1766             NodeLength += Subtable->Length;
1767
1768             /* Compile context interrupt array */
1769
1770             ContextIrptNumber = 0;
1771             IortSmmu->ContextInterruptOffset = NodeLength;
1772             while (*PFieldList)
1773             {
1774                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3b,
1775                     &Subtable);
1776                 if (ACPI_FAILURE (Status))
1777                 {
1778                     return (Status);
1779                 }
1780
1781                 if (!Subtable)
1782                 {
1783                     break;
1784                 }
1785
1786                 DtInsertSubtable (ParentTable, Subtable);
1787                 NodeLength += Subtable->Length;
1788                 ContextIrptNumber++;
1789             }
1790
1791             IortSmmu->ContextInterruptCount = ContextIrptNumber;
1792
1793             /* Compile PMU interrupt array */
1794
1795             PmuIrptNumber = 0;
1796             IortSmmu->PmuInterruptOffset = NodeLength;
1797             while (*PFieldList)
1798             {
1799                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3c,
1800                     &Subtable);
1801                 if (ACPI_FAILURE (Status))
1802                 {
1803                     return (Status);
1804                 }
1805
1806                 if (!Subtable)
1807                 {
1808                     break;
1809                 }
1810
1811                 DtInsertSubtable (ParentTable, Subtable);
1812                 NodeLength += Subtable->Length;
1813                 PmuIrptNumber++;
1814             }
1815
1816             IortSmmu->PmuInterruptCount = PmuIrptNumber;
1817             break;
1818
1819         case ACPI_IORT_NODE_SMMU_V3:
1820
1821             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort4,
1822                 &Subtable);
1823             if (ACPI_FAILURE (Status))
1824             {
1825                 return (Status);
1826             }
1827
1828             DtInsertSubtable (ParentTable, Subtable);
1829             NodeLength += Subtable->Length;
1830             break;
1831
1832         default:
1833
1834             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IORT");
1835             return (AE_ERROR);
1836         }
1837
1838         /* Compile Array of ID mappings */
1839
1840         IortNode->MappingOffset = NodeLength;
1841         IdMappingNumber = 0;
1842         while (*PFieldList)
1843         {
1844             Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortMap,
1845                 &Subtable);
1846             if (ACPI_FAILURE (Status))
1847             {
1848                 return (Status);
1849             }
1850
1851             if (!Subtable)
1852             {
1853                 break;
1854             }
1855
1856             DtInsertSubtable (ParentTable, Subtable);
1857             NodeLength += sizeof (ACPI_IORT_ID_MAPPING);
1858             IdMappingNumber++;
1859         }
1860
1861         IortNode->MappingCount = IdMappingNumber;
1862         if (!IdMappingNumber)
1863         {
1864             IortNode->MappingOffset = 0;
1865         }
1866
1867         /*
1868          * Node length can be determined by DT_LENGTH option
1869          * IortNode->Length = NodeLength;
1870          */
1871         DtPopSubtable ();
1872         ParentTable = DtPeekSubtable ();
1873         NodeNumber++;
1874     }
1875
1876     Iort->NodeCount = NodeNumber;
1877     return (AE_OK);
1878 }
1879
1880
1881 /******************************************************************************
1882  *
1883  * FUNCTION:    DtCompileIvrs
1884  *
1885  * PARAMETERS:  List                - Current field list pointer
1886  *
1887  * RETURN:      Status
1888  *
1889  * DESCRIPTION: Compile IVRS.
1890  *
1891  *****************************************************************************/
1892
1893 ACPI_STATUS
1894 DtCompileIvrs (
1895     void                    **List)
1896 {
1897     ACPI_STATUS             Status;
1898     DT_SUBTABLE             *Subtable;
1899     DT_SUBTABLE             *ParentTable;
1900     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1901     DT_FIELD                *SubtableStart;
1902     ACPI_DMTABLE_INFO       *InfoTable;
1903     ACPI_IVRS_HEADER        *IvrsHeader;
1904     UINT8                   EntryType;
1905
1906
1907     Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs,
1908         &Subtable);
1909     if (ACPI_FAILURE (Status))
1910     {
1911         return (Status);
1912     }
1913
1914     ParentTable = DtPeekSubtable ();
1915     DtInsertSubtable (ParentTable, Subtable);
1916
1917     while (*PFieldList)
1918     {
1919         SubtableStart = *PFieldList;
1920         Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHdr,
1921             &Subtable);
1922         if (ACPI_FAILURE (Status))
1923         {
1924             return (Status);
1925         }
1926
1927         ParentTable = DtPeekSubtable ();
1928         DtInsertSubtable (ParentTable, Subtable);
1929         DtPushSubtable (Subtable);
1930
1931         IvrsHeader = ACPI_CAST_PTR (ACPI_IVRS_HEADER, Subtable->Buffer);
1932
1933         switch (IvrsHeader->Type)
1934         {
1935         case ACPI_IVRS_TYPE_HARDWARE:
1936
1937             InfoTable = AcpiDmTableInfoIvrs0;
1938             break;
1939
1940         case ACPI_IVRS_TYPE_MEMORY1:
1941         case ACPI_IVRS_TYPE_MEMORY2:
1942         case ACPI_IVRS_TYPE_MEMORY3:
1943
1944             InfoTable = AcpiDmTableInfoIvrs1;
1945             break;
1946
1947         default:
1948
1949             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IVRS");
1950             return (AE_ERROR);
1951         }
1952
1953         Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1954         if (ACPI_FAILURE (Status))
1955         {
1956             return (Status);
1957         }
1958
1959         ParentTable = DtPeekSubtable ();
1960         DtInsertSubtable (ParentTable, Subtable);
1961
1962         if (IvrsHeader->Type == ACPI_IVRS_TYPE_HARDWARE)
1963         {
1964             while (*PFieldList &&
1965                 !strcmp ((*PFieldList)->Name, "Entry Type"))
1966             {
1967                 SubtableStart = *PFieldList;
1968                 DtCompileInteger (&EntryType, *PFieldList, 1, 0);
1969
1970                 switch (EntryType)
1971                 {
1972                 /* 4-byte device entries */
1973
1974                 case ACPI_IVRS_TYPE_PAD4:
1975                 case ACPI_IVRS_TYPE_ALL:
1976                 case ACPI_IVRS_TYPE_SELECT:
1977                 case ACPI_IVRS_TYPE_START:
1978                 case ACPI_IVRS_TYPE_END:
1979
1980                     InfoTable = AcpiDmTableInfoIvrs4;
1981                     break;
1982
1983                 /* 8-byte entries, type A */
1984
1985                 case ACPI_IVRS_TYPE_ALIAS_SELECT:
1986                 case ACPI_IVRS_TYPE_ALIAS_START:
1987
1988                     InfoTable = AcpiDmTableInfoIvrs8a;
1989                     break;
1990
1991                 /* 8-byte entries, type B */
1992
1993                 case ACPI_IVRS_TYPE_PAD8:
1994                 case ACPI_IVRS_TYPE_EXT_SELECT:
1995                 case ACPI_IVRS_TYPE_EXT_START:
1996
1997                     InfoTable = AcpiDmTableInfoIvrs8b;
1998                     break;
1999
2000                 /* 8-byte entries, type C */
2001
2002                 case ACPI_IVRS_TYPE_SPECIAL:
2003
2004                     InfoTable = AcpiDmTableInfoIvrs8c;
2005                     break;
2006
2007                 default:
2008
2009                     DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart,
2010                         "IVRS Device Entry");
2011                     return (AE_ERROR);
2012                 }
2013
2014                 Status = DtCompileTable (PFieldList, InfoTable,
2015                     &Subtable);
2016                 if (ACPI_FAILURE (Status))
2017                 {
2018                     return (Status);
2019                 }
2020
2021                 DtInsertSubtable (ParentTable, Subtable);
2022             }
2023         }
2024
2025         DtPopSubtable ();
2026     }
2027
2028     return (AE_OK);
2029 }