1 /****************************************************************************** 2 * 3 * Module Name: dttable2.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 L-Z */ 153 154 #include "aslcompiler.h" 155 156 #define _COMPONENT DT_COMPILER 157 ACPI_MODULE_NAME ("dttable2") 158 159 160 /****************************************************************************** 161 * 162 * FUNCTION: DtCompileLpit 163 * 164 * PARAMETERS: List - Current field list pointer 165 * 166 * RETURN: Status 167 * 168 * DESCRIPTION: Compile LPIT. 169 * 170 *****************************************************************************/ 171 172 ACPI_STATUS 173 DtCompileLpit ( 174 void **List) 175 { 176 ACPI_STATUS Status; 177 DT_SUBTABLE *Subtable; 178 DT_SUBTABLE *ParentTable; 179 DT_FIELD **PFieldList = (DT_FIELD **) List; 180 DT_FIELD *SubtableStart; 181 ACPI_DMTABLE_INFO *InfoTable; 182 ACPI_LPIT_HEADER *LpitHeader; 183 184 185 /* Note: Main table consists only of the standard ACPI table header */ 186 187 while (*PFieldList) 188 { 189 SubtableStart = *PFieldList; 190 191 /* LPIT Subtable header */ 192 193 Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr, 194 &Subtable); 195 if (ACPI_FAILURE (Status)) 196 { 197 return (Status); 198 } 199 200 ParentTable = DtPeekSubtable (); 201 DtInsertSubtable (ParentTable, Subtable); 202 DtPushSubtable (Subtable); 203 204 LpitHeader = ACPI_CAST_PTR (ACPI_LPIT_HEADER, Subtable->Buffer); 205 206 switch (LpitHeader->Type) 207 { 208 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 209 210 InfoTable = AcpiDmTableInfoLpit0; 211 break; 212 213 default: 214 215 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "LPIT"); 216 return (AE_ERROR); 217 } 218 219 /* LPIT Subtable */ 220 221 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 222 if (ACPI_FAILURE (Status)) 223 { 224 return (Status); 225 } 226 227 ParentTable = DtPeekSubtable (); 228 DtInsertSubtable (ParentTable, Subtable); 229 DtPopSubtable (); 230 } 231 232 return (AE_OK); 233 } 234 235 236 /****************************************************************************** 237 * 238 * FUNCTION: DtCompileMadt 239 * 240 * PARAMETERS: List - Current field list pointer 241 * 242 * RETURN: Status 243 * 244 * DESCRIPTION: Compile MADT. 245 * 246 *****************************************************************************/ 247 248 ACPI_STATUS 249 DtCompileMadt ( 250 void **List) 251 { 252 ACPI_STATUS Status; 253 DT_SUBTABLE *Subtable; 254 DT_SUBTABLE *ParentTable; 255 DT_FIELD **PFieldList = (DT_FIELD **) List; 256 DT_FIELD *SubtableStart; 257 ACPI_SUBTABLE_HEADER *MadtHeader; 258 ACPI_DMTABLE_INFO *InfoTable; 259 260 261 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt, 262 &Subtable); 263 if (ACPI_FAILURE (Status)) 264 { 265 return (Status); 266 } 267 268 ParentTable = DtPeekSubtable (); 269 DtInsertSubtable (ParentTable, Subtable); 270 271 while (*PFieldList) 272 { 273 SubtableStart = *PFieldList; 274 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr, 275 &Subtable); 276 if (ACPI_FAILURE (Status)) 277 { 278 return (Status); 279 } 280 281 ParentTable = DtPeekSubtable (); 282 DtInsertSubtable (ParentTable, Subtable); 283 DtPushSubtable (Subtable); 284 285 MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 286 287 switch (MadtHeader->Type) 288 { 289 case ACPI_MADT_TYPE_LOCAL_APIC: 290 291 InfoTable = AcpiDmTableInfoMadt0; 292 break; 293 294 case ACPI_MADT_TYPE_IO_APIC: 295 296 InfoTable = AcpiDmTableInfoMadt1; 297 break; 298 299 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 300 301 InfoTable = AcpiDmTableInfoMadt2; 302 break; 303 304 case ACPI_MADT_TYPE_NMI_SOURCE: 305 306 InfoTable = AcpiDmTableInfoMadt3; 307 break; 308 309 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 310 311 InfoTable = AcpiDmTableInfoMadt4; 312 break; 313 314 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 315 316 InfoTable = AcpiDmTableInfoMadt5; 317 break; 318 319 case ACPI_MADT_TYPE_IO_SAPIC: 320 321 InfoTable = AcpiDmTableInfoMadt6; 322 break; 323 324 case ACPI_MADT_TYPE_LOCAL_SAPIC: 325 326 InfoTable = AcpiDmTableInfoMadt7; 327 break; 328 329 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 330 331 InfoTable = AcpiDmTableInfoMadt8; 332 break; 333 334 case ACPI_MADT_TYPE_LOCAL_X2APIC: 335 336 InfoTable = AcpiDmTableInfoMadt9; 337 break; 338 339 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 340 341 InfoTable = AcpiDmTableInfoMadt10; 342 break; 343 344 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 345 346 InfoTable = AcpiDmTableInfoMadt11; 347 break; 348 349 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 350 351 InfoTable = AcpiDmTableInfoMadt12; 352 break; 353 354 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 355 356 InfoTable = AcpiDmTableInfoMadt13; 357 break; 358 359 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 360 361 InfoTable = AcpiDmTableInfoMadt14; 362 break; 363 364 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 365 366 InfoTable = AcpiDmTableInfoMadt15; 367 break; 368 369 case ACPI_MADT_TYPE_MULTIPROC_WAKEUP: 370 371 InfoTable = AcpiDmTableInfoMadt16; 372 break; 373 374 default: 375 376 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT"); 377 return (AE_ERROR); 378 } 379 380 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 381 if (ACPI_FAILURE (Status)) 382 { 383 return (Status); 384 } 385 386 ParentTable = DtPeekSubtable (); 387 DtInsertSubtable (ParentTable, Subtable); 388 DtPopSubtable (); 389 } 390 391 return (AE_OK); 392 } 393 394 395 /****************************************************************************** 396 * 397 * FUNCTION: DtCompileMcfg 398 * 399 * PARAMETERS: List - Current field list pointer 400 * 401 * RETURN: Status 402 * 403 * DESCRIPTION: Compile MCFG. 404 * 405 *****************************************************************************/ 406 407 ACPI_STATUS 408 DtCompileMcfg ( 409 void **List) 410 { 411 ACPI_STATUS Status; 412 413 414 Status = DtCompileTwoSubtables (List, 415 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0); 416 return (Status); 417 } 418 419 420 /****************************************************************************** 421 * 422 * FUNCTION: DtCompileMpst 423 * 424 * PARAMETERS: List - Current field list pointer 425 * 426 * RETURN: Status 427 * 428 * DESCRIPTION: Compile MPST. 429 * 430 *****************************************************************************/ 431 432 ACPI_STATUS 433 DtCompileMpst ( 434 void **List) 435 { 436 ACPI_STATUS Status; 437 DT_SUBTABLE *Subtable; 438 DT_SUBTABLE *ParentTable; 439 DT_FIELD **PFieldList = (DT_FIELD **) List; 440 ACPI_MPST_CHANNEL *MpstChannelInfo; 441 ACPI_MPST_POWER_NODE *MpstPowerNode; 442 ACPI_MPST_DATA_HDR *MpstDataHeader; 443 UINT16 SubtableCount; 444 UINT32 PowerStateCount; 445 UINT32 ComponentCount; 446 447 448 /* Main table */ 449 450 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable); 451 if (ACPI_FAILURE (Status)) 452 { 453 return (Status); 454 } 455 456 ParentTable = DtPeekSubtable (); 457 DtInsertSubtable (ParentTable, Subtable); 458 DtPushSubtable (Subtable); 459 460 MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer); 461 SubtableCount = MpstChannelInfo->PowerNodeCount; 462 463 while (*PFieldList && SubtableCount) 464 { 465 /* Subtable: Memory Power Node(s) */ 466 467 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0, 468 &Subtable); 469 if (ACPI_FAILURE (Status)) 470 { 471 return (Status); 472 } 473 474 ParentTable = DtPeekSubtable (); 475 DtInsertSubtable (ParentTable, Subtable); 476 DtPushSubtable (Subtable); 477 478 MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer); 479 PowerStateCount = MpstPowerNode->NumPowerStates; 480 ComponentCount = MpstPowerNode->NumPhysicalComponents; 481 482 ParentTable = DtPeekSubtable (); 483 484 /* Sub-subtables - Memory Power State Structure(s) */ 485 486 while (*PFieldList && PowerStateCount) 487 { 488 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A, 489 &Subtable); 490 if (ACPI_FAILURE (Status)) 491 { 492 return (Status); 493 } 494 495 DtInsertSubtable (ParentTable, Subtable); 496 PowerStateCount--; 497 } 498 499 /* Sub-subtables - Physical Component ID Structure(s) */ 500 501 while (*PFieldList && ComponentCount) 502 { 503 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B, 504 &Subtable); 505 if (ACPI_FAILURE (Status)) 506 { 507 return (Status); 508 } 509 510 DtInsertSubtable (ParentTable, Subtable); 511 ComponentCount--; 512 } 513 514 SubtableCount--; 515 DtPopSubtable (); 516 } 517 518 /* Subtable: Count of Memory Power State Characteristic structures */ 519 520 DtPopSubtable (); 521 522 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable); 523 if (ACPI_FAILURE (Status)) 524 { 525 return (Status); 526 } 527 528 ParentTable = DtPeekSubtable (); 529 DtInsertSubtable (ParentTable, Subtable); 530 DtPushSubtable (Subtable); 531 532 MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer); 533 SubtableCount = MpstDataHeader->CharacteristicsCount; 534 535 ParentTable = DtPeekSubtable (); 536 537 /* Subtable: Memory Power State Characteristics structure(s) */ 538 539 while (*PFieldList && SubtableCount) 540 { 541 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2, 542 &Subtable); 543 if (ACPI_FAILURE (Status)) 544 { 545 return (Status); 546 } 547 548 DtInsertSubtable (ParentTable, Subtable); 549 SubtableCount--; 550 } 551 552 DtPopSubtable (); 553 return (AE_OK); 554 } 555 556 557 /****************************************************************************** 558 * 559 * FUNCTION: DtCompileMsct 560 * 561 * PARAMETERS: List - Current field list pointer 562 * 563 * RETURN: Status 564 * 565 * DESCRIPTION: Compile MSCT. 566 * 567 *****************************************************************************/ 568 569 ACPI_STATUS 570 DtCompileMsct ( 571 void **List) 572 { 573 ACPI_STATUS Status; 574 575 576 Status = DtCompileTwoSubtables (List, 577 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0); 578 return (Status); 579 } 580 581 582 /****************************************************************************** 583 * 584 * FUNCTION: DtCompileNfit 585 * 586 * PARAMETERS: List - Current field list pointer 587 * 588 * RETURN: Status 589 * 590 * DESCRIPTION: Compile NFIT. 591 * 592 *****************************************************************************/ 593 594 ACPI_STATUS 595 DtCompileNfit ( 596 void **List) 597 { 598 ACPI_STATUS Status; 599 DT_SUBTABLE *Subtable; 600 DT_SUBTABLE *ParentTable; 601 DT_FIELD **PFieldList = (DT_FIELD **) List; 602 DT_FIELD *SubtableStart; 603 ACPI_NFIT_HEADER *NfitHeader; 604 ACPI_DMTABLE_INFO *InfoTable; 605 UINT32 Count; 606 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 607 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 608 609 610 /* Main table */ 611 612 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit, 613 &Subtable); 614 if (ACPI_FAILURE (Status)) 615 { 616 return (Status); 617 } 618 619 ParentTable = DtPeekSubtable (); 620 DtInsertSubtable (ParentTable, Subtable); 621 DtPushSubtable (Subtable); 622 623 /* Subtables */ 624 625 while (*PFieldList) 626 { 627 SubtableStart = *PFieldList; 628 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr, 629 &Subtable); 630 if (ACPI_FAILURE (Status)) 631 { 632 return (Status); 633 } 634 635 ParentTable = DtPeekSubtable (); 636 DtInsertSubtable (ParentTable, Subtable); 637 DtPushSubtable (Subtable); 638 639 NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer); 640 641 switch (NfitHeader->Type) 642 { 643 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 644 645 InfoTable = AcpiDmTableInfoNfit0; 646 break; 647 648 case ACPI_NFIT_TYPE_MEMORY_MAP: 649 650 InfoTable = AcpiDmTableInfoNfit1; 651 break; 652 653 case ACPI_NFIT_TYPE_INTERLEAVE: 654 655 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer); 656 InfoTable = AcpiDmTableInfoNfit2; 657 break; 658 659 case ACPI_NFIT_TYPE_SMBIOS: 660 661 InfoTable = AcpiDmTableInfoNfit3; 662 break; 663 664 case ACPI_NFIT_TYPE_CONTROL_REGION: 665 666 InfoTable = AcpiDmTableInfoNfit4; 667 break; 668 669 case ACPI_NFIT_TYPE_DATA_REGION: 670 671 InfoTable = AcpiDmTableInfoNfit5; 672 break; 673 674 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 675 676 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer); 677 InfoTable = AcpiDmTableInfoNfit6; 678 break; 679 680 case ACPI_NFIT_TYPE_CAPABILITIES: 681 682 InfoTable = AcpiDmTableInfoNfit7; 683 break; 684 685 default: 686 687 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT"); 688 return (AE_ERROR); 689 } 690 691 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 692 if (ACPI_FAILURE (Status)) 693 { 694 return (Status); 695 } 696 697 ParentTable = DtPeekSubtable (); 698 DtInsertSubtable (ParentTable, Subtable); 699 DtPopSubtable (); 700 701 switch (NfitHeader->Type) 702 { 703 case ACPI_NFIT_TYPE_INTERLEAVE: 704 705 Count = 0; 706 DtPushSubtable (Subtable); 707 while (*PFieldList) 708 { 709 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a, 710 &Subtable); 711 if (ACPI_FAILURE (Status)) 712 { 713 return (Status); 714 } 715 716 if (!Subtable) 717 { 718 DtPopSubtable (); 719 break; 720 } 721 722 ParentTable = DtPeekSubtable (); 723 DtInsertSubtable (ParentTable, Subtable); 724 Count++; 725 } 726 727 Interleave->LineCount = Count; 728 break; 729 730 case ACPI_NFIT_TYPE_SMBIOS: 731 732 if (*PFieldList) 733 { 734 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a, 735 &Subtable); 736 if (ACPI_FAILURE (Status)) 737 { 738 return (Status); 739 } 740 741 if (Subtable) 742 { 743 DtInsertSubtable (ParentTable, Subtable); 744 } 745 } 746 break; 747 748 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 749 750 Count = 0; 751 DtPushSubtable (Subtable); 752 while (*PFieldList) 753 { 754 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a, 755 &Subtable); 756 if (ACPI_FAILURE (Status)) 757 { 758 return (Status); 759 } 760 761 if (!Subtable) 762 { 763 DtPopSubtable (); 764 break; 765 } 766 767 ParentTable = DtPeekSubtable (); 768 DtInsertSubtable (ParentTable, Subtable); 769 Count++; 770 } 771 772 Hint->HintCount = (UINT16) Count; 773 break; 774 775 default: 776 break; 777 } 778 } 779 780 return (AE_OK); 781 } 782 783 784 /****************************************************************************** 785 * 786 * FUNCTION: DtCompilePcct 787 * 788 * PARAMETERS: List - Current field list pointer 789 * 790 * RETURN: Status 791 * 792 * DESCRIPTION: Compile PCCT. 793 * 794 *****************************************************************************/ 795 796 ACPI_STATUS 797 DtCompilePcct ( 798 void **List) 799 { 800 ACPI_STATUS Status; 801 DT_SUBTABLE *Subtable; 802 DT_SUBTABLE *ParentTable; 803 DT_FIELD **PFieldList = (DT_FIELD **) List; 804 DT_FIELD *SubtableStart; 805 ACPI_SUBTABLE_HEADER *PcctHeader; 806 ACPI_DMTABLE_INFO *InfoTable; 807 808 809 /* Main table */ 810 811 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct, 812 &Subtable); 813 if (ACPI_FAILURE (Status)) 814 { 815 return (Status); 816 } 817 818 ParentTable = DtPeekSubtable (); 819 DtInsertSubtable (ParentTable, Subtable); 820 821 /* Subtables */ 822 823 while (*PFieldList) 824 { 825 SubtableStart = *PFieldList; 826 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr, 827 &Subtable); 828 if (ACPI_FAILURE (Status)) 829 { 830 return (Status); 831 } 832 833 ParentTable = DtPeekSubtable (); 834 DtInsertSubtable (ParentTable, Subtable); 835 DtPushSubtable (Subtable); 836 837 PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 838 839 switch (PcctHeader->Type) 840 { 841 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 842 843 InfoTable = AcpiDmTableInfoPcct0; 844 break; 845 846 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 847 848 InfoTable = AcpiDmTableInfoPcct1; 849 break; 850 851 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 852 853 InfoTable = AcpiDmTableInfoPcct2; 854 break; 855 856 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 857 858 InfoTable = AcpiDmTableInfoPcct3; 859 break; 860 861 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 862 863 InfoTable = AcpiDmTableInfoPcct4; 864 break; 865 866 case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE: 867 868 InfoTable = AcpiDmTableInfoPcct5; 869 break; 870 871 default: 872 873 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT"); 874 return (AE_ERROR); 875 } 876 877 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 878 if (ACPI_FAILURE (Status)) 879 { 880 return (Status); 881 } 882 883 ParentTable = DtPeekSubtable (); 884 DtInsertSubtable (ParentTable, Subtable); 885 DtPopSubtable (); 886 } 887 888 return (AE_OK); 889 } 890 891 892 /****************************************************************************** 893 * 894 * FUNCTION: DtCompilePdtt 895 * 896 * PARAMETERS: List - Current field list pointer 897 * 898 * RETURN: Status 899 * 900 * DESCRIPTION: Compile PDTT. 901 * 902 *****************************************************************************/ 903 904 ACPI_STATUS 905 DtCompilePdtt ( 906 void **List) 907 { 908 ACPI_STATUS Status; 909 DT_SUBTABLE *Subtable; 910 DT_SUBTABLE *ParentTable; 911 DT_FIELD **PFieldList = (DT_FIELD **) List; 912 ACPI_TABLE_PDTT *PdttHeader; 913 UINT32 Count = 0; 914 915 916 /* Main table */ 917 918 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt, &Subtable); 919 if (ACPI_FAILURE (Status)) 920 { 921 return (Status); 922 } 923 924 ParentTable = DtPeekSubtable (); 925 DtInsertSubtable (ParentTable, Subtable); 926 927 PdttHeader = ACPI_CAST_PTR (ACPI_TABLE_PDTT, ParentTable->Buffer); 928 PdttHeader->ArrayOffset = sizeof (ACPI_TABLE_PDTT); 929 930 /* There is only one type of subtable at this time, no need to decode */ 931 932 while (*PFieldList) 933 { 934 /* List of subchannel IDs, each 2 bytes */ 935 936 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt0, 937 &Subtable); 938 if (ACPI_FAILURE (Status)) 939 { 940 return (Status); 941 } 942 943 DtInsertSubtable (ParentTable, Subtable); 944 Count++; 945 } 946 947 PdttHeader->TriggerCount = (UINT8) Count; 948 return (AE_OK); 949 } 950 951 952 /****************************************************************************** 953 * 954 * FUNCTION: DtCompilePhat 955 * 956 * PARAMETERS: List - Current field list pointer 957 * 958 * RETURN: Status 959 * 960 * DESCRIPTION: Compile Phat. 961 * 962 *****************************************************************************/ 963 964 ACPI_STATUS 965 DtCompilePhat ( 966 void **List) 967 { 968 ACPI_STATUS Status = AE_OK; 969 DT_SUBTABLE *Subtable; 970 DT_SUBTABLE *ParentTable; 971 DT_FIELD **PFieldList = (DT_FIELD **) List; 972 ACPI_PHAT_HEADER *PhatHeader; 973 ACPI_DMTABLE_INFO *Info; 974 ACPI_PHAT_VERSION_DATA *VersionData; 975 UINT32 RecordCount; 976 977 978 /* The table consist of subtables */ 979 980 while (*PFieldList) 981 { 982 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPhatHdr, &Subtable); 983 if (ACPI_FAILURE (Status)) 984 { 985 return (Status); 986 } 987 988 ParentTable = DtPeekSubtable (); 989 DtInsertSubtable (ParentTable, Subtable); 990 DtPushSubtable (Subtable); 991 992 PhatHeader = ACPI_CAST_PTR (ACPI_PHAT_HEADER, Subtable->Buffer); 993 994 switch (PhatHeader->Type) 995 { 996 case ACPI_PHAT_TYPE_FW_VERSION_DATA: 997 998 Info = AcpiDmTableInfoPhat0; 999 PhatHeader->Length = sizeof (ACPI_PHAT_VERSION_DATA); 1000 break; 1001 1002 case ACPI_PHAT_TYPE_FW_HEALTH_DATA: 1003 1004 Info = AcpiDmTableInfoPhat1; 1005 PhatHeader->Length = sizeof (ACPI_PHAT_HEALTH_DATA); 1006 break; 1007 1008 default: 1009 1010 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, *PFieldList, "PHAT"); 1011 return (AE_ERROR); 1012 1013 break; 1014 } 1015 1016 Status = DtCompileTable (PFieldList, Info, &Subtable); 1017 if (ACPI_FAILURE (Status)) 1018 { 1019 return (Status); 1020 } 1021 1022 ParentTable = DtPeekSubtable (); 1023 DtInsertSubtable (ParentTable, Subtable); 1024 1025 switch (PhatHeader->Type) 1026 { 1027 case ACPI_PHAT_TYPE_FW_VERSION_DATA: 1028 1029 VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, 1030 (Subtable->Buffer - sizeof (ACPI_PHAT_HEADER))); 1031 RecordCount = VersionData->ElementCount; 1032 1033 while (RecordCount) 1034 { 1035 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPhat0a, 1036 &Subtable); 1037 if (ACPI_FAILURE (Status)) 1038 { 1039 return (Status); 1040 } 1041 ParentTable = DtPeekSubtable (); 1042 DtInsertSubtable (ParentTable, Subtable); 1043 1044 RecordCount--; 1045 PhatHeader->Length += sizeof (ACPI_PHAT_VERSION_ELEMENT); 1046 } 1047 break; 1048 1049 case ACPI_PHAT_TYPE_FW_HEALTH_DATA: 1050 1051 /* Compile device path */ 1052 1053 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPhat1a, &Subtable); 1054 if (ACPI_FAILURE (Status)) 1055 { 1056 return (Status); 1057 } 1058 ParentTable = DtPeekSubtable (); 1059 DtInsertSubtable (ParentTable, Subtable); 1060 1061 PhatHeader->Length += (UINT16) Subtable->Length; 1062 1063 /* Compile vendor specific data */ 1064 1065 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPhat1b, &Subtable); 1066 if (ACPI_FAILURE (Status)) 1067 { 1068 return (Status); 1069 } 1070 ParentTable = DtPeekSubtable (); 1071 DtInsertSubtable (ParentTable, Subtable); 1072 1073 PhatHeader->Length += (UINT16) Subtable->Length; 1074 1075 break; 1076 1077 default: 1078 1079 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, *PFieldList, "PHAT"); 1080 return (AE_ERROR); 1081 } 1082 } 1083 1084 return (Status); 1085 } 1086 1087 1088 /****************************************************************************** 1089 * 1090 * FUNCTION: DtCompilePmtt 1091 * 1092 * PARAMETERS: List - Current field list pointer 1093 * 1094 * RETURN: Status 1095 * 1096 * DESCRIPTION: Compile PMTT. 1097 * 1098 *****************************************************************************/ 1099 1100 ACPI_STATUS 1101 DtCompilePmtt ( 1102 void **List) 1103 { 1104 ACPI_STATUS Status; 1105 DT_SUBTABLE *Subtable; 1106 DT_SUBTABLE *ParentTable; 1107 DT_FIELD **PFieldList = (DT_FIELD **) List; 1108 DT_FIELD *SubtableStart; 1109 UINT16 Type; 1110 1111 1112 /* Main table */ 1113 1114 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable); 1115 if (ACPI_FAILURE (Status)) 1116 { 1117 return (Status); 1118 } 1119 1120 ParentTable = DtPeekSubtable (); 1121 DtInsertSubtable (ParentTable, Subtable); 1122 DtPushSubtable (Subtable); 1123 1124 /* Subtables */ 1125 1126 while (*PFieldList) 1127 { 1128 SubtableStart = *PFieldList; 1129 DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0); 1130 1131 switch (Type) 1132 { 1133 case ACPI_PMTT_TYPE_SOCKET: 1134 1135 /* Subtable: Socket Structure */ 1136 1137 DbgPrint (ASL_DEBUG_OUTPUT, "Compile PMTT_TYPE_SOCKET (0)\n"); 1138 1139 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0, 1140 &Subtable); 1141 if (ACPI_FAILURE (Status)) 1142 { 1143 return (Status); 1144 } 1145 1146 break; 1147 1148 case ACPI_PMTT_TYPE_CONTROLLER: 1149 1150 /* Subtable: Memory Controller Structure */ 1151 1152 DbgPrint (ASL_DEBUG_OUTPUT, "Compile PMTT_TYPE_CONTROLLER (1)\n"); 1153 1154 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1, 1155 &Subtable); 1156 if (ACPI_FAILURE (Status)) 1157 { 1158 return (Status); 1159 } 1160 1161 break; 1162 1163 case ACPI_PMTT_TYPE_DIMM: 1164 1165 /* Subtable: Physical Component (DIMM) Structure */ 1166 1167 DbgPrint (ASL_DEBUG_OUTPUT, "Compile PMTT_TYPE_DIMM (2)\n"); 1168 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2, 1169 &Subtable); 1170 if (ACPI_FAILURE (Status)) 1171 { 1172 return (Status); 1173 } 1174 1175 break; 1176 1177 case ACPI_PMTT_TYPE_VENDOR: 1178 1179 /* Subtable: Vendor-specific Structure */ 1180 1181 DbgPrint (ASL_DEBUG_OUTPUT, "Compile PMTT_TYPE_VENDOR(FF)\n"); 1182 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttVendor, 1183 &Subtable); 1184 if (ACPI_FAILURE (Status)) 1185 { 1186 return (Status); 1187 } 1188 1189 break; 1190 1191 default: 1192 1193 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT"); 1194 return (AE_ERROR); 1195 } 1196 1197 DtInsertSubtable (ParentTable, Subtable); 1198 } 1199 1200 return (Status); 1201 } 1202 1203 1204 /****************************************************************************** 1205 * 1206 * FUNCTION: DtCompilePptt 1207 * 1208 * PARAMETERS: List - Current field list pointer 1209 * 1210 * RETURN: Status 1211 * 1212 * DESCRIPTION: Compile PPTT. 1213 * 1214 *****************************************************************************/ 1215 1216 ACPI_STATUS 1217 DtCompilePptt ( 1218 void **List) 1219 { 1220 ACPI_STATUS Status; 1221 ACPI_SUBTABLE_HEADER *PpttHeader; 1222 ACPI_PPTT_PROCESSOR *PpttProcessor = NULL; 1223 DT_SUBTABLE *Subtable; 1224 DT_SUBTABLE *ParentTable; 1225 ACPI_DMTABLE_INFO *InfoTable; 1226 DT_FIELD **PFieldList = (DT_FIELD **) List; 1227 DT_FIELD *SubtableStart; 1228 ACPI_TABLE_HEADER *PpttAcpiHeader; 1229 1230 1231 ParentTable = DtPeekSubtable (); 1232 while (*PFieldList) 1233 { 1234 SubtableStart = *PFieldList; 1235 1236 /* Compile PPTT subtable header */ 1237 1238 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPpttHdr, 1239 &Subtable); 1240 if (ACPI_FAILURE (Status)) 1241 { 1242 return (Status); 1243 } 1244 DtInsertSubtable (ParentTable, Subtable); 1245 PpttHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1246 PpttHeader->Length = (UINT8)(Subtable->Length); 1247 1248 switch (PpttHeader->Type) 1249 { 1250 case ACPI_PPTT_TYPE_PROCESSOR: 1251 1252 InfoTable = AcpiDmTableInfoPptt0; 1253 break; 1254 1255 case ACPI_PPTT_TYPE_CACHE: 1256 1257 InfoTable = AcpiDmTableInfoPptt1; 1258 break; 1259 1260 case ACPI_PPTT_TYPE_ID: 1261 1262 InfoTable = AcpiDmTableInfoPptt2; 1263 break; 1264 1265 default: 1266 1267 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PPTT"); 1268 return (AE_ERROR); 1269 } 1270 1271 /* Compile PPTT subtable body */ 1272 1273 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1274 if (ACPI_FAILURE (Status)) 1275 { 1276 return (Status); 1277 } 1278 DtInsertSubtable (ParentTable, Subtable); 1279 PpttHeader->Length += (UINT8)(Subtable->Length); 1280 1281 /* Compile PPTT subtable additionals */ 1282 1283 switch (PpttHeader->Type) 1284 { 1285 case ACPI_PPTT_TYPE_PROCESSOR: 1286 1287 PpttProcessor = ACPI_SUB_PTR (ACPI_PPTT_PROCESSOR, 1288 Subtable->Buffer, sizeof (ACPI_SUBTABLE_HEADER)); 1289 if (PpttProcessor) 1290 { 1291 /* Compile initiator proximity domain list */ 1292 1293 PpttProcessor->NumberOfPrivResources = 0; 1294 while (*PFieldList) 1295 { 1296 Status = DtCompileTable (PFieldList, 1297 AcpiDmTableInfoPptt0a, &Subtable); 1298 if (ACPI_FAILURE (Status)) 1299 { 1300 return (Status); 1301 } 1302 if (!Subtable) 1303 { 1304 break; 1305 } 1306 1307 DtInsertSubtable (ParentTable, Subtable); 1308 PpttHeader->Length += (UINT8)(Subtable->Length); 1309 PpttProcessor->NumberOfPrivResources++; 1310 } 1311 } 1312 break; 1313 1314 case ACPI_PPTT_TYPE_CACHE: 1315 1316 PpttAcpiHeader = ACPI_CAST_PTR (ACPI_TABLE_HEADER, 1317 AslGbl_RootTable->Buffer); 1318 if (PpttAcpiHeader->Revision < 3) 1319 { 1320 break; 1321 } 1322 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPptt1a, 1323 &Subtable); 1324 DtInsertSubtable (ParentTable, Subtable); 1325 PpttHeader->Length += (UINT8)(Subtable->Length); 1326 break; 1327 1328 default: 1329 1330 break; 1331 } 1332 } 1333 1334 return (AE_OK); 1335 } 1336 1337 1338 /****************************************************************************** 1339 * 1340 * FUNCTION: DtCompilePrmt 1341 * 1342 * PARAMETERS: List - Current field list pointer 1343 * 1344 * RETURN: Status 1345 * 1346 * DESCRIPTION: Compile PRMT. 1347 * 1348 *****************************************************************************/ 1349 1350 ACPI_STATUS 1351 DtCompilePrmt ( 1352 void **List) 1353 { 1354 ACPI_STATUS Status; 1355 ACPI_TABLE_PRMT_HEADER *PrmtHeader; 1356 ACPI_PRMT_MODULE_INFO *PrmtModuleInfo; 1357 DT_SUBTABLE *Subtable; 1358 DT_SUBTABLE *ParentTable; 1359 DT_FIELD **PFieldList = (DT_FIELD **) List; 1360 UINT32 i, j; 1361 1362 ParentTable = DtPeekSubtable (); 1363 1364 /* Compile PRMT subtable header */ 1365 1366 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPrmtHdr, 1367 &Subtable); 1368 if (ACPI_FAILURE (Status)) 1369 { 1370 return (Status); 1371 } 1372 DtInsertSubtable (ParentTable, Subtable); 1373 PrmtHeader = ACPI_CAST_PTR (ACPI_TABLE_PRMT_HEADER, Subtable->Buffer); 1374 1375 for (i = 0; i < PrmtHeader->ModuleInfoCount; i++) 1376 { 1377 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPrmtModule, 1378 &Subtable); 1379 if (ACPI_FAILURE (Status)) 1380 { 1381 return (Status); 1382 } 1383 DtInsertSubtable (ParentTable, Subtable); 1384 PrmtModuleInfo = ACPI_CAST_PTR (ACPI_PRMT_MODULE_INFO, Subtable->Buffer); 1385 1386 for (j = 0; j < PrmtModuleInfo->HandlerInfoCount; j++) 1387 { 1388 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPrmtHandler, 1389 &Subtable); 1390 if (ACPI_FAILURE (Status)) 1391 { 1392 return (Status); 1393 } 1394 DtInsertSubtable (ParentTable, Subtable); 1395 } 1396 } 1397 1398 return (AE_OK); 1399 } 1400 1401 1402 /****************************************************************************** 1403 * 1404 * FUNCTION: DtCompileRgrt 1405 * 1406 * PARAMETERS: List - Current field list pointer 1407 * 1408 * RETURN: Status 1409 * 1410 * DESCRIPTION: Compile RGRT. 1411 * 1412 *****************************************************************************/ 1413 1414 ACPI_STATUS 1415 DtCompileRgrt ( 1416 void **List) 1417 { 1418 ACPI_STATUS Status; 1419 DT_SUBTABLE *Subtable; 1420 DT_SUBTABLE *ParentTable; 1421 DT_FIELD **PFieldList = (DT_FIELD **) List; 1422 1423 1424 /* Compile the main table */ 1425 1426 Status = DtCompileTable (PFieldList, AcpiDmTableInfoRgrt, 1427 &Subtable); 1428 if (ACPI_FAILURE (Status)) 1429 { 1430 return (Status); 1431 } 1432 1433 ParentTable = DtPeekSubtable (); 1434 DtInsertSubtable (ParentTable, Subtable); 1435 1436 /* Compile the "Subtable" -- actually just the binary (PNG) image */ 1437 1438 Status = DtCompileTable (PFieldList, AcpiDmTableInfoRgrt0, 1439 &Subtable); 1440 if (ACPI_FAILURE (Status)) 1441 { 1442 return (Status); 1443 } 1444 1445 DtInsertSubtable (ParentTable, Subtable); 1446 return (AE_OK); 1447 } 1448 1449 1450 /****************************************************************************** 1451 * 1452 * FUNCTION: DtCompileRsdt 1453 * 1454 * PARAMETERS: List - Current field list pointer 1455 * 1456 * RETURN: Status 1457 * 1458 * DESCRIPTION: Compile RSDT. 1459 * 1460 *****************************************************************************/ 1461 1462 ACPI_STATUS 1463 DtCompileRsdt ( 1464 void **List) 1465 { 1466 DT_SUBTABLE *Subtable; 1467 DT_SUBTABLE *ParentTable; 1468 DT_FIELD *FieldList = *(DT_FIELD **) List; 1469 UINT32 Address; 1470 1471 1472 ParentTable = DtPeekSubtable (); 1473 1474 while (FieldList) 1475 { 1476 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO); 1477 1478 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable); 1479 DtInsertSubtable (ParentTable, Subtable); 1480 FieldList = FieldList->Next; 1481 } 1482 1483 return (AE_OK); 1484 } 1485 1486 1487 /****************************************************************************** 1488 * 1489 * FUNCTION: DtCompileS3pt 1490 * 1491 * PARAMETERS: PFieldList - Current field list pointer 1492 * 1493 * RETURN: Status 1494 * 1495 * DESCRIPTION: Compile S3PT (Pointed to by FPDT) 1496 * 1497 *****************************************************************************/ 1498 1499 ACPI_STATUS 1500 DtCompileS3pt ( 1501 DT_FIELD **PFieldList) 1502 { 1503 ACPI_STATUS Status; 1504 ACPI_FPDT_HEADER *S3ptHeader; 1505 DT_SUBTABLE *Subtable; 1506 DT_SUBTABLE *ParentTable; 1507 ACPI_DMTABLE_INFO *InfoTable; 1508 DT_FIELD *SubtableStart; 1509 1510 1511 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt, 1512 &AslGbl_RootTable); 1513 if (ACPI_FAILURE (Status)) 1514 { 1515 return (Status); 1516 } 1517 1518 DtPushSubtable (AslGbl_RootTable); 1519 1520 while (*PFieldList) 1521 { 1522 SubtableStart = *PFieldList; 1523 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr, 1524 &Subtable); 1525 if (ACPI_FAILURE (Status)) 1526 { 1527 return (Status); 1528 } 1529 1530 ParentTable = DtPeekSubtable (); 1531 DtInsertSubtable (ParentTable, Subtable); 1532 DtPushSubtable (Subtable); 1533 1534 S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer); 1535 1536 switch (S3ptHeader->Type) 1537 { 1538 case ACPI_S3PT_TYPE_RESUME: 1539 1540 InfoTable = AcpiDmTableInfoS3pt0; 1541 break; 1542 1543 case ACPI_S3PT_TYPE_SUSPEND: 1544 1545 InfoTable = AcpiDmTableInfoS3pt1; 1546 break; 1547 1548 default: 1549 1550 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT"); 1551 return (AE_ERROR); 1552 } 1553 1554 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1555 if (ACPI_FAILURE (Status)) 1556 { 1557 return (Status); 1558 } 1559 1560 ParentTable = DtPeekSubtable (); 1561 DtInsertSubtable (ParentTable, Subtable); 1562 DtPopSubtable (); 1563 } 1564 1565 return (AE_OK); 1566 } 1567 1568 1569 /****************************************************************************** 1570 * 1571 * FUNCTION: DtCompileSdev 1572 * 1573 * PARAMETERS: List - Current field list pointer 1574 * 1575 * RETURN: Status 1576 * 1577 * DESCRIPTION: Compile SDEV. 1578 * 1579 *****************************************************************************/ 1580 1581 ACPI_STATUS 1582 DtCompileSdev ( 1583 void **List) 1584 { 1585 ACPI_STATUS Status; 1586 ACPI_SDEV_HEADER *SdevHeader; 1587 ACPI_SDEV_HEADER *SecureComponentHeader; 1588 DT_SUBTABLE *Subtable; 1589 DT_SUBTABLE *ParentTable; 1590 ACPI_DMTABLE_INFO *InfoTable; 1591 ACPI_DMTABLE_INFO *SecureComponentInfoTable = NULL; 1592 DT_FIELD **PFieldList = (DT_FIELD **) List; 1593 DT_FIELD *SubtableStart; 1594 ACPI_SDEV_PCIE *Pcie = NULL; 1595 ACPI_SDEV_NAMESPACE *Namesp = NULL; 1596 UINT32 EntryCount; 1597 ACPI_SDEV_SECURE_COMPONENT *SecureComponent = NULL; 1598 UINT16 ComponentLength = 0; 1599 1600 1601 /* Subtables */ 1602 1603 while (*PFieldList) 1604 { 1605 /* Compile common SDEV subtable header */ 1606 1607 SubtableStart = *PFieldList; 1608 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdevHdr, 1609 &Subtable); 1610 if (ACPI_FAILURE (Status)) 1611 { 1612 return (Status); 1613 } 1614 1615 ParentTable = DtPeekSubtable (); 1616 DtInsertSubtable (ParentTable, Subtable); 1617 DtPushSubtable (Subtable); 1618 1619 SdevHeader = ACPI_CAST_PTR (ACPI_SDEV_HEADER, Subtable->Buffer); 1620 SdevHeader->Length = (UINT8)(sizeof (ACPI_SDEV_HEADER)); 1621 1622 switch (SdevHeader->Type) 1623 { 1624 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1625 1626 InfoTable = AcpiDmTableInfoSdev0; 1627 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable->Buffer); 1628 SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT, 1629 ACPI_ADD_PTR (UINT8, Subtable->Buffer, sizeof(ACPI_SDEV_NAMESPACE))); 1630 break; 1631 1632 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1633 1634 InfoTable = AcpiDmTableInfoSdev1; 1635 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable->Buffer); 1636 break; 1637 1638 default: 1639 1640 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV"); 1641 return (AE_ERROR); 1642 } 1643 1644 /* Compile SDEV subtable body */ 1645 1646 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1647 if (ACPI_FAILURE (Status)) 1648 { 1649 return (Status); 1650 } 1651 1652 ParentTable = DtPeekSubtable (); 1653 DtInsertSubtable (ParentTable, Subtable); 1654 1655 /* Optional data fields are appended to the main subtable body */ 1656 1657 switch (SdevHeader->Type) 1658 { 1659 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1660 1661 /* 1662 * Device Id Offset will be be calculated differently depending on 1663 * the presence of secure access components. 1664 */ 1665 Namesp->DeviceIdOffset = 0; 1666 ComponentLength = 0; 1667 1668 /* If the secure access component exists, get the structures */ 1669 1670 if (SdevHeader->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT) 1671 { 1672 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev0b, 1673 &Subtable); 1674 if (ACPI_FAILURE (Status)) 1675 { 1676 return (Status); 1677 } 1678 ParentTable = DtPeekSubtable (); 1679 DtInsertSubtable (ParentTable, Subtable); 1680 1681 Namesp->DeviceIdOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT); 1682 1683 /* Compile a secure access component header */ 1684 1685 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdevSecCompHdr, 1686 &Subtable); 1687 if (ACPI_FAILURE (Status)) 1688 { 1689 return (Status); 1690 } 1691 ParentTable = DtPeekSubtable (); 1692 DtInsertSubtable (ParentTable, Subtable); 1693 1694 /* Compile the secure access component */ 1695 1696 SecureComponentHeader = ACPI_CAST_PTR (ACPI_SDEV_HEADER, Subtable->Buffer); 1697 switch (SecureComponentHeader->Type) 1698 { 1699 case ACPI_SDEV_TYPE_ID_COMPONENT: 1700 1701 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId; 1702 Namesp->DeviceIdOffset += sizeof (ACPI_SDEV_ID_COMPONENT); 1703 ComponentLength = sizeof (ACPI_SDEV_ID_COMPONENT); 1704 break; 1705 1706 case ACPI_SDEV_TYPE_MEM_COMPONENT: 1707 1708 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem; 1709 Namesp->DeviceIdOffset += sizeof (ACPI_SDEV_MEM_COMPONENT); 1710 ComponentLength = sizeof (ACPI_SDEV_MEM_COMPONENT); 1711 break; 1712 1713 default: 1714 1715 /* Any other secure component types are undefined */ 1716 1717 return (AE_ERROR); 1718 } 1719 1720 Status = DtCompileTable (PFieldList, SecureComponentInfoTable, 1721 &Subtable); 1722 if (ACPI_FAILURE (Status)) 1723 { 1724 return (Status); 1725 } 1726 ParentTable = DtPeekSubtable (); 1727 DtInsertSubtable (ParentTable, Subtable); 1728 1729 SecureComponent->SecureComponentOffset = 1730 sizeof (ACPI_SDEV_NAMESPACE) + sizeof (ACPI_SDEV_SECURE_COMPONENT); 1731 SecureComponent->SecureComponentLength = ComponentLength; 1732 1733 1734 /* 1735 * Add the secure component to the subtable to be added for the 1736 * the namespace subtable's length 1737 */ 1738 ComponentLength += sizeof (ACPI_SDEV_SECURE_COMPONENT); 1739 } 1740 1741 /* Append DeviceId namespace string */ 1742 1743 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev0a, 1744 &Subtable); 1745 if (ACPI_FAILURE (Status)) 1746 { 1747 return (Status); 1748 } 1749 1750 if (!Subtable) 1751 { 1752 break; 1753 } 1754 1755 ParentTable = DtPeekSubtable (); 1756 DtInsertSubtable (ParentTable, Subtable); 1757 1758 Namesp->DeviceIdOffset += sizeof (ACPI_SDEV_NAMESPACE); 1759 1760 Namesp->DeviceIdLength = (UINT16) Subtable->Length; 1761 1762 /* Append Vendor data */ 1763 1764 Namesp->VendorDataLength = 0; 1765 Namesp->VendorDataOffset = 0; 1766 1767 if (*PFieldList) 1768 { 1769 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b, 1770 &Subtable); 1771 if (ACPI_FAILURE (Status)) 1772 { 1773 return (Status); 1774 } 1775 1776 if (Subtable) 1777 { 1778 ParentTable = DtPeekSubtable (); 1779 DtInsertSubtable (ParentTable, Subtable); 1780 1781 Namesp->VendorDataOffset = 1782 Namesp->DeviceIdOffset + Namesp->DeviceIdLength; 1783 Namesp->VendorDataLength = 1784 (UINT16) Subtable->Length; 1785 1786 /* Final size of entire namespace structure */ 1787 1788 SdevHeader->Length = (UINT16)(sizeof(ACPI_SDEV_NAMESPACE) + 1789 Subtable->Length + Namesp->DeviceIdLength) + ComponentLength; 1790 } 1791 } 1792 1793 break; 1794 1795 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1796 1797 /* Append the PCIe path info first */ 1798 1799 EntryCount = 0; 1800 while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device")) 1801 { 1802 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a, 1803 &Subtable); 1804 if (ACPI_FAILURE (Status)) 1805 { 1806 return (Status); 1807 } 1808 1809 if (!Subtable) 1810 { 1811 DtPopSubtable (); 1812 break; 1813 } 1814 1815 ParentTable = DtPeekSubtable (); 1816 DtInsertSubtable (ParentTable, Subtable); 1817 EntryCount++; 1818 } 1819 1820 /* Path offset will point immediately after the main subtable */ 1821 1822 Pcie->PathOffset = sizeof (ACPI_SDEV_PCIE); 1823 Pcie->PathLength = (UINT16) 1824 (EntryCount * sizeof (ACPI_SDEV_PCIE_PATH)); 1825 1826 /* Append the Vendor Data last */ 1827 1828 Pcie->VendorDataLength = 0; 1829 Pcie->VendorDataOffset = 0; 1830 1831 if (*PFieldList) 1832 { 1833 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b, 1834 &Subtable); 1835 if (ACPI_FAILURE (Status)) 1836 { 1837 return (Status); 1838 } 1839 1840 if (Subtable) 1841 { 1842 ParentTable = DtPeekSubtable (); 1843 DtInsertSubtable (ParentTable, Subtable); 1844 1845 Pcie->VendorDataOffset = 1846 Pcie->PathOffset + Pcie->PathLength; 1847 Pcie->VendorDataLength = (UINT16) 1848 Subtable->Length; 1849 } 1850 } 1851 1852 SdevHeader->Length = 1853 sizeof (ACPI_SDEV_PCIE) + 1854 Pcie->PathLength + Pcie->VendorDataLength; 1855 break; 1856 1857 default: 1858 1859 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV"); 1860 return (AE_ERROR); 1861 } 1862 1863 DtPopSubtable (); 1864 } 1865 1866 return (AE_OK); 1867 } 1868 1869 1870 /****************************************************************************** 1871 * 1872 * FUNCTION: DtCompileSlic 1873 * 1874 * PARAMETERS: List - Current field list pointer 1875 * 1876 * RETURN: Status 1877 * 1878 * DESCRIPTION: Compile SLIC. 1879 * 1880 *****************************************************************************/ 1881 1882 ACPI_STATUS 1883 DtCompileSlic ( 1884 void **List) 1885 { 1886 ACPI_STATUS Status; 1887 DT_SUBTABLE *Subtable; 1888 DT_SUBTABLE *ParentTable; 1889 DT_FIELD **PFieldList = (DT_FIELD **) List; 1890 1891 1892 while (*PFieldList) 1893 { 1894 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic, 1895 &Subtable); 1896 if (ACPI_FAILURE (Status)) 1897 { 1898 return (Status); 1899 } 1900 1901 ParentTable = DtPeekSubtable (); 1902 DtInsertSubtable (ParentTable, Subtable); 1903 DtPushSubtable (Subtable); 1904 DtPopSubtable (); 1905 } 1906 1907 return (AE_OK); 1908 } 1909 1910 1911 /****************************************************************************** 1912 * 1913 * FUNCTION: DtCompileSlit 1914 * 1915 * PARAMETERS: List - Current field list pointer 1916 * 1917 * RETURN: Status 1918 * 1919 * DESCRIPTION: Compile SLIT. 1920 * 1921 *****************************************************************************/ 1922 1923 ACPI_STATUS 1924 DtCompileSlit ( 1925 void **List) 1926 { 1927 ACPI_STATUS Status; 1928 DT_SUBTABLE *Subtable; 1929 DT_SUBTABLE *ParentTable; 1930 DT_FIELD **PFieldList = (DT_FIELD **) List; 1931 DT_FIELD *FieldList; 1932 DT_FIELD *EndOfFieldList = NULL; 1933 UINT32 Localities; 1934 UINT32 LocalityListLength; 1935 UINT8 *LocalityBuffer; 1936 1937 1938 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, 1939 &Subtable); 1940 if (ACPI_FAILURE (Status)) 1941 { 1942 return (Status); 1943 } 1944 1945 ParentTable = DtPeekSubtable (); 1946 DtInsertSubtable (ParentTable, Subtable); 1947 1948 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); 1949 LocalityBuffer = UtLocalCalloc (Localities); 1950 LocalityListLength = 0; 1951 1952 /* Compile each locality buffer */ 1953 1954 FieldList = *PFieldList; 1955 while (FieldList) 1956 { 1957 DtCompileBuffer (LocalityBuffer, 1958 FieldList->Value, FieldList, Localities); 1959 1960 LocalityListLength++; 1961 DtCreateSubtable (LocalityBuffer, Localities, &Subtable); 1962 DtInsertSubtable (ParentTable, Subtable); 1963 EndOfFieldList = FieldList; 1964 FieldList = FieldList->Next; 1965 } 1966 1967 if (LocalityListLength != Localities) 1968 { 1969 sprintf(AslGbl_MsgBuffer, 1970 "Found %u entries, must match LocalityCount: %u", 1971 LocalityListLength, Localities); 1972 DtError (ASL_ERROR, ASL_MSG_ENTRY_LIST, EndOfFieldList, AslGbl_MsgBuffer); 1973 ACPI_FREE (LocalityBuffer); 1974 return (AE_LIMIT); 1975 } 1976 1977 ACPI_FREE (LocalityBuffer); 1978 return (AE_OK); 1979 } 1980 1981 1982 /****************************************************************************** 1983 * 1984 * FUNCTION: DtCompileSrat 1985 * 1986 * PARAMETERS: List - Current field list pointer 1987 * 1988 * RETURN: Status 1989 * 1990 * DESCRIPTION: Compile SRAT. 1991 * 1992 *****************************************************************************/ 1993 1994 ACPI_STATUS 1995 DtCompileSrat ( 1996 void **List) 1997 { 1998 ACPI_STATUS Status; 1999 DT_SUBTABLE *Subtable; 2000 DT_SUBTABLE *ParentTable; 2001 DT_FIELD **PFieldList = (DT_FIELD **) List; 2002 DT_FIELD *SubtableStart; 2003 ACPI_SUBTABLE_HEADER *SratHeader; 2004 ACPI_DMTABLE_INFO *InfoTable; 2005 2006 2007 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat, 2008 &Subtable); 2009 if (ACPI_FAILURE (Status)) 2010 { 2011 return (Status); 2012 } 2013 2014 ParentTable = DtPeekSubtable (); 2015 DtInsertSubtable (ParentTable, Subtable); 2016 2017 while (*PFieldList) 2018 { 2019 SubtableStart = *PFieldList; 2020 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr, 2021 &Subtable); 2022 if (ACPI_FAILURE (Status)) 2023 { 2024 return (Status); 2025 } 2026 2027 ParentTable = DtPeekSubtable (); 2028 DtInsertSubtable (ParentTable, Subtable); 2029 DtPushSubtable (Subtable); 2030 2031 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 2032 2033 switch (SratHeader->Type) 2034 { 2035 case ACPI_SRAT_TYPE_CPU_AFFINITY: 2036 2037 InfoTable = AcpiDmTableInfoSrat0; 2038 break; 2039 2040 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 2041 2042 InfoTable = AcpiDmTableInfoSrat1; 2043 break; 2044 2045 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 2046 2047 InfoTable = AcpiDmTableInfoSrat2; 2048 break; 2049 2050 case ACPI_SRAT_TYPE_GICC_AFFINITY: 2051 2052 InfoTable = AcpiDmTableInfoSrat3; 2053 break; 2054 2055 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY: 2056 2057 InfoTable = AcpiDmTableInfoSrat4; 2058 break; 2059 2060 case ACPI_SRAT_TYPE_GENERIC_AFFINITY: 2061 2062 InfoTable = AcpiDmTableInfoSrat5; 2063 break; 2064 2065 default: 2066 2067 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT"); 2068 return (AE_ERROR); 2069 } 2070 2071 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 2072 if (ACPI_FAILURE (Status)) 2073 { 2074 return (Status); 2075 } 2076 2077 ParentTable = DtPeekSubtable (); 2078 DtInsertSubtable (ParentTable, Subtable); 2079 DtPopSubtable (); 2080 } 2081 2082 return (AE_OK); 2083 } 2084 2085 2086 /****************************************************************************** 2087 * 2088 * FUNCTION: DtCompileStao 2089 * 2090 * PARAMETERS: PFieldList - Current field list pointer 2091 * 2092 * RETURN: Status 2093 * 2094 * DESCRIPTION: Compile STAO. 2095 * 2096 *****************************************************************************/ 2097 2098 ACPI_STATUS 2099 DtCompileStao ( 2100 void **List) 2101 { 2102 DT_FIELD **PFieldList = (DT_FIELD **) List; 2103 DT_SUBTABLE *Subtable; 2104 DT_SUBTABLE *ParentTable; 2105 ACPI_STATUS Status; 2106 2107 2108 /* Compile the main table */ 2109 2110 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao, 2111 &Subtable); 2112 if (ACPI_FAILURE (Status)) 2113 { 2114 return (Status); 2115 } 2116 2117 ParentTable = DtPeekSubtable (); 2118 DtInsertSubtable (ParentTable, Subtable); 2119 2120 /* Compile each ASCII namestring as a subtable */ 2121 2122 while (*PFieldList) 2123 { 2124 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr, 2125 &Subtable); 2126 if (ACPI_FAILURE (Status)) 2127 { 2128 return (Status); 2129 } 2130 2131 ParentTable = DtPeekSubtable (); 2132 DtInsertSubtable (ParentTable, Subtable); 2133 } 2134 2135 return (AE_OK); 2136 } 2137 2138 2139 2140 /****************************************************************************** 2141 * 2142 * FUNCTION: DtCompileSvkl 2143 * 2144 * PARAMETERS: PFieldList - Current field list pointer 2145 * 2146 * RETURN: Status 2147 * 2148 * DESCRIPTION: Compile SVKL. 2149 * 2150 * NOTES: SVKL is essentially a flat table, with a small main table and 2151 * a variable number of a single type of subtable. 2152 * 2153 *****************************************************************************/ 2154 2155 ACPI_STATUS 2156 DtCompileSvkl ( 2157 void **List) 2158 { 2159 DT_FIELD **PFieldList = (DT_FIELD **) List; 2160 DT_SUBTABLE *Subtable; 2161 DT_SUBTABLE *ParentTable; 2162 ACPI_STATUS Status; 2163 2164 2165 /* Compile the main table */ 2166 2167 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSvkl, 2168 &Subtable); 2169 if (ACPI_FAILURE (Status)) 2170 { 2171 return (Status); 2172 } 2173 2174 ParentTable = DtPeekSubtable (); 2175 DtInsertSubtable (ParentTable, Subtable); 2176 2177 /* Compile each subtable */ 2178 2179 while (*PFieldList) 2180 { 2181 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSvkl0, 2182 &Subtable); 2183 if (ACPI_FAILURE (Status)) 2184 { 2185 return (Status); 2186 } 2187 2188 ParentTable = DtPeekSubtable (); 2189 DtInsertSubtable (ParentTable, Subtable); 2190 } 2191 2192 return (AE_OK); 2193 } 2194 2195 2196 /****************************************************************************** 2197 * 2198 * FUNCTION: DtCompileTcpa 2199 * 2200 * PARAMETERS: PFieldList - Current field list pointer 2201 * 2202 * RETURN: Status 2203 * 2204 * DESCRIPTION: Compile TCPA. 2205 * 2206 *****************************************************************************/ 2207 2208 ACPI_STATUS 2209 DtCompileTcpa ( 2210 void **List) 2211 { 2212 DT_FIELD **PFieldList = (DT_FIELD **) List; 2213 DT_SUBTABLE *Subtable; 2214 ACPI_TABLE_TCPA_HDR *TcpaHeader; 2215 DT_SUBTABLE *ParentTable; 2216 ACPI_STATUS Status; 2217 2218 2219 /* Compile the main table */ 2220 2221 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr, 2222 &Subtable); 2223 if (ACPI_FAILURE (Status)) 2224 { 2225 return (Status); 2226 } 2227 2228 ParentTable = DtPeekSubtable (); 2229 DtInsertSubtable (ParentTable, Subtable); 2230 2231 /* 2232 * Examine the PlatformClass field to determine the table type. 2233 * Either a client or server table. Only one. 2234 */ 2235 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer); 2236 2237 switch (TcpaHeader->PlatformClass) 2238 { 2239 case ACPI_TCPA_CLIENT_TABLE: 2240 2241 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient, 2242 &Subtable); 2243 break; 2244 2245 case ACPI_TCPA_SERVER_TABLE: 2246 2247 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer, 2248 &Subtable); 2249 break; 2250 2251 default: 2252 2253 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 2254 TcpaHeader->PlatformClass); 2255 Status = AE_ERROR; 2256 break; 2257 } 2258 2259 ParentTable = DtPeekSubtable (); 2260 DtInsertSubtable (ParentTable, Subtable); 2261 return (Status); 2262 } 2263 2264 2265 /****************************************************************************** 2266 * 2267 * FUNCTION: DtCompileTpm2Rev3 2268 * 2269 * PARAMETERS: PFieldList - Current field list pointer 2270 * 2271 * RETURN: Status 2272 * 2273 * DESCRIPTION: Compile TPM2 revision 3 2274 * 2275 *****************************************************************************/ 2276 static ACPI_STATUS 2277 DtCompileTpm2Rev3 ( 2278 void **List) 2279 { 2280 DT_FIELD **PFieldList = (DT_FIELD **) List; 2281 DT_SUBTABLE *Subtable; 2282 ACPI_TABLE_TPM23 *Tpm23Header; 2283 DT_SUBTABLE *ParentTable; 2284 ACPI_STATUS Status = AE_OK; 2285 2286 2287 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23, 2288 &Subtable); 2289 2290 ParentTable = DtPeekSubtable (); 2291 DtInsertSubtable (ParentTable, Subtable); 2292 Tpm23Header = ACPI_CAST_PTR (ACPI_TABLE_TPM23, ParentTable->Buffer); 2293 2294 /* Subtable type depends on the StartMethod */ 2295 2296 switch (Tpm23Header->StartMethod) 2297 { 2298 case ACPI_TPM23_ACPI_START_METHOD: 2299 2300 /* Subtable specific to to ARM_SMC */ 2301 2302 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23a, 2303 &Subtable); 2304 if (ACPI_FAILURE (Status)) 2305 { 2306 return (Status); 2307 } 2308 2309 ParentTable = DtPeekSubtable (); 2310 DtInsertSubtable (ParentTable, Subtable); 2311 break; 2312 2313 default: 2314 break; 2315 } 2316 2317 return (Status); 2318 } 2319 2320 2321 /****************************************************************************** 2322 * 2323 * FUNCTION: DtCompileTpm2 2324 * 2325 * PARAMETERS: PFieldList - Current field list pointer 2326 * 2327 * RETURN: Status 2328 * 2329 * DESCRIPTION: Compile TPM2. 2330 * 2331 *****************************************************************************/ 2332 2333 ACPI_STATUS 2334 DtCompileTpm2 ( 2335 void **List) 2336 { 2337 DT_FIELD **PFieldList = (DT_FIELD **) List; 2338 DT_SUBTABLE *Subtable; 2339 ACPI_TABLE_TPM2 *Tpm2Header; 2340 DT_SUBTABLE *ParentTable; 2341 ACPI_STATUS Status = AE_OK; 2342 ACPI_TABLE_HEADER *Header; 2343 2344 2345 ParentTable = DtPeekSubtable (); 2346 2347 Header = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); 2348 2349 if (Header->Revision == 3) 2350 { 2351 return (DtCompileTpm2Rev3 (List)); 2352 } 2353 2354 /* Compile the main table */ 2355 2356 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2, 2357 &Subtable); 2358 if (ACPI_FAILURE (Status)) 2359 { 2360 return (Status); 2361 } 2362 2363 ParentTable = DtPeekSubtable (); 2364 DtInsertSubtable (ParentTable, Subtable); 2365 2366 Tpm2Header = ACPI_CAST_PTR (ACPI_TABLE_TPM2, ParentTable->Buffer); 2367 2368 /* Method parameters */ 2369 /* Optional: Log area minimum length */ 2370 /* Optional: Log area start address */ 2371 /* TBD: Optional fields above not fully implemented (not optional at this time) */ 2372 2373 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a, 2374 &Subtable); 2375 if (ACPI_FAILURE (Status)) 2376 { 2377 return (Status); 2378 } 2379 2380 ParentTable = DtPeekSubtable (); 2381 DtInsertSubtable (ParentTable, Subtable); 2382 2383 2384 /* Subtable type depends on the StartMethod */ 2385 2386 switch (Tpm2Header->StartMethod) 2387 { 2388 case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC: 2389 2390 /* Subtable specific to to ARM_SMC */ 2391 2392 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211, 2393 &Subtable); 2394 if (ACPI_FAILURE (Status)) 2395 { 2396 return (Status); 2397 } 2398 2399 ParentTable = DtPeekSubtable (); 2400 DtInsertSubtable (ParentTable, Subtable); 2401 break; 2402 2403 case ACPI_TPM2_START_METHOD: 2404 case ACPI_TPM2_MEMORY_MAPPED: 2405 case ACPI_TPM2_COMMAND_BUFFER: 2406 case ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD: 2407 break; 2408 2409 case ACPI_TPM2_RESERVED1: 2410 case ACPI_TPM2_RESERVED3: 2411 case ACPI_TPM2_RESERVED4: 2412 case ACPI_TPM2_RESERVED5: 2413 case ACPI_TPM2_RESERVED9: 2414 case ACPI_TPM2_RESERVED10: 2415 2416 AcpiOsPrintf ("\n**** Reserved TPM2 Start Method type 0x%X\n", 2417 Tpm2Header->StartMethod); 2418 Status = AE_ERROR; 2419 break; 2420 2421 case ACPI_TPM2_NOT_ALLOWED: 2422 default: 2423 2424 AcpiOsPrintf ("\n**** Unknown TPM2 Start Method type 0x%X\n", 2425 Tpm2Header->StartMethod); 2426 Status = AE_ERROR; 2427 break; 2428 } 2429 2430 return (Status); 2431 } 2432 2433 2434 /****************************************************************************** 2435 * 2436 * FUNCTION: DtGetGenericTableInfo 2437 * 2438 * PARAMETERS: Name - Generic type name 2439 * 2440 * RETURN: Info entry 2441 * 2442 * DESCRIPTION: Obtain table info for a generic name entry 2443 * 2444 *****************************************************************************/ 2445 2446 ACPI_DMTABLE_INFO * 2447 DtGetGenericTableInfo ( 2448 char *Name) 2449 { 2450 ACPI_DMTABLE_INFO *Info; 2451 UINT32 i; 2452 2453 2454 if (!Name) 2455 { 2456 return (NULL); 2457 } 2458 2459 /* Search info table for name match */ 2460 2461 for (i = 0; ; i++) 2462 { 2463 Info = AcpiDmTableInfoGeneric[i]; 2464 if (Info->Opcode == ACPI_DMT_EXIT) 2465 { 2466 Info = NULL; 2467 break; 2468 } 2469 2470 /* Use caseless compare for generic keywords */ 2471 2472 if (!AcpiUtStricmp (Name, Info->Name)) 2473 { 2474 break; 2475 } 2476 } 2477 2478 return (Info); 2479 } 2480 2481 2482 /****************************************************************************** 2483 * 2484 * FUNCTION: DtCompileUefi 2485 * 2486 * PARAMETERS: List - Current field list pointer 2487 * 2488 * RETURN: Status 2489 * 2490 * DESCRIPTION: Compile UEFI. 2491 * 2492 *****************************************************************************/ 2493 2494 ACPI_STATUS 2495 DtCompileUefi ( 2496 void **List) 2497 { 2498 ACPI_STATUS Status; 2499 DT_SUBTABLE *Subtable; 2500 DT_SUBTABLE *ParentTable; 2501 DT_FIELD **PFieldList = (DT_FIELD **) List; 2502 UINT16 *DataOffset; 2503 2504 2505 /* Compile the predefined portion of the UEFI table */ 2506 2507 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi, 2508 &Subtable); 2509 if (ACPI_FAILURE (Status)) 2510 { 2511 return (Status); 2512 } 2513 2514 DataOffset = (UINT16 *) (Subtable->Buffer + 16); 2515 *DataOffset = sizeof (ACPI_TABLE_UEFI); 2516 2517 ParentTable = DtPeekSubtable (); 2518 DtInsertSubtable (ParentTable, Subtable); 2519 2520 /* 2521 * Compile the "generic" portion of the UEFI table. This 2522 * part of the table is not predefined and any of the generic 2523 * operators may be used. 2524 */ 2525 DtCompileGeneric ((void **) PFieldList, NULL, NULL); 2526 return (AE_OK); 2527 } 2528 2529 2530 /****************************************************************************** 2531 * 2532 * FUNCTION: DtCompileViot 2533 * 2534 * PARAMETERS: List - Current field list pointer 2535 * 2536 * RETURN: Status 2537 * 2538 * DESCRIPTION: Compile VIOT. 2539 * 2540 *****************************************************************************/ 2541 2542 ACPI_STATUS 2543 DtCompileViot ( 2544 void **List) 2545 { 2546 ACPI_STATUS Status; 2547 DT_SUBTABLE *Subtable; 2548 DT_SUBTABLE *ParentTable; 2549 DT_FIELD **PFieldList = (DT_FIELD **) List; 2550 DT_FIELD *SubtableStart; 2551 ACPI_TABLE_VIOT *Viot; 2552 ACPI_VIOT_HEADER *ViotHeader; 2553 ACPI_DMTABLE_INFO *InfoTable; 2554 UINT16 NodeCount; 2555 2556 ParentTable = DtPeekSubtable (); 2557 2558 Status = DtCompileTable (PFieldList, AcpiDmTableInfoViot, &Subtable); 2559 if (ACPI_FAILURE (Status)) 2560 { 2561 return (Status); 2562 } 2563 DtInsertSubtable (ParentTable, Subtable); 2564 2565 /* 2566 * Using ACPI_SUB_PTR, We needn't define a separate structure. Care 2567 * should be taken to avoid accessing ACPI_TABLE_HEADER fields. 2568 */ 2569 Viot = ACPI_SUB_PTR (ACPI_TABLE_VIOT, Subtable->Buffer, 2570 sizeof (ACPI_TABLE_HEADER)); 2571 2572 Viot->NodeOffset = sizeof (ACPI_TABLE_VIOT); 2573 2574 NodeCount = 0; 2575 while (*PFieldList) { 2576 SubtableStart = *PFieldList; 2577 Status = DtCompileTable (PFieldList, AcpiDmTableInfoViotHeader, 2578 &Subtable); 2579 if (ACPI_FAILURE (Status)) 2580 { 2581 return (Status); 2582 } 2583 2584 ParentTable = DtPeekSubtable (); 2585 DtInsertSubtable (ParentTable, Subtable); 2586 DtPushSubtable (Subtable); 2587 2588 ViotHeader = ACPI_CAST_PTR (ACPI_VIOT_HEADER, Subtable->Buffer); 2589 2590 switch (ViotHeader->Type) 2591 { 2592 case ACPI_VIOT_NODE_PCI_RANGE: 2593 2594 InfoTable = AcpiDmTableInfoViot1; 2595 break; 2596 2597 case ACPI_VIOT_NODE_MMIO: 2598 2599 InfoTable = AcpiDmTableInfoViot2; 2600 break; 2601 2602 case ACPI_VIOT_NODE_VIRTIO_IOMMU_PCI: 2603 2604 InfoTable = AcpiDmTableInfoViot3; 2605 break; 2606 2607 case ACPI_VIOT_NODE_VIRTIO_IOMMU_MMIO: 2608 2609 InfoTable = AcpiDmTableInfoViot4; 2610 break; 2611 2612 default: 2613 2614 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "VIOT"); 2615 return (AE_ERROR); 2616 } 2617 2618 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 2619 if (ACPI_FAILURE (Status)) 2620 { 2621 return (Status); 2622 } 2623 2624 ParentTable = DtPeekSubtable (); 2625 DtInsertSubtable (ParentTable, Subtable); 2626 DtPopSubtable (); 2627 NodeCount++; 2628 } 2629 2630 Viot->NodeCount = NodeCount; 2631 return (AE_OK); 2632 } 2633 2634 2635 /****************************************************************************** 2636 * 2637 * FUNCTION: DtCompileWdat 2638 * 2639 * PARAMETERS: List - Current field list pointer 2640 * 2641 * RETURN: Status 2642 * 2643 * DESCRIPTION: Compile WDAT. 2644 * 2645 *****************************************************************************/ 2646 2647 ACPI_STATUS 2648 DtCompileWdat ( 2649 void **List) 2650 { 2651 ACPI_STATUS Status; 2652 2653 2654 Status = DtCompileTwoSubtables (List, 2655 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0); 2656 return (Status); 2657 } 2658 2659 2660 /****************************************************************************** 2661 * 2662 * FUNCTION: DtCompileWpbt 2663 * 2664 * PARAMETERS: List - Current field list pointer 2665 * 2666 * RETURN: Status 2667 * 2668 * DESCRIPTION: Compile WPBT. 2669 * 2670 *****************************************************************************/ 2671 2672 ACPI_STATUS 2673 DtCompileWpbt ( 2674 void **List) 2675 { 2676 DT_FIELD **PFieldList = (DT_FIELD **) List; 2677 DT_SUBTABLE *Subtable; 2678 DT_SUBTABLE *ParentTable; 2679 ACPI_TABLE_WPBT *Table; 2680 ACPI_STATUS Status; 2681 2682 2683 /* Compile the main table */ 2684 2685 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt, &Subtable); 2686 if (ACPI_FAILURE (Status)) 2687 { 2688 return (Status); 2689 } 2690 2691 ParentTable = DtPeekSubtable (); 2692 DtInsertSubtable (ParentTable, Subtable); 2693 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer); 2694 2695 /* 2696 * Exit now if there are no arguments specified. This is indicated by: 2697 * The "Command-line Arguments" field has not been specified (if specified, 2698 * it will be the last field in the field list -- after the main table). 2699 * Set the Argument Length in the main table to zero. 2700 */ 2701 if (!*PFieldList) 2702 { 2703 Table->ArgumentsLength = 0; 2704 return (AE_OK); 2705 } 2706 2707 /* Compile the argument list subtable */ 2708 2709 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0, &Subtable); 2710 if (ACPI_FAILURE (Status)) 2711 { 2712 return (Status); 2713 } 2714 2715 /* Extract the length of the Arguments buffer, insert into main table */ 2716 2717 Table->ArgumentsLength = (UINT16) Subtable->TotalLength; 2718 DtInsertSubtable (ParentTable, Subtable); 2719 return (AE_OK); 2720 } 2721 2722 2723 /****************************************************************************** 2724 * 2725 * FUNCTION: DtCompileXsdt 2726 * 2727 * PARAMETERS: List - Current field list pointer 2728 * 2729 * RETURN: Status 2730 * 2731 * DESCRIPTION: Compile XSDT. 2732 * 2733 *****************************************************************************/ 2734 2735 ACPI_STATUS 2736 DtCompileXsdt ( 2737 void **List) 2738 { 2739 DT_SUBTABLE *Subtable; 2740 DT_SUBTABLE *ParentTable; 2741 DT_FIELD *FieldList = *(DT_FIELD **) List; 2742 UINT64 Address; 2743 2744 2745 ParentTable = DtPeekSubtable (); 2746 2747 while (FieldList) 2748 { 2749 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO); 2750 2751 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable); 2752 DtInsertSubtable (ParentTable, Subtable); 2753 FieldList = FieldList->Next; 2754 } 2755 2756 return (AE_OK); 2757 } 2758 2759 2760 /****************************************************************************** 2761 * 2762 * FUNCTION: DtCompileGeneric 2763 * 2764 * PARAMETERS: List - Current field list pointer 2765 * Name - Field name to end generic compiling 2766 * Length - Compiled table length to return 2767 * 2768 * RETURN: Status 2769 * 2770 * DESCRIPTION: Compile generic unknown table. 2771 * 2772 *****************************************************************************/ 2773 2774 ACPI_STATUS 2775 DtCompileGeneric ( 2776 void **List, 2777 char *Name, 2778 UINT32 *Length) 2779 { 2780 ACPI_STATUS Status; 2781 DT_SUBTABLE *Subtable; 2782 DT_SUBTABLE *ParentTable; 2783 DT_FIELD **PFieldList = (DT_FIELD **) List; 2784 ACPI_DMTABLE_INFO *Info; 2785 2786 2787 ParentTable = DtPeekSubtable (); 2788 2789 /* 2790 * Compile the "generic" portion of the table. This 2791 * part of the table is not predefined and any of the generic 2792 * operators may be used. 2793 */ 2794 2795 /* Find any and all labels in the entire generic portion */ 2796 2797 DtDetectAllLabels (*PFieldList); 2798 2799 /* Now we can actually compile the parse tree */ 2800 2801 if (Length && *Length) 2802 { 2803 *Length = 0; 2804 } 2805 while (*PFieldList) 2806 { 2807 if (Name && !strcmp ((*PFieldList)->Name, Name)) 2808 { 2809 break; 2810 } 2811 2812 Info = DtGetGenericTableInfo ((*PFieldList)->Name); 2813 if (!Info) 2814 { 2815 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found", 2816 (*PFieldList)->Name); 2817 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2818 (*PFieldList), AslGbl_MsgBuffer); 2819 2820 *PFieldList = (*PFieldList)->Next; 2821 continue; 2822 } 2823 2824 Status = DtCompileTable (PFieldList, Info, 2825 &Subtable); 2826 if (ACPI_SUCCESS (Status)) 2827 { 2828 DtInsertSubtable (ParentTable, Subtable); 2829 if (Length) 2830 { 2831 *Length += Subtable->Length; 2832 } 2833 } 2834 else 2835 { 2836 *PFieldList = (*PFieldList)->Next; 2837 2838 if (Status == AE_NOT_FOUND) 2839 { 2840 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found", 2841 (*PFieldList)->Name); 2842 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2843 (*PFieldList), AslGbl_MsgBuffer); 2844 } 2845 } 2846 } 2847 2848 return (AE_OK); 2849 } 2850