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 - 2021, 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: DtCompileAest 176 * 177 * PARAMETERS: List - Current field list pointer 178 * 179 * RETURN: Status 180 * 181 * DESCRIPTION: Compile AEST. 182 * 183 * NOTE: Assumes the following table structure: 184 * For all AEST Error Nodes: 185 * 1) An AEST Error Node, followed immediately by: 186 * 2) Any node-specific data 187 * 3) An Interface Structure (one) 188 * 4) A list (array) of Interrupt Structures, the count as specified 189 * in the NodeInterruptCount field of the Error Node header. 190 * 191 * AEST - ARM Error Source table. Conforms to: 192 * ACPI for the Armv8 RAS Extensions 1.1 Platform Design Document Sep 2020 193 * 194 *****************************************************************************/ 195 196 ACPI_STATUS 197 DtCompileAest ( 198 void **List) 199 { 200 ACPI_AEST_HEADER *ErrorNodeHeader; 201 ACPI_AEST_PROCESSOR *AestProcessor; 202 DT_SUBTABLE *Subtable; 203 DT_SUBTABLE *ParentTable; 204 ACPI_DMTABLE_INFO *InfoTable; 205 ACPI_STATUS Status; 206 UINT32 i; 207 UINT32 Offset; 208 DT_FIELD **PFieldList = (DT_FIELD **) List; 209 210 211 while (*PFieldList) 212 { 213 /* Compile the common error node header */ 214 215 Status = DtCompileTable (PFieldList, AcpiDmTableInfoAestHdr, 216 &Subtable); 217 if (ACPI_FAILURE (Status)) 218 { 219 return (Status); 220 } 221 222 ParentTable = DtPeekSubtable (); 223 DtInsertSubtable (ParentTable, Subtable); 224 225 /* Everything past the error node header will be a subtable */ 226 227 DtPushSubtable (Subtable); 228 229 /* 230 * Compile the node-specific structure (Based on the error 231 * node header Type field) 232 */ 233 ErrorNodeHeader = ACPI_CAST_PTR (ACPI_AEST_HEADER, Subtable->Buffer); 234 235 /* Point past the common error node header */ 236 237 Offset = sizeof (ACPI_AEST_HEADER); 238 ErrorNodeHeader->NodeSpecificOffset = Offset; 239 240 /* Decode the error node type */ 241 242 switch (ErrorNodeHeader->Type) 243 { 244 case ACPI_AEST_PROCESSOR_ERROR_NODE: 245 246 InfoTable = AcpiDmTableInfoAestProcError; 247 break; 248 249 case ACPI_AEST_MEMORY_ERROR_NODE: 250 251 InfoTable = AcpiDmTableInfoAestMemError; 252 break; 253 254 case ACPI_AEST_SMMU_ERROR_NODE: 255 256 InfoTable = AcpiDmTableInfoAestSmmuError; 257 break; 258 259 case ACPI_AEST_VENDOR_ERROR_NODE: 260 261 InfoTable = AcpiDmTableInfoAestVendorError; 262 break; 263 264 case ACPI_AEST_GIC_ERROR_NODE: 265 266 InfoTable = AcpiDmTableInfoAestGicError; 267 break; 268 269 /* Error case below */ 270 default: 271 AcpiOsPrintf ("Unknown AEST Subtable Type: %X\n", 272 ErrorNodeHeader->Type); 273 return (AE_ERROR); 274 } 275 276 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 277 if (ACPI_FAILURE (Status)) 278 { 279 return (Status); 280 } 281 282 /* Point past the node-specific structure */ 283 284 Offset += Subtable->Length; 285 ErrorNodeHeader->NodeInterfaceOffset = Offset; 286 287 ParentTable = DtPeekSubtable (); 288 DtInsertSubtable (ParentTable, Subtable); 289 290 /* Compile any additional node-specific substructures */ 291 292 if (ErrorNodeHeader->Type == ACPI_AEST_PROCESSOR_ERROR_NODE) 293 { 294 /* 295 * Special handling for PROCESSOR_ERROR_NODE subtables 296 * (to handle the Resource Substructure via the ResourceType 297 * field). 298 */ 299 AestProcessor = ACPI_CAST_PTR (ACPI_AEST_PROCESSOR, 300 Subtable->Buffer); 301 302 switch (AestProcessor->ResourceType) 303 { 304 case ACPI_AEST_CACHE_RESOURCE: 305 306 InfoTable = AcpiDmTableInfoAestCacheRsrc; 307 break; 308 309 case ACPI_AEST_TLB_RESOURCE: 310 311 InfoTable = AcpiDmTableInfoAestTlbRsrc; 312 break; 313 314 case ACPI_AEST_GENERIC_RESOURCE: 315 316 InfoTable = AcpiDmTableInfoAestGenRsrc; 317 AcpiOsPrintf ("Generic Resource Type (%X) is not supported at this time\n", 318 AestProcessor->ResourceType); 319 return (AE_ERROR); 320 321 /* Error case below */ 322 default: 323 AcpiOsPrintf ("Unknown AEST Processor Resource Type: %X\n", 324 AestProcessor->ResourceType); 325 return (AE_ERROR); 326 } 327 328 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 329 if (ACPI_FAILURE (Status)) 330 { 331 return (Status); 332 } 333 334 /* Point past the resource substructure subtable */ 335 336 Offset += Subtable->Length; 337 ErrorNodeHeader->NodeInterfaceOffset = Offset; 338 339 ParentTable = DtPeekSubtable (); 340 DtInsertSubtable (ParentTable, Subtable); 341 } 342 343 /* Compile the (required) node interface structure */ 344 345 Status = DtCompileTable (PFieldList, AcpiDmTableInfoAestXface, 346 &Subtable); 347 if (ACPI_FAILURE (Status)) 348 { 349 return (Status); 350 } 351 352 ErrorNodeHeader->NodeInterruptOffset = 0; 353 ParentTable = DtPeekSubtable (); 354 DtInsertSubtable (ParentTable, Subtable); 355 356 /* Compile each of the node interrupt structures */ 357 358 if (ErrorNodeHeader->NodeInterruptCount) 359 { 360 /* Point to the first interrupt structure */ 361 362 Offset += Subtable->Length; 363 ErrorNodeHeader->NodeInterruptOffset = Offset; 364 } 365 366 /* Compile each of the interrupt structures */ 367 368 for (i = 0; i < ErrorNodeHeader->NodeInterruptCount; i++) 369 { 370 Status = DtCompileTable (PFieldList, AcpiDmTableInfoAestXrupt, 371 &Subtable); 372 if (ACPI_FAILURE (Status)) 373 { 374 return (Status); 375 } 376 377 ParentTable = DtPeekSubtable (); 378 DtInsertSubtable (ParentTable, Subtable); 379 } 380 381 /* Prepare for the next AEST Error node */ 382 383 DtPopSubtable (); 384 } 385 386 return (AE_OK); 387 } 388 389 390 /****************************************************************************** 391 * 392 * FUNCTION: DtCompileAsf 393 * 394 * PARAMETERS: List - Current field list pointer 395 * 396 * RETURN: Status 397 * 398 * DESCRIPTION: Compile ASF!. 399 * 400 *****************************************************************************/ 401 402 ACPI_STATUS 403 DtCompileAsf ( 404 void **List) 405 { 406 ACPI_ASF_INFO *AsfTable; 407 DT_SUBTABLE *Subtable; 408 DT_SUBTABLE *ParentTable; 409 ACPI_DMTABLE_INFO *InfoTable; 410 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 411 UINT32 DataCount = 0; 412 ACPI_STATUS Status; 413 UINT32 i; 414 DT_FIELD **PFieldList = (DT_FIELD **) List; 415 DT_FIELD *SubtableStart; 416 417 418 while (*PFieldList) 419 { 420 SubtableStart = *PFieldList; 421 Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr, 422 &Subtable); 423 if (ACPI_FAILURE (Status)) 424 { 425 return (Status); 426 } 427 428 ParentTable = DtPeekSubtable (); 429 DtInsertSubtable (ParentTable, Subtable); 430 DtPushSubtable (Subtable); 431 432 AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer); 433 434 switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */ 435 { 436 case ACPI_ASF_TYPE_INFO: 437 438 InfoTable = AcpiDmTableInfoAsf0; 439 break; 440 441 case ACPI_ASF_TYPE_ALERT: 442 443 InfoTable = AcpiDmTableInfoAsf1; 444 break; 445 446 case ACPI_ASF_TYPE_CONTROL: 447 448 InfoTable = AcpiDmTableInfoAsf2; 449 break; 450 451 case ACPI_ASF_TYPE_BOOT: 452 453 InfoTable = AcpiDmTableInfoAsf3; 454 break; 455 456 case ACPI_ASF_TYPE_ADDRESS: 457 458 InfoTable = AcpiDmTableInfoAsf4; 459 break; 460 461 default: 462 463 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!"); 464 return (AE_ERROR); 465 } 466 467 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 468 if (ACPI_FAILURE (Status)) 469 { 470 return (Status); 471 } 472 473 ParentTable = DtPeekSubtable (); 474 DtInsertSubtable (ParentTable, Subtable); 475 476 switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */ 477 { 478 case ACPI_ASF_TYPE_INFO: 479 480 DataInfoTable = NULL; 481 break; 482 483 case ACPI_ASF_TYPE_ALERT: 484 485 DataInfoTable = AcpiDmTableInfoAsf1a; 486 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, 487 ACPI_SUB_PTR (UINT8, Subtable->Buffer, 488 sizeof (ACPI_ASF_HEADER)))->Alerts; 489 break; 490 491 case ACPI_ASF_TYPE_CONTROL: 492 493 DataInfoTable = AcpiDmTableInfoAsf2a; 494 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, 495 ACPI_SUB_PTR (UINT8, Subtable->Buffer, 496 sizeof (ACPI_ASF_HEADER)))->Controls; 497 break; 498 499 case ACPI_ASF_TYPE_BOOT: 500 501 DataInfoTable = NULL; 502 break; 503 504 case ACPI_ASF_TYPE_ADDRESS: 505 506 DataInfoTable = TableInfoAsfAddress; 507 DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, 508 ACPI_SUB_PTR (UINT8, Subtable->Buffer, 509 sizeof (ACPI_ASF_HEADER)))->Devices; 510 break; 511 512 default: 513 514 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!"); 515 return (AE_ERROR); 516 } 517 518 if (DataInfoTable) 519 { 520 switch (AsfTable->Header.Type & 0x7F) 521 { 522 case ACPI_ASF_TYPE_ADDRESS: 523 524 while (DataCount > 0) 525 { 526 Status = DtCompileTable (PFieldList, DataInfoTable, 527 &Subtable); 528 if (ACPI_FAILURE (Status)) 529 { 530 return (Status); 531 } 532 533 DtInsertSubtable (ParentTable, Subtable); 534 DataCount = DataCount - Subtable->Length; 535 } 536 break; 537 538 default: 539 540 for (i = 0; i < DataCount; i++) 541 { 542 Status = DtCompileTable (PFieldList, DataInfoTable, 543 &Subtable); 544 if (ACPI_FAILURE (Status)) 545 { 546 return (Status); 547 } 548 549 DtInsertSubtable (ParentTable, Subtable); 550 } 551 break; 552 } 553 } 554 555 DtPopSubtable (); 556 } 557 558 return (AE_OK); 559 } 560 561 562 /****************************************************************************** 563 * 564 * FUNCTION: DtCompileCedt 565 * 566 * PARAMETERS: List - Current field list pointer 567 * 568 * RETURN: Status 569 * 570 * DESCRIPTION: Compile CEDT. 571 * 572 *****************************************************************************/ 573 574 ACPI_STATUS 575 DtCompileCedt ( 576 void **List) 577 { 578 ACPI_STATUS Status; 579 DT_SUBTABLE *Subtable; 580 DT_SUBTABLE *ParentTable; 581 DT_FIELD **PFieldList = (DT_FIELD **) List; 582 ACPI_CEDT_HEADER *CedtHeader; 583 DT_FIELD *SubtableStart; 584 585 586 /* Walk the parse tree */ 587 588 while (*PFieldList) 589 { 590 SubtableStart = *PFieldList; 591 592 /* CEDT Header */ 593 594 Status = DtCompileTable (PFieldList, AcpiDmTableInfoCedtHdr, 595 &Subtable); 596 if (ACPI_FAILURE (Status)) 597 { 598 return (Status); 599 } 600 601 ParentTable = DtPeekSubtable (); 602 DtInsertSubtable (ParentTable, Subtable); 603 DtPushSubtable (Subtable); 604 605 CedtHeader = ACPI_CAST_PTR (ACPI_CEDT_HEADER, Subtable->Buffer); 606 607 switch (CedtHeader->Type) 608 { 609 case ACPI_CEDT_TYPE_CHBS: 610 611 break; 612 613 default: 614 615 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "CEDT"); 616 return (AE_ERROR); 617 } 618 619 /* CEDT Subtable */ 620 621 Status = DtCompileTable (PFieldList, AcpiDmTableInfoCedt0, &Subtable); 622 if (ACPI_FAILURE (Status)) 623 { 624 return (Status); 625 } 626 627 ParentTable = DtPeekSubtable (); 628 DtInsertSubtable (ParentTable, Subtable); 629 DtPopSubtable (); 630 } 631 632 return (AE_OK); 633 } 634 635 636 /****************************************************************************** 637 * 638 * FUNCTION: DtCompileCpep 639 * 640 * PARAMETERS: List - Current field list pointer 641 * 642 * RETURN: Status 643 * 644 * DESCRIPTION: Compile CPEP. 645 * 646 *****************************************************************************/ 647 648 ACPI_STATUS 649 DtCompileCpep ( 650 void **List) 651 { 652 ACPI_STATUS Status; 653 654 655 Status = DtCompileTwoSubtables (List, 656 AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0); 657 return (Status); 658 } 659 660 661 /****************************************************************************** 662 * 663 * FUNCTION: DtCompileCsrt 664 * 665 * PARAMETERS: List - Current field list pointer 666 * 667 * RETURN: Status 668 * 669 * DESCRIPTION: Compile CSRT. 670 * 671 *****************************************************************************/ 672 673 ACPI_STATUS 674 DtCompileCsrt ( 675 void **List) 676 { 677 ACPI_STATUS Status = AE_OK; 678 DT_SUBTABLE *Subtable; 679 DT_SUBTABLE *ParentTable; 680 DT_FIELD **PFieldList = (DT_FIELD **) List; 681 UINT32 DescriptorCount; 682 UINT32 GroupLength; 683 684 685 /* Subtables (Resource Groups) */ 686 687 ParentTable = DtPeekSubtable (); 688 while (*PFieldList) 689 { 690 /* Resource group subtable */ 691 692 Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt0, 693 &Subtable); 694 if (ACPI_FAILURE (Status)) 695 { 696 return (Status); 697 } 698 699 /* Compute the number of resource descriptors */ 700 701 GroupLength = 702 (ACPI_CAST_PTR (ACPI_CSRT_GROUP, 703 Subtable->Buffer))->Length - 704 (ACPI_CAST_PTR (ACPI_CSRT_GROUP, 705 Subtable->Buffer))->SharedInfoLength - 706 sizeof (ACPI_CSRT_GROUP); 707 708 DescriptorCount = (GroupLength / 709 sizeof (ACPI_CSRT_DESCRIPTOR)); 710 711 DtInsertSubtable (ParentTable, Subtable); 712 DtPushSubtable (Subtable); 713 ParentTable = DtPeekSubtable (); 714 715 /* Shared info subtable (One per resource group) */ 716 717 Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt1, 718 &Subtable); 719 if (ACPI_FAILURE (Status)) 720 { 721 return (Status); 722 } 723 724 DtInsertSubtable (ParentTable, Subtable); 725 726 /* Sub-Subtables (Resource Descriptors) */ 727 728 while (*PFieldList && DescriptorCount) 729 { 730 731 Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2, 732 &Subtable); 733 if (ACPI_FAILURE (Status)) 734 { 735 return (Status); 736 } 737 738 DtInsertSubtable (ParentTable, Subtable); 739 740 DtPushSubtable (Subtable); 741 ParentTable = DtPeekSubtable (); 742 if (*PFieldList) 743 { 744 Status = DtCompileTable (PFieldList, AcpiDmTableInfoCsrt2a, 745 &Subtable); 746 if (ACPI_FAILURE (Status)) 747 { 748 return (Status); 749 } 750 if (Subtable) 751 { 752 DtInsertSubtable (ParentTable, Subtable); 753 } 754 } 755 756 DtPopSubtable (); 757 ParentTable = DtPeekSubtable (); 758 DescriptorCount--; 759 } 760 761 DtPopSubtable (); 762 ParentTable = DtPeekSubtable (); 763 } 764 765 return (Status); 766 } 767 768 769 /****************************************************************************** 770 * 771 * FUNCTION: DtCompileDbg2 772 * 773 * PARAMETERS: List - Current field list pointer 774 * 775 * RETURN: Status 776 * 777 * DESCRIPTION: Compile DBG2. 778 * 779 *****************************************************************************/ 780 781 ACPI_STATUS 782 DtCompileDbg2 ( 783 void **List) 784 { 785 ACPI_STATUS Status; 786 DT_SUBTABLE *Subtable; 787 DT_SUBTABLE *ParentTable; 788 DT_FIELD **PFieldList = (DT_FIELD **) List; 789 UINT32 SubtableCount; 790 ACPI_DBG2_HEADER *Dbg2Header; 791 ACPI_DBG2_DEVICE *DeviceInfo; 792 UINT16 CurrentOffset; 793 UINT32 i; 794 795 796 /* Main table */ 797 798 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2, &Subtable); 799 if (ACPI_FAILURE (Status)) 800 { 801 return (Status); 802 } 803 804 ParentTable = DtPeekSubtable (); 805 DtInsertSubtable (ParentTable, Subtable); 806 807 /* Main table fields */ 808 809 Dbg2Header = ACPI_CAST_PTR (ACPI_DBG2_HEADER, Subtable->Buffer); 810 Dbg2Header->InfoOffset = sizeof (ACPI_TABLE_HEADER) + ACPI_PTR_DIFF ( 811 ACPI_ADD_PTR (UINT8, Dbg2Header, sizeof (ACPI_DBG2_HEADER)), Dbg2Header); 812 813 SubtableCount = Dbg2Header->InfoCount; 814 DtPushSubtable (Subtable); 815 816 /* Process all Device Information subtables (Count = InfoCount) */ 817 818 while (*PFieldList && SubtableCount) 819 { 820 /* Subtable: Debug Device Information */ 821 822 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Device, 823 &Subtable); 824 if (ACPI_FAILURE (Status)) 825 { 826 return (Status); 827 } 828 829 DeviceInfo = ACPI_CAST_PTR (ACPI_DBG2_DEVICE, Subtable->Buffer); 830 CurrentOffset = (UINT16) sizeof (ACPI_DBG2_DEVICE); 831 832 ParentTable = DtPeekSubtable (); 833 DtInsertSubtable (ParentTable, Subtable); 834 DtPushSubtable (Subtable); 835 836 ParentTable = DtPeekSubtable (); 837 838 /* BaseAddressRegister GAS array (Required, size is RegisterCount) */ 839 840 DeviceInfo->BaseAddressOffset = CurrentOffset; 841 for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++) 842 { 843 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Addr, 844 &Subtable); 845 if (ACPI_FAILURE (Status)) 846 { 847 return (Status); 848 } 849 850 CurrentOffset += (UINT16) sizeof (ACPI_GENERIC_ADDRESS); 851 DtInsertSubtable (ParentTable, Subtable); 852 } 853 854 /* AddressSize array (Required, size = RegisterCount) */ 855 856 DeviceInfo->AddressSizeOffset = CurrentOffset; 857 for (i = 0; *PFieldList && (i < DeviceInfo->RegisterCount); i++) 858 { 859 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Size, 860 &Subtable); 861 if (ACPI_FAILURE (Status)) 862 { 863 return (Status); 864 } 865 866 CurrentOffset += (UINT16) sizeof (UINT32); 867 DtInsertSubtable (ParentTable, Subtable); 868 } 869 870 /* NamespaceString device identifier (Required, size = NamePathLength) */ 871 872 DeviceInfo->NamepathOffset = CurrentOffset; 873 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2Name, 874 &Subtable); 875 if (ACPI_FAILURE (Status)) 876 { 877 return (Status); 878 } 879 880 /* Update the device info header */ 881 882 DeviceInfo->NamepathLength = (UINT16) Subtable->Length; 883 CurrentOffset += (UINT16) DeviceInfo->NamepathLength; 884 DtInsertSubtable (ParentTable, Subtable); 885 886 /* OemData - Variable-length data (Optional, size = OemDataLength) */ 887 888 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDbg2OemData, 889 &Subtable); 890 if (Status == AE_END_OF_TABLE) 891 { 892 /* optional field was not found and we're at the end of the file */ 893 894 goto subtableDone; 895 } 896 else if (ACPI_FAILURE (Status)) 897 { 898 return (Status); 899 } 900 901 /* Update the device info header (zeros if no OEM data present) */ 902 903 DeviceInfo->OemDataOffset = 0; 904 DeviceInfo->OemDataLength = 0; 905 906 /* Optional subtable (OemData) */ 907 908 if (Subtable && Subtable->Length) 909 { 910 DeviceInfo->OemDataOffset = CurrentOffset; 911 DeviceInfo->OemDataLength = (UINT16) Subtable->Length; 912 913 DtInsertSubtable (ParentTable, Subtable); 914 } 915 subtableDone: 916 SubtableCount--; 917 DtPopSubtable (); /* Get next Device Information subtable */ 918 } 919 920 DtPopSubtable (); 921 return (AE_OK); 922 } 923 924 925 /****************************************************************************** 926 * 927 * FUNCTION: DtCompileDmar 928 * 929 * PARAMETERS: List - Current field list pointer 930 * 931 * RETURN: Status 932 * 933 * DESCRIPTION: Compile DMAR. 934 * 935 *****************************************************************************/ 936 937 ACPI_STATUS 938 DtCompileDmar ( 939 void **List) 940 { 941 ACPI_STATUS Status; 942 DT_SUBTABLE *Subtable; 943 DT_SUBTABLE *ParentTable; 944 DT_FIELD **PFieldList = (DT_FIELD **) List; 945 DT_FIELD *SubtableStart; 946 ACPI_DMTABLE_INFO *InfoTable; 947 ACPI_DMAR_HEADER *DmarHeader; 948 ACPI_DMAR_DEVICE_SCOPE *DmarDeviceScope; 949 UINT32 DeviceScopeLength; 950 UINT32 PciPathLength; 951 952 953 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable); 954 if (ACPI_FAILURE (Status)) 955 { 956 return (Status); 957 } 958 959 ParentTable = DtPeekSubtable (); 960 DtInsertSubtable (ParentTable, Subtable); 961 DtPushSubtable (Subtable); 962 963 while (*PFieldList) 964 { 965 /* DMAR Header */ 966 967 SubtableStart = *PFieldList; 968 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarHdr, 969 &Subtable); 970 if (ACPI_FAILURE (Status)) 971 { 972 return (Status); 973 } 974 975 ParentTable = DtPeekSubtable (); 976 DtInsertSubtable (ParentTable, Subtable); 977 DtPushSubtable (Subtable); 978 979 DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer); 980 981 switch (DmarHeader->Type) 982 { 983 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 984 985 InfoTable = AcpiDmTableInfoDmar0; 986 break; 987 988 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 989 990 InfoTable = AcpiDmTableInfoDmar1; 991 break; 992 993 case ACPI_DMAR_TYPE_ROOT_ATS: 994 995 InfoTable = AcpiDmTableInfoDmar2; 996 break; 997 998 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 999 1000 InfoTable = AcpiDmTableInfoDmar3; 1001 break; 1002 1003 case ACPI_DMAR_TYPE_NAMESPACE: 1004 1005 InfoTable = AcpiDmTableInfoDmar4; 1006 break; 1007 1008 default: 1009 1010 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "DMAR"); 1011 return (AE_ERROR); 1012 } 1013 1014 /* DMAR Subtable */ 1015 1016 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1017 if (ACPI_FAILURE (Status)) 1018 { 1019 return (Status); 1020 } 1021 1022 ParentTable = DtPeekSubtable (); 1023 DtInsertSubtable (ParentTable, Subtable); 1024 1025 /* 1026 * Optional Device Scope subtables 1027 */ 1028 if ((DmarHeader->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 1029 (DmarHeader->Type == ACPI_DMAR_TYPE_NAMESPACE)) 1030 { 1031 /* These types do not support device scopes */ 1032 1033 DtPopSubtable (); 1034 continue; 1035 } 1036 1037 DtPushSubtable (Subtable); 1038 DeviceScopeLength = DmarHeader->Length - Subtable->Length - 1039 ParentTable->Length; 1040 while (DeviceScopeLength) 1041 { 1042 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope, 1043 &Subtable); 1044 if (Status == AE_NOT_FOUND) 1045 { 1046 break; 1047 } 1048 1049 ParentTable = DtPeekSubtable (); 1050 DtInsertSubtable (ParentTable, Subtable); 1051 DtPushSubtable (Subtable); 1052 1053 DmarDeviceScope = ACPI_CAST_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable->Buffer); 1054 1055 /* Optional PCI Paths */ 1056 1057 PciPathLength = DmarDeviceScope->Length - Subtable->Length; 1058 while (PciPathLength) 1059 { 1060 Status = DtCompileTable (PFieldList, TableInfoDmarPciPath, 1061 &Subtable); 1062 if (Status == AE_NOT_FOUND) 1063 { 1064 DtPopSubtable (); 1065 break; 1066 } 1067 1068 ParentTable = DtPeekSubtable (); 1069 DtInsertSubtable (ParentTable, Subtable); 1070 PciPathLength -= Subtable->Length; 1071 } 1072 1073 DtPopSubtable (); 1074 DeviceScopeLength -= DmarDeviceScope->Length; 1075 } 1076 1077 DtPopSubtable (); 1078 DtPopSubtable (); 1079 } 1080 1081 return (AE_OK); 1082 } 1083 1084 1085 /****************************************************************************** 1086 * 1087 * FUNCTION: DtCompileDrtm 1088 * 1089 * PARAMETERS: List - Current field list pointer 1090 * 1091 * RETURN: Status 1092 * 1093 * DESCRIPTION: Compile DRTM. 1094 * 1095 *****************************************************************************/ 1096 1097 ACPI_STATUS 1098 DtCompileDrtm ( 1099 void **List) 1100 { 1101 ACPI_STATUS Status; 1102 DT_SUBTABLE *Subtable; 1103 DT_SUBTABLE *ParentTable; 1104 DT_FIELD **PFieldList = (DT_FIELD **) List; 1105 UINT32 Count; 1106 /* ACPI_TABLE_DRTM *Drtm; */ 1107 ACPI_DRTM_VTABLE_LIST *DrtmVtl; 1108 ACPI_DRTM_RESOURCE_LIST *DrtmRl; 1109 /* ACPI_DRTM_DPS_ID *DrtmDps; */ 1110 1111 1112 ParentTable = DtPeekSubtable (); 1113 1114 /* Compile DRTM header */ 1115 1116 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm, 1117 &Subtable); 1118 if (ACPI_FAILURE (Status)) 1119 { 1120 return (Status); 1121 } 1122 DtInsertSubtable (ParentTable, Subtable); 1123 1124 /* 1125 * Using ACPI_SUB_PTR, We needn't define a separate structure. Care 1126 * should be taken to avoid accessing ACPI_TABLE_HADER fields. 1127 */ 1128 #if 0 1129 Drtm = ACPI_SUB_PTR (ACPI_TABLE_DRTM, 1130 Subtable->Buffer, sizeof (ACPI_TABLE_HEADER)); 1131 #endif 1132 /* Compile VTL */ 1133 1134 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0, 1135 &Subtable); 1136 if (ACPI_FAILURE (Status)) 1137 { 1138 return (Status); 1139 } 1140 1141 DtInsertSubtable (ParentTable, Subtable); 1142 DrtmVtl = ACPI_CAST_PTR (ACPI_DRTM_VTABLE_LIST, Subtable->Buffer); 1143 1144 DtPushSubtable (Subtable); 1145 ParentTable = DtPeekSubtable (); 1146 Count = 0; 1147 1148 while (*PFieldList) 1149 { 1150 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm0a, 1151 &Subtable); 1152 if (ACPI_FAILURE (Status)) 1153 { 1154 return (Status); 1155 } 1156 if (!Subtable) 1157 { 1158 break; 1159 } 1160 DtInsertSubtable (ParentTable, Subtable); 1161 Count++; 1162 } 1163 1164 DrtmVtl->ValidatedTableCount = Count; 1165 DtPopSubtable (); 1166 ParentTable = DtPeekSubtable (); 1167 1168 /* Compile RL */ 1169 1170 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1, 1171 &Subtable); 1172 if (ACPI_FAILURE (Status)) 1173 { 1174 return (Status); 1175 } 1176 1177 DtInsertSubtable (ParentTable, Subtable); 1178 DrtmRl = ACPI_CAST_PTR (ACPI_DRTM_RESOURCE_LIST, Subtable->Buffer); 1179 1180 DtPushSubtable (Subtable); 1181 ParentTable = DtPeekSubtable (); 1182 Count = 0; 1183 1184 while (*PFieldList) 1185 { 1186 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm1a, 1187 &Subtable); 1188 if (ACPI_FAILURE (Status)) 1189 { 1190 return (Status); 1191 } 1192 1193 if (!Subtable) 1194 { 1195 break; 1196 } 1197 1198 DtInsertSubtable (ParentTable, Subtable); 1199 Count++; 1200 } 1201 1202 DrtmRl->ResourceCount = Count; 1203 DtPopSubtable (); 1204 ParentTable = DtPeekSubtable (); 1205 1206 /* Compile DPS */ 1207 1208 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDrtm2, 1209 &Subtable); 1210 if (ACPI_FAILURE (Status)) 1211 { 1212 return (Status); 1213 } 1214 DtInsertSubtable (ParentTable, Subtable); 1215 /* DrtmDps = ACPI_CAST_PTR (ACPI_DRTM_DPS_ID, Subtable->Buffer);*/ 1216 1217 1218 return (AE_OK); 1219 } 1220 1221 1222 /****************************************************************************** 1223 * 1224 * FUNCTION: DtCompileEinj 1225 * 1226 * PARAMETERS: List - Current field list pointer 1227 * 1228 * RETURN: Status 1229 * 1230 * DESCRIPTION: Compile EINJ. 1231 * 1232 *****************************************************************************/ 1233 1234 ACPI_STATUS 1235 DtCompileEinj ( 1236 void **List) 1237 { 1238 ACPI_STATUS Status; 1239 1240 1241 Status = DtCompileTwoSubtables (List, 1242 AcpiDmTableInfoEinj, AcpiDmTableInfoEinj0); 1243 return (Status); 1244 } 1245 1246 1247 /****************************************************************************** 1248 * 1249 * FUNCTION: DtCompileErst 1250 * 1251 * PARAMETERS: List - Current field list pointer 1252 * 1253 * RETURN: Status 1254 * 1255 * DESCRIPTION: Compile ERST. 1256 * 1257 *****************************************************************************/ 1258 1259 ACPI_STATUS 1260 DtCompileErst ( 1261 void **List) 1262 { 1263 ACPI_STATUS Status; 1264 1265 1266 Status = DtCompileTwoSubtables (List, 1267 AcpiDmTableInfoErst, AcpiDmTableInfoEinj0); 1268 return (Status); 1269 } 1270 1271 1272 /****************************************************************************** 1273 * 1274 * FUNCTION: DtCompileGtdt 1275 * 1276 * PARAMETERS: List - Current field list pointer 1277 * 1278 * RETURN: Status 1279 * 1280 * DESCRIPTION: Compile GTDT. 1281 * 1282 *****************************************************************************/ 1283 1284 ACPI_STATUS 1285 DtCompileGtdt ( 1286 void **List) 1287 { 1288 ACPI_STATUS Status; 1289 DT_SUBTABLE *Subtable; 1290 DT_SUBTABLE *ParentTable; 1291 DT_FIELD **PFieldList = (DT_FIELD **) List; 1292 DT_FIELD *SubtableStart; 1293 ACPI_SUBTABLE_HEADER *GtdtHeader; 1294 ACPI_DMTABLE_INFO *InfoTable; 1295 UINT32 GtCount; 1296 ACPI_TABLE_HEADER *Header; 1297 1298 1299 ParentTable = DtPeekSubtable (); 1300 1301 Header = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); 1302 1303 /* Compile the main table */ 1304 1305 Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt, 1306 &Subtable); 1307 if (ACPI_FAILURE (Status)) 1308 { 1309 return (Status); 1310 } 1311 1312 /* GTDT revision 3 later contains 2 extra fields before subtables */ 1313 1314 if (Header->Revision > 2) 1315 { 1316 ParentTable = DtPeekSubtable (); 1317 DtInsertSubtable (ParentTable, Subtable); 1318 1319 Status = DtCompileTable (PFieldList, 1320 AcpiDmTableInfoGtdtEl2, &Subtable); 1321 if (ACPI_FAILURE (Status)) 1322 { 1323 return (Status); 1324 } 1325 } 1326 1327 ParentTable = DtPeekSubtable (); 1328 DtInsertSubtable (ParentTable, Subtable); 1329 1330 while (*PFieldList) 1331 { 1332 SubtableStart = *PFieldList; 1333 Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdtHdr, 1334 &Subtable); 1335 if (ACPI_FAILURE (Status)) 1336 { 1337 return (Status); 1338 } 1339 1340 ParentTable = DtPeekSubtable (); 1341 DtInsertSubtable (ParentTable, Subtable); 1342 DtPushSubtable (Subtable); 1343 1344 GtdtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1345 1346 switch (GtdtHeader->Type) 1347 { 1348 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1349 1350 InfoTable = AcpiDmTableInfoGtdt0; 1351 break; 1352 1353 case ACPI_GTDT_TYPE_WATCHDOG: 1354 1355 InfoTable = AcpiDmTableInfoGtdt1; 1356 break; 1357 1358 default: 1359 1360 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "GTDT"); 1361 return (AE_ERROR); 1362 } 1363 1364 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1365 if (ACPI_FAILURE (Status)) 1366 { 1367 return (Status); 1368 } 1369 1370 ParentTable = DtPeekSubtable (); 1371 DtInsertSubtable (ParentTable, Subtable); 1372 1373 /* 1374 * Additional GT block subtable data 1375 */ 1376 1377 switch (GtdtHeader->Type) 1378 { 1379 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1380 1381 DtPushSubtable (Subtable); 1382 ParentTable = DtPeekSubtable (); 1383 1384 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 1385 Subtable->Buffer - sizeof(ACPI_GTDT_HEADER)))->TimerCount; 1386 1387 while (GtCount) 1388 { 1389 Status = DtCompileTable (PFieldList, AcpiDmTableInfoGtdt0a, 1390 &Subtable); 1391 if (ACPI_FAILURE (Status)) 1392 { 1393 return (Status); 1394 } 1395 1396 DtInsertSubtable (ParentTable, Subtable); 1397 GtCount--; 1398 } 1399 1400 DtPopSubtable (); 1401 break; 1402 1403 default: 1404 1405 break; 1406 } 1407 1408 DtPopSubtable (); 1409 } 1410 1411 return (AE_OK); 1412 } 1413 1414 1415 /****************************************************************************** 1416 * 1417 * FUNCTION: DtCompileFpdt 1418 * 1419 * PARAMETERS: List - Current field list pointer 1420 * 1421 * RETURN: Status 1422 * 1423 * DESCRIPTION: Compile FPDT. 1424 * 1425 *****************************************************************************/ 1426 1427 ACPI_STATUS 1428 DtCompileFpdt ( 1429 void **List) 1430 { 1431 ACPI_STATUS Status; 1432 ACPI_FPDT_HEADER *FpdtHeader; 1433 DT_SUBTABLE *Subtable; 1434 DT_SUBTABLE *ParentTable; 1435 ACPI_DMTABLE_INFO *InfoTable; 1436 DT_FIELD **PFieldList = (DT_FIELD **) List; 1437 DT_FIELD *SubtableStart; 1438 1439 1440 while (*PFieldList) 1441 { 1442 SubtableStart = *PFieldList; 1443 Status = DtCompileTable (PFieldList, AcpiDmTableInfoFpdtHdr, 1444 &Subtable); 1445 if (ACPI_FAILURE (Status)) 1446 { 1447 return (Status); 1448 } 1449 1450 ParentTable = DtPeekSubtable (); 1451 DtInsertSubtable (ParentTable, Subtable); 1452 DtPushSubtable (Subtable); 1453 1454 FpdtHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer); 1455 1456 switch (FpdtHeader->Type) 1457 { 1458 case ACPI_FPDT_TYPE_BOOT: 1459 1460 InfoTable = AcpiDmTableInfoFpdt0; 1461 break; 1462 1463 case ACPI_FPDT_TYPE_S3PERF: 1464 1465 InfoTable = AcpiDmTableInfoFpdt1; 1466 break; 1467 1468 default: 1469 1470 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "FPDT"); 1471 return (AE_ERROR); 1472 break; 1473 } 1474 1475 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1476 if (ACPI_FAILURE (Status)) 1477 { 1478 return (Status); 1479 } 1480 1481 ParentTable = DtPeekSubtable (); 1482 DtInsertSubtable (ParentTable, Subtable); 1483 DtPopSubtable (); 1484 } 1485 1486 return (AE_OK); 1487 } 1488 1489 1490 /****************************************************************************** 1491 * 1492 * FUNCTION: DtCompileHest 1493 * 1494 * PARAMETERS: List - Current field list pointer 1495 * 1496 * RETURN: Status 1497 * 1498 * DESCRIPTION: Compile HEST. 1499 * 1500 *****************************************************************************/ 1501 1502 ACPI_STATUS 1503 DtCompileHest ( 1504 void **List) 1505 { 1506 ACPI_STATUS Status; 1507 DT_SUBTABLE *Subtable; 1508 DT_SUBTABLE *ParentTable; 1509 DT_FIELD **PFieldList = (DT_FIELD **) List; 1510 DT_FIELD *SubtableStart; 1511 ACPI_DMTABLE_INFO *InfoTable; 1512 UINT16 Type; 1513 UINT32 BankCount; 1514 1515 1516 Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest, 1517 &Subtable); 1518 if (ACPI_FAILURE (Status)) 1519 { 1520 return (Status); 1521 } 1522 1523 ParentTable = DtPeekSubtable (); 1524 DtInsertSubtable (ParentTable, Subtable); 1525 1526 while (*PFieldList) 1527 { 1528 /* Get subtable type */ 1529 1530 SubtableStart = *PFieldList; 1531 DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0); 1532 1533 switch (Type) 1534 { 1535 case ACPI_HEST_TYPE_IA32_CHECK: 1536 1537 InfoTable = AcpiDmTableInfoHest0; 1538 break; 1539 1540 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1541 1542 InfoTable = AcpiDmTableInfoHest1; 1543 break; 1544 1545 case ACPI_HEST_TYPE_IA32_NMI: 1546 1547 InfoTable = AcpiDmTableInfoHest2; 1548 break; 1549 1550 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1551 1552 InfoTable = AcpiDmTableInfoHest6; 1553 break; 1554 1555 case ACPI_HEST_TYPE_AER_ENDPOINT: 1556 1557 InfoTable = AcpiDmTableInfoHest7; 1558 break; 1559 1560 case ACPI_HEST_TYPE_AER_BRIDGE: 1561 1562 InfoTable = AcpiDmTableInfoHest8; 1563 break; 1564 1565 case ACPI_HEST_TYPE_GENERIC_ERROR: 1566 1567 InfoTable = AcpiDmTableInfoHest9; 1568 break; 1569 1570 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 1571 1572 InfoTable = AcpiDmTableInfoHest10; 1573 break; 1574 1575 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 1576 1577 InfoTable = AcpiDmTableInfoHest11; 1578 break; 1579 1580 default: 1581 1582 /* Cannot continue on unknown type */ 1583 1584 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HEST"); 1585 return (AE_ERROR); 1586 } 1587 1588 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1589 if (ACPI_FAILURE (Status)) 1590 { 1591 return (Status); 1592 } 1593 1594 DtInsertSubtable (ParentTable, Subtable); 1595 1596 /* 1597 * Additional subtable data - IA32 Error Bank(s) 1598 */ 1599 BankCount = 0; 1600 switch (Type) 1601 { 1602 case ACPI_HEST_TYPE_IA32_CHECK: 1603 1604 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1605 Subtable->Buffer))->NumHardwareBanks; 1606 break; 1607 1608 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1609 1610 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1611 Subtable->Buffer))->NumHardwareBanks; 1612 break; 1613 1614 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 1615 1616 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 1617 Subtable->Buffer))->NumHardwareBanks; 1618 break; 1619 1620 default: 1621 1622 break; 1623 } 1624 1625 while (BankCount) 1626 { 1627 Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank, 1628 &Subtable); 1629 if (ACPI_FAILURE (Status)) 1630 { 1631 return (Status); 1632 } 1633 1634 DtInsertSubtable (ParentTable, Subtable); 1635 BankCount--; 1636 } 1637 } 1638 1639 return (AE_OK); 1640 } 1641 1642 1643 /****************************************************************************** 1644 * 1645 * FUNCTION: DtCompileHmat 1646 * 1647 * PARAMETERS: List - Current field list pointer 1648 * 1649 * RETURN: Status 1650 * 1651 * DESCRIPTION: Compile HMAT. 1652 * 1653 *****************************************************************************/ 1654 1655 ACPI_STATUS 1656 DtCompileHmat ( 1657 void **List) 1658 { 1659 ACPI_STATUS Status; 1660 DT_SUBTABLE *Subtable; 1661 DT_SUBTABLE *ParentTable; 1662 DT_FIELD **PFieldList = (DT_FIELD **) List; 1663 DT_FIELD *SubtableStart; 1664 DT_FIELD *EntryStart; 1665 ACPI_HMAT_STRUCTURE *HmatStruct; 1666 ACPI_HMAT_LOCALITY *HmatLocality; 1667 ACPI_HMAT_CACHE *HmatCache; 1668 ACPI_DMTABLE_INFO *InfoTable; 1669 UINT32 IntPDNumber; 1670 UINT32 TgtPDNumber; 1671 UINT64 EntryNumber; 1672 UINT16 SMBIOSHandleNumber; 1673 1674 1675 ParentTable = DtPeekSubtable (); 1676 1677 Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmat, 1678 &Subtable); 1679 if (ACPI_FAILURE (Status)) 1680 { 1681 return (Status); 1682 } 1683 DtInsertSubtable (ParentTable, Subtable); 1684 1685 while (*PFieldList) 1686 { 1687 /* Compile HMAT structure header */ 1688 1689 SubtableStart = *PFieldList; 1690 Status = DtCompileTable (PFieldList, AcpiDmTableInfoHmatHdr, 1691 &Subtable); 1692 if (ACPI_FAILURE (Status)) 1693 { 1694 return (Status); 1695 } 1696 DtInsertSubtable (ParentTable, Subtable); 1697 1698 HmatStruct = ACPI_CAST_PTR (ACPI_HMAT_STRUCTURE, Subtable->Buffer); 1699 HmatStruct->Length = Subtable->Length; 1700 1701 /* Compile HMAT structure body */ 1702 1703 switch (HmatStruct->Type) 1704 { 1705 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 1706 1707 InfoTable = AcpiDmTableInfoHmat0; 1708 break; 1709 1710 case ACPI_HMAT_TYPE_LOCALITY: 1711 1712 InfoTable = AcpiDmTableInfoHmat1; 1713 break; 1714 1715 case ACPI_HMAT_TYPE_CACHE: 1716 1717 InfoTable = AcpiDmTableInfoHmat2; 1718 break; 1719 1720 default: 1721 1722 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HMAT"); 1723 return (AE_ERROR); 1724 } 1725 1726 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1727 if (ACPI_FAILURE (Status)) 1728 { 1729 return (Status); 1730 } 1731 DtInsertSubtable (ParentTable, Subtable); 1732 HmatStruct->Length += Subtable->Length; 1733 1734 /* Compile HMAT structure additionals */ 1735 1736 switch (HmatStruct->Type) 1737 { 1738 case ACPI_HMAT_TYPE_LOCALITY: 1739 1740 HmatLocality = ACPI_SUB_PTR (ACPI_HMAT_LOCALITY, 1741 Subtable->Buffer, sizeof (ACPI_HMAT_STRUCTURE)); 1742 1743 /* Compile initiator proximity domain list */ 1744 1745 IntPDNumber = 0; 1746 while (*PFieldList) 1747 { 1748 Status = DtCompileTable (PFieldList, 1749 AcpiDmTableInfoHmat1a, &Subtable); 1750 if (ACPI_FAILURE (Status)) 1751 { 1752 return (Status); 1753 } 1754 if (!Subtable) 1755 { 1756 break; 1757 } 1758 DtInsertSubtable (ParentTable, Subtable); 1759 HmatStruct->Length += Subtable->Length; 1760 IntPDNumber++; 1761 } 1762 HmatLocality->NumberOfInitiatorPDs = IntPDNumber; 1763 1764 /* Compile target proximity domain list */ 1765 1766 TgtPDNumber = 0; 1767 while (*PFieldList) 1768 { 1769 Status = DtCompileTable (PFieldList, 1770 AcpiDmTableInfoHmat1b, &Subtable); 1771 if (ACPI_FAILURE (Status)) 1772 { 1773 return (Status); 1774 } 1775 if (!Subtable) 1776 { 1777 break; 1778 } 1779 DtInsertSubtable (ParentTable, Subtable); 1780 HmatStruct->Length += Subtable->Length; 1781 TgtPDNumber++; 1782 } 1783 HmatLocality->NumberOfTargetPDs = TgtPDNumber; 1784 1785 /* Save start of the entries for reporting errors */ 1786 1787 EntryStart = *PFieldList; 1788 1789 /* Compile latency/bandwidth entries */ 1790 1791 EntryNumber = 0; 1792 while (*PFieldList) 1793 { 1794 Status = DtCompileTable (PFieldList, 1795 AcpiDmTableInfoHmat1c, &Subtable); 1796 if (ACPI_FAILURE (Status)) 1797 { 1798 return (Status); 1799 } 1800 if (!Subtable) 1801 { 1802 break; 1803 } 1804 DtInsertSubtable (ParentTable, Subtable); 1805 HmatStruct->Length += Subtable->Length; 1806 EntryNumber++; 1807 } 1808 1809 /* Validate number of entries */ 1810 1811 if (EntryNumber != 1812 ((UINT64)IntPDNumber * (UINT64)TgtPDNumber)) 1813 { 1814 DtFatal (ASL_MSG_INVALID_EXPRESSION, EntryStart, "HMAT"); 1815 return (AE_ERROR); 1816 } 1817 break; 1818 1819 case ACPI_HMAT_TYPE_CACHE: 1820 1821 /* Compile SMBIOS handles */ 1822 1823 HmatCache = ACPI_SUB_PTR (ACPI_HMAT_CACHE, 1824 Subtable->Buffer, sizeof (ACPI_HMAT_STRUCTURE)); 1825 SMBIOSHandleNumber = 0; 1826 while (*PFieldList) 1827 { 1828 Status = DtCompileTable (PFieldList, 1829 AcpiDmTableInfoHmat2a, &Subtable); 1830 if (ACPI_FAILURE (Status)) 1831 { 1832 return (Status); 1833 } 1834 if (!Subtable) 1835 { 1836 break; 1837 } 1838 DtInsertSubtable (ParentTable, Subtable); 1839 HmatStruct->Length += Subtable->Length; 1840 SMBIOSHandleNumber++; 1841 } 1842 HmatCache->NumberOfSMBIOSHandles = SMBIOSHandleNumber; 1843 break; 1844 1845 default: 1846 1847 break; 1848 } 1849 } 1850 1851 return (AE_OK); 1852 } 1853 1854 1855 /****************************************************************************** 1856 * 1857 * FUNCTION: DtCompileIort 1858 * 1859 * PARAMETERS: List - Current field list pointer 1860 * 1861 * RETURN: Status 1862 * 1863 * DESCRIPTION: Compile IORT. 1864 * 1865 *****************************************************************************/ 1866 1867 ACPI_STATUS 1868 DtCompileIort ( 1869 void **List) 1870 { 1871 ACPI_STATUS Status; 1872 DT_SUBTABLE *Subtable; 1873 DT_SUBTABLE *ParentTable; 1874 DT_FIELD **PFieldList = (DT_FIELD **) List; 1875 DT_FIELD *SubtableStart; 1876 ACPI_TABLE_HEADER *Table; 1877 ACPI_TABLE_IORT *Iort; 1878 ACPI_IORT_NODE *IortNode; 1879 ACPI_IORT_ITS_GROUP *IortItsGroup; 1880 ACPI_IORT_SMMU *IortSmmu; 1881 ACPI_IORT_RMR *IortRmr; 1882 UINT32 NodeNumber; 1883 UINT32 NodeLength; 1884 UINT32 IdMappingNumber; 1885 UINT32 ItsNumber; 1886 UINT32 ContextIrptNumber; 1887 UINT32 PmuIrptNumber; 1888 UINT32 PaddingLength; 1889 UINT8 Revision; 1890 UINT32 RmrCount; 1891 1892 1893 ParentTable = DtPeekSubtable (); 1894 1895 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort, 1896 &Subtable); 1897 if (ACPI_FAILURE (Status)) 1898 { 1899 return (Status); 1900 } 1901 DtInsertSubtable (ParentTable, Subtable); 1902 1903 Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); 1904 Revision = Table->Revision; 1905 1906 /* Both IORT Rev E and E.a have known issues and are not supported */ 1907 1908 if (Revision == 1 || Revision == 2) 1909 { 1910 DtError (ASL_ERROR, ASL_MSG_UNSUPPORTED, NULL, "IORT table revision"); 1911 return (AE_ERROR); 1912 } 1913 1914 /* 1915 * Using ACPI_SUB_PTR, We needn't define a separate structure. Care 1916 * should be taken to avoid accessing ACPI_TABLE_HEADER fields. 1917 */ 1918 Iort = ACPI_SUB_PTR (ACPI_TABLE_IORT, 1919 Subtable->Buffer, sizeof (ACPI_TABLE_HEADER)); 1920 1921 /* 1922 * OptionalPadding - Variable-length data 1923 * (Optional, size = OffsetToNodes - sizeof (ACPI_TABLE_IORT)) 1924 * Optionally allows the generic data types to be used for filling 1925 * this field. 1926 */ 1927 Iort->NodeOffset = sizeof (ACPI_TABLE_IORT); 1928 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortPad, 1929 &Subtable); 1930 if (ACPI_FAILURE (Status)) 1931 { 1932 return (Status); 1933 } 1934 if (Subtable) 1935 { 1936 DtInsertSubtable (ParentTable, Subtable); 1937 Iort->NodeOffset += Subtable->Length; 1938 } 1939 else 1940 { 1941 Status = DtCompileGeneric (ACPI_CAST_PTR (void *, PFieldList), 1942 AcpiDmTableInfoIortHdr[0].Name, &PaddingLength); 1943 if (ACPI_FAILURE (Status)) 1944 { 1945 return (Status); 1946 } 1947 Iort->NodeOffset += PaddingLength; 1948 } 1949 1950 NodeNumber = 0; 1951 while (*PFieldList) 1952 { 1953 SubtableStart = *PFieldList; 1954 if (Revision == 0) 1955 { 1956 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortHdr, 1957 &Subtable); 1958 } 1959 else if (Revision >= 3) 1960 { 1961 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortHdr3, 1962 &Subtable); 1963 } 1964 1965 if (ACPI_FAILURE (Status)) 1966 { 1967 return (Status); 1968 } 1969 1970 DtInsertSubtable (ParentTable, Subtable); 1971 IortNode = ACPI_CAST_PTR (ACPI_IORT_NODE, Subtable->Buffer); 1972 NodeLength = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); 1973 1974 DtPushSubtable (Subtable); 1975 ParentTable = DtPeekSubtable (); 1976 1977 switch (IortNode->Type) 1978 { 1979 case ACPI_IORT_NODE_ITS_GROUP: 1980 1981 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0, 1982 &Subtable); 1983 if (ACPI_FAILURE (Status)) 1984 { 1985 return (Status); 1986 } 1987 1988 DtInsertSubtable (ParentTable, Subtable); 1989 IortItsGroup = ACPI_CAST_PTR (ACPI_IORT_ITS_GROUP, Subtable->Buffer); 1990 NodeLength += Subtable->Length; 1991 1992 ItsNumber = 0; 1993 while (*PFieldList) 1994 { 1995 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort0a, 1996 &Subtable); 1997 if (ACPI_FAILURE (Status)) 1998 { 1999 return (Status); 2000 } 2001 if (!Subtable) 2002 { 2003 break; 2004 } 2005 2006 DtInsertSubtable (ParentTable, Subtable); 2007 NodeLength += Subtable->Length; 2008 ItsNumber++; 2009 } 2010 2011 IortItsGroup->ItsCount = ItsNumber; 2012 break; 2013 2014 case ACPI_IORT_NODE_NAMED_COMPONENT: 2015 2016 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1, 2017 &Subtable); 2018 if (ACPI_FAILURE (Status)) 2019 { 2020 return (Status); 2021 } 2022 2023 DtInsertSubtable (ParentTable, Subtable); 2024 NodeLength += Subtable->Length; 2025 2026 /* 2027 * Padding - Variable-length data 2028 * Optionally allows the offset of the ID mappings to be used 2029 * for filling this field. 2030 */ 2031 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort1a, 2032 &Subtable); 2033 if (ACPI_FAILURE (Status)) 2034 { 2035 return (Status); 2036 } 2037 2038 if (Subtable) 2039 { 2040 DtInsertSubtable (ParentTable, Subtable); 2041 NodeLength += Subtable->Length; 2042 } 2043 else 2044 { 2045 if (NodeLength > IortNode->MappingOffset) 2046 { 2047 return (AE_BAD_DATA); 2048 } 2049 2050 if (NodeLength < IortNode->MappingOffset) 2051 { 2052 Status = DtCompilePadding ( 2053 IortNode->MappingOffset - NodeLength, 2054 &Subtable); 2055 if (ACPI_FAILURE (Status)) 2056 { 2057 return (Status); 2058 } 2059 2060 DtInsertSubtable (ParentTable, Subtable); 2061 NodeLength = IortNode->MappingOffset; 2062 } 2063 } 2064 break; 2065 2066 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: 2067 2068 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort2, 2069 &Subtable); 2070 if (ACPI_FAILURE (Status)) 2071 { 2072 return (Status); 2073 } 2074 2075 DtInsertSubtable (ParentTable, Subtable); 2076 NodeLength += Subtable->Length; 2077 break; 2078 2079 case ACPI_IORT_NODE_SMMU: 2080 2081 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3, 2082 &Subtable); 2083 if (ACPI_FAILURE (Status)) 2084 { 2085 return (Status); 2086 } 2087 2088 DtInsertSubtable (ParentTable, Subtable); 2089 IortSmmu = ACPI_CAST_PTR (ACPI_IORT_SMMU, Subtable->Buffer); 2090 NodeLength += Subtable->Length; 2091 2092 /* Compile global interrupt array */ 2093 2094 IortSmmu->GlobalInterruptOffset = NodeLength; 2095 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3a, 2096 &Subtable); 2097 if (ACPI_FAILURE (Status)) 2098 { 2099 return (Status); 2100 } 2101 2102 DtInsertSubtable (ParentTable, Subtable); 2103 NodeLength += Subtable->Length; 2104 2105 /* Compile context interrupt array */ 2106 2107 ContextIrptNumber = 0; 2108 IortSmmu->ContextInterruptOffset = NodeLength; 2109 while (*PFieldList) 2110 { 2111 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3b, 2112 &Subtable); 2113 if (ACPI_FAILURE (Status)) 2114 { 2115 return (Status); 2116 } 2117 2118 if (!Subtable) 2119 { 2120 break; 2121 } 2122 2123 DtInsertSubtable (ParentTable, Subtable); 2124 NodeLength += Subtable->Length; 2125 ContextIrptNumber++; 2126 } 2127 2128 IortSmmu->ContextInterruptCount = ContextIrptNumber; 2129 2130 /* Compile PMU interrupt array */ 2131 2132 PmuIrptNumber = 0; 2133 IortSmmu->PmuInterruptOffset = NodeLength; 2134 while (*PFieldList) 2135 { 2136 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort3c, 2137 &Subtable); 2138 if (ACPI_FAILURE (Status)) 2139 { 2140 return (Status); 2141 } 2142 2143 if (!Subtable) 2144 { 2145 break; 2146 } 2147 2148 DtInsertSubtable (ParentTable, Subtable); 2149 NodeLength += Subtable->Length; 2150 PmuIrptNumber++; 2151 } 2152 2153 IortSmmu->PmuInterruptCount = PmuIrptNumber; 2154 break; 2155 2156 case ACPI_IORT_NODE_SMMU_V3: 2157 2158 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort4, 2159 &Subtable); 2160 if (ACPI_FAILURE (Status)) 2161 { 2162 return (Status); 2163 } 2164 2165 DtInsertSubtable (ParentTable, Subtable); 2166 NodeLength += Subtable->Length; 2167 break; 2168 2169 case ACPI_IORT_NODE_PMCG: 2170 2171 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort5, 2172 &Subtable); 2173 if (ACPI_FAILURE (Status)) 2174 { 2175 return (Status); 2176 } 2177 2178 DtInsertSubtable (ParentTable, Subtable); 2179 NodeLength += Subtable->Length; 2180 break; 2181 2182 case ACPI_IORT_NODE_RMR: 2183 2184 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort6, 2185 &Subtable); 2186 if (ACPI_FAILURE (Status)) 2187 { 2188 return (Status); 2189 } 2190 2191 DtInsertSubtable (ParentTable, Subtable); 2192 IortRmr = ACPI_CAST_PTR (ACPI_IORT_RMR, Subtable->Buffer); 2193 NodeLength += Subtable->Length; 2194 2195 /* Compile RMR Descriptors */ 2196 2197 RmrCount = 0; 2198 IortRmr->RmrOffset = NodeLength; 2199 while (*PFieldList) 2200 { 2201 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIort6a, 2202 &Subtable); 2203 if (ACPI_FAILURE (Status)) 2204 { 2205 return (Status); 2206 } 2207 2208 if (!Subtable) 2209 { 2210 break; 2211 } 2212 2213 DtInsertSubtable (ParentTable, Subtable); 2214 NodeLength += sizeof (ACPI_IORT_RMR_DESC); 2215 RmrCount++; 2216 } 2217 2218 IortRmr->RmrCount = RmrCount; 2219 break; 2220 2221 default: 2222 2223 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IORT"); 2224 return (AE_ERROR); 2225 } 2226 2227 /* Compile Array of ID mappings */ 2228 2229 IortNode->MappingOffset = NodeLength; 2230 IdMappingNumber = 0; 2231 while (*PFieldList) 2232 { 2233 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIortMap, 2234 &Subtable); 2235 if (ACPI_FAILURE (Status)) 2236 { 2237 return (Status); 2238 } 2239 2240 if (!Subtable) 2241 { 2242 break; 2243 } 2244 2245 DtInsertSubtable (ParentTable, Subtable); 2246 NodeLength += sizeof (ACPI_IORT_ID_MAPPING); 2247 IdMappingNumber++; 2248 } 2249 2250 IortNode->MappingCount = IdMappingNumber; 2251 if (!IdMappingNumber) 2252 { 2253 IortNode->MappingOffset = 0; 2254 } 2255 2256 /* 2257 * Node length can be determined by DT_LENGTH option 2258 * IortNode->Length = NodeLength; 2259 */ 2260 DtPopSubtable (); 2261 ParentTable = DtPeekSubtable (); 2262 NodeNumber++; 2263 } 2264 2265 Iort->NodeCount = NodeNumber; 2266 return (AE_OK); 2267 } 2268 2269 2270 /****************************************************************************** 2271 * 2272 * FUNCTION: DtCompileIvrs 2273 * 2274 * PARAMETERS: List - Current field list pointer 2275 * 2276 * RETURN: Status 2277 * 2278 * DESCRIPTION: Compile IVRS. Notes: 2279 * The IVRS is essentially a flat table, with the following 2280 * structure: 2281 * <Main ACPI Table Header> 2282 * <Main subtable - virtualization info> 2283 * <IVHD> 2284 * <Device Entries> 2285 * ... 2286 * <IVHD> 2287 * <Device Entries> 2288 * <IVMD> 2289 * ... 2290 * 2291 *****************************************************************************/ 2292 2293 ACPI_STATUS 2294 DtCompileIvrs ( 2295 void **List) 2296 { 2297 ACPI_STATUS Status; 2298 DT_SUBTABLE *Subtable; 2299 DT_SUBTABLE *ParentTable; 2300 DT_SUBTABLE *MainSubtable; 2301 DT_FIELD **PFieldList = (DT_FIELD **) List; 2302 DT_FIELD *SubtableStart; 2303 ACPI_DMTABLE_INFO *InfoTable = NULL; 2304 UINT8 SubtableType; 2305 UINT8 Temp64[16]; 2306 UINT8 Temp8; 2307 2308 2309 /* Main table */ 2310 2311 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs, 2312 &Subtable); 2313 if (ACPI_FAILURE (Status)) 2314 { 2315 return (Status); 2316 } 2317 2318 ParentTable = DtPeekSubtable (); 2319 DtInsertSubtable (ParentTable, Subtable); 2320 DtPushSubtable (Subtable); 2321 2322 /* Save a pointer to the main subtable */ 2323 2324 MainSubtable = Subtable; 2325 2326 while (*PFieldList) 2327 { 2328 SubtableStart = *PFieldList; 2329 2330 /* Compile the SubtableType integer */ 2331 2332 DtCompileInteger (&SubtableType, *PFieldList, 1, 0); 2333 2334 switch (SubtableType) 2335 { 2336 2337 /* Type 10h, IVHD (I/O Virtualization Hardware Definition) */ 2338 2339 case ACPI_IVRS_TYPE_HARDWARE1: 2340 2341 InfoTable = AcpiDmTableInfoIvrsHware1; 2342 break; 2343 2344 /* Types 11h, 40h, IVHD (I/O Virtualization Hardware Definition) */ 2345 2346 case ACPI_IVRS_TYPE_HARDWARE2: 2347 case ACPI_IVRS_TYPE_HARDWARE3: 2348 2349 InfoTable = AcpiDmTableInfoIvrsHware23; 2350 break; 2351 2352 /* Types 20h, 21h, 22h, IVMD (I/O Virtualization Memory Definition Block) */ 2353 2354 case ACPI_IVRS_TYPE_MEMORY1: 2355 case ACPI_IVRS_TYPE_MEMORY2: 2356 case ACPI_IVRS_TYPE_MEMORY3: 2357 2358 InfoTable = AcpiDmTableInfoIvrsMemory; 2359 break; 2360 2361 /* 4-byte device entries */ 2362 2363 case ACPI_IVRS_TYPE_PAD4: 2364 case ACPI_IVRS_TYPE_ALL: 2365 case ACPI_IVRS_TYPE_SELECT: 2366 case ACPI_IVRS_TYPE_START: 2367 case ACPI_IVRS_TYPE_END: 2368 2369 InfoTable = AcpiDmTableInfoIvrs4; 2370 break; 2371 2372 /* 8-byte device entries, type A */ 2373 2374 case ACPI_IVRS_TYPE_ALIAS_SELECT: 2375 case ACPI_IVRS_TYPE_ALIAS_START: 2376 2377 InfoTable = AcpiDmTableInfoIvrs8a; 2378 break; 2379 2380 /* 8-byte device entries, type B */ 2381 2382 case ACPI_IVRS_TYPE_EXT_SELECT: 2383 case ACPI_IVRS_TYPE_EXT_START: 2384 2385 InfoTable = AcpiDmTableInfoIvrs8b; 2386 break; 2387 2388 /* 8-byte device entries, type C */ 2389 2390 case ACPI_IVRS_TYPE_SPECIAL: 2391 2392 InfoTable = AcpiDmTableInfoIvrs8c; 2393 break; 2394 2395 /* Variable device entries, type F0h */ 2396 2397 case ACPI_IVRS_TYPE_HID: 2398 2399 InfoTable = AcpiDmTableInfoIvrsHid; 2400 break; 2401 2402 default: 2403 2404 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, 2405 "IVRS Device Entry"); 2406 return (AE_ERROR); 2407 } 2408 2409 /* Compile the InfoTable from above */ 2410 2411 Status = DtCompileTable (PFieldList, InfoTable, 2412 &Subtable); 2413 if (ACPI_FAILURE (Status)) 2414 { 2415 return (Status); 2416 } 2417 2418 ParentTable = DtPeekSubtable (); 2419 if (SubtableType != ACPI_IVRS_TYPE_HARDWARE1 && 2420 SubtableType != ACPI_IVRS_TYPE_HARDWARE2 && 2421 SubtableType != ACPI_IVRS_TYPE_HARDWARE3 && 2422 SubtableType != ACPI_IVRS_TYPE_HID && 2423 SubtableType != ACPI_IVRS_TYPE_MEMORY1 && 2424 SubtableType != ACPI_IVRS_TYPE_MEMORY2 && 2425 SubtableType != ACPI_IVRS_TYPE_MEMORY3) 2426 { 2427 if (ParentTable) 2428 DtInsertSubtable (ParentTable, Subtable); 2429 } 2430 2431 switch (SubtableType) 2432 { 2433 case ACPI_IVRS_TYPE_HARDWARE1: 2434 case ACPI_IVRS_TYPE_HARDWARE2: 2435 case ACPI_IVRS_TYPE_HARDWARE3: 2436 case ACPI_IVRS_TYPE_MEMORY1: 2437 case ACPI_IVRS_TYPE_MEMORY2: 2438 case ACPI_IVRS_TYPE_MEMORY3: 2439 2440 /* Insert these IVHDs/IVMDs at the root subtable */ 2441 2442 DtInsertSubtable (MainSubtable, Subtable); 2443 DtPushSubtable (Subtable); 2444 ParentTable = MainSubtable; 2445 break; 2446 2447 case ACPI_IVRS_TYPE_HID: 2448 2449 /* Special handling for the HID named device entry (0xF0) */ 2450 2451 if (ParentTable) 2452 { 2453 DtInsertSubtable (ParentTable, Subtable); 2454 } 2455 2456 /* 2457 * Process the HID value. First, get the HID value as a string. 2458 */ 2459 DtCompileOneField ((UINT8 *) &Temp64, *PFieldList, 16, DT_FIELD_TYPE_STRING, 0); 2460 2461 /* 2462 * Determine if the HID is an integer or a string. 2463 * An integer is defined to be 32 bits, with the upper 32 bits 2464 * set to zero. (from the ACPI Spec): "The HID can be a 32-bit 2465 * integer or a character string. If an integer, the lower 2466 * 4 bytes of the field contain the integer and the upper 2467 * 4 bytes are padded with 0". 2468 */ 2469 if (UtIsIdInteger ((UINT8 *) &Temp64)) 2470 { 2471 /* Compile the HID value as an integer */ 2472 2473 DtCompileOneField ((UINT8 *) &Temp64, *PFieldList, 8, DT_FIELD_TYPE_INTEGER, 0); 2474 2475 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHidInteger, 2476 &Subtable); 2477 if (ACPI_FAILURE (Status)) 2478 { 2479 return (Status); 2480 } 2481 } 2482 else 2483 { 2484 /* Compile the HID value as a string */ 2485 2486 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHidString, 2487 &Subtable); 2488 if (ACPI_FAILURE (Status)) 2489 { 2490 return (Status); 2491 } 2492 } 2493 2494 DtInsertSubtable (ParentTable, Subtable); 2495 2496 /* 2497 * Process the CID value. First, get the CID value as a string. 2498 */ 2499 DtCompileOneField ((UINT8 *) &Temp64, *PFieldList, 16, DT_FIELD_TYPE_STRING, 0); 2500 2501 if (UtIsIdInteger ((UINT8 *) &Temp64)) 2502 { 2503 /* Compile the CID value as an integer */ 2504 2505 DtCompileOneField ((UINT8 *) &Temp64, *PFieldList, 8, DT_FIELD_TYPE_INTEGER, 0); 2506 2507 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsCidInteger, 2508 &Subtable); 2509 if (ACPI_FAILURE (Status)) 2510 { 2511 return (Status); 2512 } 2513 } 2514 else 2515 { 2516 /* Compile the CID value as a string */ 2517 2518 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsCidString, 2519 &Subtable); 2520 if (ACPI_FAILURE (Status)) 2521 { 2522 return (Status); 2523 } 2524 } 2525 2526 DtInsertSubtable (ParentTable, Subtable); 2527 2528 /* 2529 * Process the UID value. First, get and decode the "UID Format" field (Integer). 2530 */ 2531 if (!*PFieldList) 2532 { 2533 return (AE_OK); 2534 } 2535 2536 DtCompileOneField (&Temp8, *PFieldList, 1, DT_FIELD_TYPE_INTEGER, 0); 2537 2538 switch (Temp8) 2539 { 2540 case ACPI_IVRS_UID_NOT_PRESENT: 2541 break; 2542 2543 case ACPI_IVRS_UID_IS_INTEGER: 2544 2545 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsUidInteger, 2546 &Subtable); 2547 if (ACPI_FAILURE (Status)) 2548 { 2549 return (Status); 2550 } 2551 DtInsertSubtable (ParentTable, Subtable); 2552 break; 2553 2554 case ACPI_IVRS_UID_IS_STRING: 2555 2556 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsUidString, 2557 &Subtable); 2558 if (ACPI_FAILURE (Status)) 2559 { 2560 return (Status); 2561 } 2562 DtInsertSubtable (ParentTable, Subtable); 2563 break; 2564 2565 default: 2566 2567 DtFatal (ASL_MSG_UNKNOWN_FORMAT, SubtableStart, 2568 "IVRS Device Entry"); 2569 return (AE_ERROR); 2570 } 2571 2572 default: 2573 2574 /* All other subtable types come through here */ 2575 break; 2576 } 2577 } 2578 2579 return (AE_OK); 2580 } 2581