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 - 2019, 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 <contrib/dev/acpica/compiler/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 default: 370 371 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT"); 372 return (AE_ERROR); 373 } 374 375 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 376 if (ACPI_FAILURE (Status)) 377 { 378 return (Status); 379 } 380 381 ParentTable = DtPeekSubtable (); 382 DtInsertSubtable (ParentTable, Subtable); 383 DtPopSubtable (); 384 } 385 386 return (AE_OK); 387 } 388 389 390 /****************************************************************************** 391 * 392 * FUNCTION: DtCompileMcfg 393 * 394 * PARAMETERS: List - Current field list pointer 395 * 396 * RETURN: Status 397 * 398 * DESCRIPTION: Compile MCFG. 399 * 400 *****************************************************************************/ 401 402 ACPI_STATUS 403 DtCompileMcfg ( 404 void **List) 405 { 406 ACPI_STATUS Status; 407 408 409 Status = DtCompileTwoSubtables (List, 410 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0); 411 return (Status); 412 } 413 414 415 /****************************************************************************** 416 * 417 * FUNCTION: DtCompileMpst 418 * 419 * PARAMETERS: List - Current field list pointer 420 * 421 * RETURN: Status 422 * 423 * DESCRIPTION: Compile MPST. 424 * 425 *****************************************************************************/ 426 427 ACPI_STATUS 428 DtCompileMpst ( 429 void **List) 430 { 431 ACPI_STATUS Status; 432 DT_SUBTABLE *Subtable; 433 DT_SUBTABLE *ParentTable; 434 DT_FIELD **PFieldList = (DT_FIELD **) List; 435 ACPI_MPST_CHANNEL *MpstChannelInfo; 436 ACPI_MPST_POWER_NODE *MpstPowerNode; 437 ACPI_MPST_DATA_HDR *MpstDataHeader; 438 UINT16 SubtableCount; 439 UINT32 PowerStateCount; 440 UINT32 ComponentCount; 441 442 443 /* Main table */ 444 445 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable); 446 if (ACPI_FAILURE (Status)) 447 { 448 return (Status); 449 } 450 451 ParentTable = DtPeekSubtable (); 452 DtInsertSubtable (ParentTable, Subtable); 453 DtPushSubtable (Subtable); 454 455 MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer); 456 SubtableCount = MpstChannelInfo->PowerNodeCount; 457 458 while (*PFieldList && SubtableCount) 459 { 460 /* Subtable: Memory Power Node(s) */ 461 462 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0, 463 &Subtable); 464 if (ACPI_FAILURE (Status)) 465 { 466 return (Status); 467 } 468 469 ParentTable = DtPeekSubtable (); 470 DtInsertSubtable (ParentTable, Subtable); 471 DtPushSubtable (Subtable); 472 473 MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer); 474 PowerStateCount = MpstPowerNode->NumPowerStates; 475 ComponentCount = MpstPowerNode->NumPhysicalComponents; 476 477 ParentTable = DtPeekSubtable (); 478 479 /* Sub-subtables - Memory Power State Structure(s) */ 480 481 while (*PFieldList && PowerStateCount) 482 { 483 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A, 484 &Subtable); 485 if (ACPI_FAILURE (Status)) 486 { 487 return (Status); 488 } 489 490 DtInsertSubtable (ParentTable, Subtable); 491 PowerStateCount--; 492 } 493 494 /* Sub-subtables - Physical Component ID Structure(s) */ 495 496 while (*PFieldList && ComponentCount) 497 { 498 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B, 499 &Subtable); 500 if (ACPI_FAILURE (Status)) 501 { 502 return (Status); 503 } 504 505 DtInsertSubtable (ParentTable, Subtable); 506 ComponentCount--; 507 } 508 509 SubtableCount--; 510 DtPopSubtable (); 511 } 512 513 /* Subtable: Count of Memory Power State Characteristic structures */ 514 515 DtPopSubtable (); 516 517 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable); 518 if (ACPI_FAILURE (Status)) 519 { 520 return (Status); 521 } 522 523 ParentTable = DtPeekSubtable (); 524 DtInsertSubtable (ParentTable, Subtable); 525 DtPushSubtable (Subtable); 526 527 MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer); 528 SubtableCount = MpstDataHeader->CharacteristicsCount; 529 530 ParentTable = DtPeekSubtable (); 531 532 /* Subtable: Memory Power State Characteristics structure(s) */ 533 534 while (*PFieldList && SubtableCount) 535 { 536 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2, 537 &Subtable); 538 if (ACPI_FAILURE (Status)) 539 { 540 return (Status); 541 } 542 543 DtInsertSubtable (ParentTable, Subtable); 544 SubtableCount--; 545 } 546 547 DtPopSubtable (); 548 return (AE_OK); 549 } 550 551 552 /****************************************************************************** 553 * 554 * FUNCTION: DtCompileMsct 555 * 556 * PARAMETERS: List - Current field list pointer 557 * 558 * RETURN: Status 559 * 560 * DESCRIPTION: Compile MSCT. 561 * 562 *****************************************************************************/ 563 564 ACPI_STATUS 565 DtCompileMsct ( 566 void **List) 567 { 568 ACPI_STATUS Status; 569 570 571 Status = DtCompileTwoSubtables (List, 572 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0); 573 return (Status); 574 } 575 576 577 /****************************************************************************** 578 * 579 * FUNCTION: DtCompileMtmr 580 * 581 * PARAMETERS: List - Current field list pointer 582 * 583 * RETURN: Status 584 * 585 * DESCRIPTION: Compile MTMR. 586 * 587 *****************************************************************************/ 588 589 ACPI_STATUS 590 DtCompileMtmr ( 591 void **List) 592 { 593 ACPI_STATUS Status; 594 595 596 Status = DtCompileTwoSubtables (List, 597 AcpiDmTableInfoMtmr, AcpiDmTableInfoMtmr0); 598 return (Status); 599 } 600 601 602 /****************************************************************************** 603 * 604 * FUNCTION: DtCompileNfit 605 * 606 * PARAMETERS: List - Current field list pointer 607 * 608 * RETURN: Status 609 * 610 * DESCRIPTION: Compile NFIT. 611 * 612 *****************************************************************************/ 613 614 ACPI_STATUS 615 DtCompileNfit ( 616 void **List) 617 { 618 ACPI_STATUS Status; 619 DT_SUBTABLE *Subtable; 620 DT_SUBTABLE *ParentTable; 621 DT_FIELD **PFieldList = (DT_FIELD **) List; 622 DT_FIELD *SubtableStart; 623 ACPI_NFIT_HEADER *NfitHeader; 624 ACPI_DMTABLE_INFO *InfoTable; 625 UINT32 Count; 626 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 627 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 628 629 630 /* Main table */ 631 632 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit, 633 &Subtable); 634 if (ACPI_FAILURE (Status)) 635 { 636 return (Status); 637 } 638 639 ParentTable = DtPeekSubtable (); 640 DtInsertSubtable (ParentTable, Subtable); 641 DtPushSubtable (Subtable); 642 643 /* Subtables */ 644 645 while (*PFieldList) 646 { 647 SubtableStart = *PFieldList; 648 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr, 649 &Subtable); 650 if (ACPI_FAILURE (Status)) 651 { 652 return (Status); 653 } 654 655 ParentTable = DtPeekSubtable (); 656 DtInsertSubtable (ParentTable, Subtable); 657 DtPushSubtable (Subtable); 658 659 NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer); 660 661 switch (NfitHeader->Type) 662 { 663 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 664 665 InfoTable = AcpiDmTableInfoNfit0; 666 break; 667 668 case ACPI_NFIT_TYPE_MEMORY_MAP: 669 670 InfoTable = AcpiDmTableInfoNfit1; 671 break; 672 673 case ACPI_NFIT_TYPE_INTERLEAVE: 674 675 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer); 676 InfoTable = AcpiDmTableInfoNfit2; 677 break; 678 679 case ACPI_NFIT_TYPE_SMBIOS: 680 681 InfoTable = AcpiDmTableInfoNfit3; 682 break; 683 684 case ACPI_NFIT_TYPE_CONTROL_REGION: 685 686 InfoTable = AcpiDmTableInfoNfit4; 687 break; 688 689 case ACPI_NFIT_TYPE_DATA_REGION: 690 691 InfoTable = AcpiDmTableInfoNfit5; 692 break; 693 694 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 695 696 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer); 697 InfoTable = AcpiDmTableInfoNfit6; 698 break; 699 700 case ACPI_NFIT_TYPE_CAPABILITIES: 701 702 InfoTable = AcpiDmTableInfoNfit7; 703 break; 704 705 default: 706 707 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT"); 708 return (AE_ERROR); 709 } 710 711 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 712 if (ACPI_FAILURE (Status)) 713 { 714 return (Status); 715 } 716 717 ParentTable = DtPeekSubtable (); 718 DtInsertSubtable (ParentTable, Subtable); 719 DtPopSubtable (); 720 721 switch (NfitHeader->Type) 722 { 723 case ACPI_NFIT_TYPE_INTERLEAVE: 724 725 Count = 0; 726 DtPushSubtable (Subtable); 727 while (*PFieldList) 728 { 729 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a, 730 &Subtable); 731 if (ACPI_FAILURE (Status)) 732 { 733 return (Status); 734 } 735 736 if (!Subtable) 737 { 738 DtPopSubtable (); 739 break; 740 } 741 742 ParentTable = DtPeekSubtable (); 743 DtInsertSubtable (ParentTable, Subtable); 744 Count++; 745 } 746 747 Interleave->LineCount = Count; 748 break; 749 750 case ACPI_NFIT_TYPE_SMBIOS: 751 752 if (*PFieldList) 753 { 754 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a, 755 &Subtable); 756 if (ACPI_FAILURE (Status)) 757 { 758 return (Status); 759 } 760 761 if (Subtable) 762 { 763 DtInsertSubtable (ParentTable, Subtable); 764 } 765 } 766 break; 767 768 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 769 770 Count = 0; 771 DtPushSubtable (Subtable); 772 while (*PFieldList) 773 { 774 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a, 775 &Subtable); 776 if (ACPI_FAILURE (Status)) 777 { 778 return (Status); 779 } 780 781 if (!Subtable) 782 { 783 DtPopSubtable (); 784 break; 785 } 786 787 ParentTable = DtPeekSubtable (); 788 DtInsertSubtable (ParentTable, Subtable); 789 Count++; 790 } 791 792 Hint->HintCount = (UINT16) Count; 793 break; 794 795 default: 796 break; 797 } 798 } 799 800 return (AE_OK); 801 } 802 803 804 /****************************************************************************** 805 * 806 * FUNCTION: DtCompilePcct 807 * 808 * PARAMETERS: List - Current field list pointer 809 * 810 * RETURN: Status 811 * 812 * DESCRIPTION: Compile PCCT. 813 * 814 *****************************************************************************/ 815 816 ACPI_STATUS 817 DtCompilePcct ( 818 void **List) 819 { 820 ACPI_STATUS Status; 821 DT_SUBTABLE *Subtable; 822 DT_SUBTABLE *ParentTable; 823 DT_FIELD **PFieldList = (DT_FIELD **) List; 824 DT_FIELD *SubtableStart; 825 ACPI_SUBTABLE_HEADER *PcctHeader; 826 ACPI_DMTABLE_INFO *InfoTable; 827 828 829 /* Main table */ 830 831 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct, 832 &Subtable); 833 if (ACPI_FAILURE (Status)) 834 { 835 return (Status); 836 } 837 838 ParentTable = DtPeekSubtable (); 839 DtInsertSubtable (ParentTable, Subtable); 840 841 /* Subtables */ 842 843 while (*PFieldList) 844 { 845 SubtableStart = *PFieldList; 846 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr, 847 &Subtable); 848 if (ACPI_FAILURE (Status)) 849 { 850 return (Status); 851 } 852 853 ParentTable = DtPeekSubtable (); 854 DtInsertSubtable (ParentTable, Subtable); 855 DtPushSubtable (Subtable); 856 857 PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 858 859 switch (PcctHeader->Type) 860 { 861 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 862 863 InfoTable = AcpiDmTableInfoPcct0; 864 break; 865 866 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 867 868 InfoTable = AcpiDmTableInfoPcct1; 869 break; 870 871 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 872 873 InfoTable = AcpiDmTableInfoPcct2; 874 break; 875 876 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 877 878 InfoTable = AcpiDmTableInfoPcct3; 879 break; 880 881 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 882 883 InfoTable = AcpiDmTableInfoPcct4; 884 break; 885 886 default: 887 888 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT"); 889 return (AE_ERROR); 890 } 891 892 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 893 if (ACPI_FAILURE (Status)) 894 { 895 return (Status); 896 } 897 898 ParentTable = DtPeekSubtable (); 899 DtInsertSubtable (ParentTable, Subtable); 900 DtPopSubtable (); 901 } 902 903 return (AE_OK); 904 } 905 906 907 /****************************************************************************** 908 * 909 * FUNCTION: DtCompilePdtt 910 * 911 * PARAMETERS: List - Current field list pointer 912 * 913 * RETURN: Status 914 * 915 * DESCRIPTION: Compile PDTT. 916 * 917 *****************************************************************************/ 918 919 ACPI_STATUS 920 DtCompilePdtt ( 921 void **List) 922 { 923 ACPI_STATUS Status; 924 DT_SUBTABLE *Subtable; 925 DT_SUBTABLE *ParentTable; 926 DT_FIELD **PFieldList = (DT_FIELD **) List; 927 ACPI_TABLE_PDTT *PdttHeader; 928 UINT32 Count = 0; 929 930 931 /* Main table */ 932 933 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt, &Subtable); 934 if (ACPI_FAILURE (Status)) 935 { 936 return (Status); 937 } 938 939 ParentTable = DtPeekSubtable (); 940 DtInsertSubtable (ParentTable, Subtable); 941 942 PdttHeader = ACPI_CAST_PTR (ACPI_TABLE_PDTT, ParentTable->Buffer); 943 PdttHeader->ArrayOffset = sizeof (ACPI_TABLE_PDTT); 944 945 /* There is only one type of subtable at this time, no need to decode */ 946 947 while (*PFieldList) 948 { 949 /* List of subchannel IDs, each 2 bytes */ 950 951 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt0, 952 &Subtable); 953 if (ACPI_FAILURE (Status)) 954 { 955 return (Status); 956 } 957 958 DtInsertSubtable (ParentTable, Subtable); 959 Count++; 960 } 961 962 PdttHeader->TriggerCount = (UINT8) Count; 963 return (AE_OK); 964 } 965 966 967 /****************************************************************************** 968 * 969 * FUNCTION: DtCompilePmtt 970 * 971 * PARAMETERS: List - Current field list pointer 972 * 973 * RETURN: Status 974 * 975 * DESCRIPTION: Compile PMTT. 976 * 977 *****************************************************************************/ 978 979 ACPI_STATUS 980 DtCompilePmtt ( 981 void **List) 982 { 983 ACPI_STATUS Status; 984 DT_SUBTABLE *Subtable; 985 DT_SUBTABLE *ParentTable; 986 DT_FIELD **PFieldList = (DT_FIELD **) List; 987 DT_FIELD *SubtableStart; 988 ACPI_PMTT_HEADER *PmttHeader; 989 ACPI_PMTT_CONTROLLER *PmttController; 990 UINT16 DomainCount; 991 UINT8 PrevType = ACPI_PMTT_TYPE_SOCKET; 992 993 994 /* Main table */ 995 996 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable); 997 if (ACPI_FAILURE (Status)) 998 { 999 return (Status); 1000 } 1001 1002 ParentTable = DtPeekSubtable (); 1003 DtInsertSubtable (ParentTable, Subtable); 1004 DtPushSubtable (Subtable); 1005 1006 while (*PFieldList) 1007 { 1008 SubtableStart = *PFieldList; 1009 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr, 1010 &Subtable); 1011 if (ACPI_FAILURE (Status)) 1012 { 1013 return (Status); 1014 } 1015 1016 PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer); 1017 while (PrevType >= PmttHeader->Type) 1018 { 1019 DtPopSubtable (); 1020 1021 if (PrevType == ACPI_PMTT_TYPE_SOCKET) 1022 { 1023 break; 1024 } 1025 1026 PrevType--; 1027 } 1028 1029 PrevType = PmttHeader->Type; 1030 1031 ParentTable = DtPeekSubtable (); 1032 DtInsertSubtable (ParentTable, Subtable); 1033 DtPushSubtable (Subtable); 1034 1035 switch (PmttHeader->Type) 1036 { 1037 case ACPI_PMTT_TYPE_SOCKET: 1038 1039 /* Subtable: Socket Structure */ 1040 1041 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0, 1042 &Subtable); 1043 if (ACPI_FAILURE (Status)) 1044 { 1045 return (Status); 1046 } 1047 1048 ParentTable = DtPeekSubtable (); 1049 DtInsertSubtable (ParentTable, Subtable); 1050 break; 1051 1052 case ACPI_PMTT_TYPE_CONTROLLER: 1053 1054 /* Subtable: Memory Controller Structure */ 1055 1056 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1, 1057 &Subtable); 1058 if (ACPI_FAILURE (Status)) 1059 { 1060 return (Status); 1061 } 1062 1063 ParentTable = DtPeekSubtable (); 1064 DtInsertSubtable (ParentTable, Subtable); 1065 1066 PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER, 1067 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER))); 1068 DomainCount = PmttController->DomainCount; 1069 1070 while (DomainCount) 1071 { 1072 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a, 1073 &Subtable); 1074 if (ACPI_FAILURE (Status)) 1075 { 1076 return (Status); 1077 } 1078 1079 DtInsertSubtable (ParentTable, Subtable); 1080 DomainCount--; 1081 } 1082 break; 1083 1084 case ACPI_PMTT_TYPE_DIMM: 1085 1086 /* Subtable: Physical Component Structure */ 1087 1088 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2, 1089 &Subtable); 1090 if (ACPI_FAILURE (Status)) 1091 { 1092 return (Status); 1093 } 1094 1095 ParentTable = DtPeekSubtable (); 1096 DtInsertSubtable (ParentTable, Subtable); 1097 break; 1098 1099 default: 1100 1101 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT"); 1102 return (AE_ERROR); 1103 } 1104 } 1105 1106 return (Status); 1107 } 1108 1109 1110 /****************************************************************************** 1111 * 1112 * FUNCTION: DtCompilePptt 1113 * 1114 * PARAMETERS: List - Current field list pointer 1115 * 1116 * RETURN: Status 1117 * 1118 * DESCRIPTION: Compile PPTT. 1119 * 1120 *****************************************************************************/ 1121 1122 ACPI_STATUS 1123 DtCompilePptt ( 1124 void **List) 1125 { 1126 ACPI_STATUS Status; 1127 ACPI_SUBTABLE_HEADER *PpttHeader; 1128 ACPI_PPTT_PROCESSOR *PpttProcessor = NULL; 1129 DT_SUBTABLE *Subtable; 1130 DT_SUBTABLE *ParentTable; 1131 ACPI_DMTABLE_INFO *InfoTable; 1132 DT_FIELD **PFieldList = (DT_FIELD **) List; 1133 DT_FIELD *SubtableStart; 1134 1135 1136 ParentTable = DtPeekSubtable (); 1137 while (*PFieldList) 1138 { 1139 SubtableStart = *PFieldList; 1140 1141 /* Compile PPTT subtable header */ 1142 1143 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPpttHdr, 1144 &Subtable); 1145 if (ACPI_FAILURE (Status)) 1146 { 1147 return (Status); 1148 } 1149 DtInsertSubtable (ParentTable, Subtable); 1150 PpttHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1151 PpttHeader->Length = (UINT8)(Subtable->Length); 1152 1153 switch (PpttHeader->Type) 1154 { 1155 case ACPI_PPTT_TYPE_PROCESSOR: 1156 1157 InfoTable = AcpiDmTableInfoPptt0; 1158 break; 1159 1160 case ACPI_PPTT_TYPE_CACHE: 1161 1162 InfoTable = AcpiDmTableInfoPptt1; 1163 break; 1164 1165 case ACPI_PPTT_TYPE_ID: 1166 1167 InfoTable = AcpiDmTableInfoPptt2; 1168 break; 1169 1170 default: 1171 1172 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PPTT"); 1173 return (AE_ERROR); 1174 } 1175 1176 /* Compile PPTT subtable body */ 1177 1178 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1179 if (ACPI_FAILURE (Status)) 1180 { 1181 return (Status); 1182 } 1183 DtInsertSubtable (ParentTable, Subtable); 1184 PpttHeader->Length += (UINT8)(Subtable->Length); 1185 1186 /* Compile PPTT subtable additionals */ 1187 1188 switch (PpttHeader->Type) 1189 { 1190 case ACPI_PPTT_TYPE_PROCESSOR: 1191 1192 PpttProcessor = ACPI_SUB_PTR (ACPI_PPTT_PROCESSOR, 1193 Subtable->Buffer, sizeof (ACPI_SUBTABLE_HEADER)); 1194 if (PpttProcessor) 1195 { 1196 /* Compile initiator proximity domain list */ 1197 1198 PpttProcessor->NumberOfPrivResources = 0; 1199 while (*PFieldList) 1200 { 1201 Status = DtCompileTable (PFieldList, 1202 AcpiDmTableInfoPptt0a, &Subtable); 1203 if (ACPI_FAILURE (Status)) 1204 { 1205 return (Status); 1206 } 1207 if (!Subtable) 1208 { 1209 break; 1210 } 1211 1212 DtInsertSubtable (ParentTable, Subtable); 1213 PpttHeader->Length += (UINT8)(Subtable->Length); 1214 PpttProcessor->NumberOfPrivResources++; 1215 } 1216 } 1217 break; 1218 1219 default: 1220 1221 break; 1222 } 1223 } 1224 1225 return (AE_OK); 1226 } 1227 1228 1229 /****************************************************************************** 1230 * 1231 * FUNCTION: DtCompileRsdt 1232 * 1233 * PARAMETERS: List - Current field list pointer 1234 * 1235 * RETURN: Status 1236 * 1237 * DESCRIPTION: Compile RSDT. 1238 * 1239 *****************************************************************************/ 1240 1241 ACPI_STATUS 1242 DtCompileRsdt ( 1243 void **List) 1244 { 1245 DT_SUBTABLE *Subtable; 1246 DT_SUBTABLE *ParentTable; 1247 DT_FIELD *FieldList = *(DT_FIELD **) List; 1248 UINT32 Address; 1249 1250 1251 ParentTable = DtPeekSubtable (); 1252 1253 while (FieldList) 1254 { 1255 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO); 1256 1257 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable); 1258 DtInsertSubtable (ParentTable, Subtable); 1259 FieldList = FieldList->Next; 1260 } 1261 1262 return (AE_OK); 1263 } 1264 1265 1266 /****************************************************************************** 1267 * 1268 * FUNCTION: DtCompileS3pt 1269 * 1270 * PARAMETERS: PFieldList - Current field list pointer 1271 * 1272 * RETURN: Status 1273 * 1274 * DESCRIPTION: Compile S3PT (Pointed to by FPDT) 1275 * 1276 *****************************************************************************/ 1277 1278 ACPI_STATUS 1279 DtCompileS3pt ( 1280 DT_FIELD **PFieldList) 1281 { 1282 ACPI_STATUS Status; 1283 ACPI_FPDT_HEADER *S3ptHeader; 1284 DT_SUBTABLE *Subtable; 1285 DT_SUBTABLE *ParentTable; 1286 ACPI_DMTABLE_INFO *InfoTable; 1287 DT_FIELD *SubtableStart; 1288 1289 1290 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt, 1291 &AslGbl_RootTable); 1292 if (ACPI_FAILURE (Status)) 1293 { 1294 return (Status); 1295 } 1296 1297 DtPushSubtable (AslGbl_RootTable); 1298 1299 while (*PFieldList) 1300 { 1301 SubtableStart = *PFieldList; 1302 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr, 1303 &Subtable); 1304 if (ACPI_FAILURE (Status)) 1305 { 1306 return (Status); 1307 } 1308 1309 ParentTable = DtPeekSubtable (); 1310 DtInsertSubtable (ParentTable, Subtable); 1311 DtPushSubtable (Subtable); 1312 1313 S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer); 1314 1315 switch (S3ptHeader->Type) 1316 { 1317 case ACPI_S3PT_TYPE_RESUME: 1318 1319 InfoTable = AcpiDmTableInfoS3pt0; 1320 break; 1321 1322 case ACPI_S3PT_TYPE_SUSPEND: 1323 1324 InfoTable = AcpiDmTableInfoS3pt1; 1325 break; 1326 1327 default: 1328 1329 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT"); 1330 return (AE_ERROR); 1331 } 1332 1333 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1334 if (ACPI_FAILURE (Status)) 1335 { 1336 return (Status); 1337 } 1338 1339 ParentTable = DtPeekSubtable (); 1340 DtInsertSubtable (ParentTable, Subtable); 1341 DtPopSubtable (); 1342 } 1343 1344 return (AE_OK); 1345 } 1346 1347 1348 /****************************************************************************** 1349 * 1350 * FUNCTION: DtCompileSdev 1351 * 1352 * PARAMETERS: List - Current field list pointer 1353 * 1354 * RETURN: Status 1355 * 1356 * DESCRIPTION: Compile SDEV. 1357 * 1358 *****************************************************************************/ 1359 1360 ACPI_STATUS 1361 DtCompileSdev ( 1362 void **List) 1363 { 1364 ACPI_STATUS Status; 1365 ACPI_SDEV_HEADER *SdevHeader; 1366 DT_SUBTABLE *Subtable; 1367 DT_SUBTABLE *ParentTable; 1368 ACPI_DMTABLE_INFO *InfoTable; 1369 DT_FIELD **PFieldList = (DT_FIELD **) List; 1370 DT_FIELD *SubtableStart; 1371 ACPI_SDEV_PCIE *Pcie = NULL; 1372 ACPI_SDEV_NAMESPACE *Namesp = NULL; 1373 UINT32 EntryCount; 1374 1375 1376 /* Subtables */ 1377 1378 while (*PFieldList) 1379 { 1380 /* Compile common SDEV subtable header */ 1381 1382 SubtableStart = *PFieldList; 1383 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdevHdr, 1384 &Subtable); 1385 if (ACPI_FAILURE (Status)) 1386 { 1387 return (Status); 1388 } 1389 1390 ParentTable = DtPeekSubtable (); 1391 DtInsertSubtable (ParentTable, Subtable); 1392 DtPushSubtable (Subtable); 1393 1394 SdevHeader = ACPI_CAST_PTR (ACPI_SDEV_HEADER, Subtable->Buffer); 1395 SdevHeader->Length = (UINT8)(sizeof (ACPI_SDEV_HEADER)); 1396 1397 switch (SdevHeader->Type) 1398 { 1399 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1400 1401 InfoTable = AcpiDmTableInfoSdev0; 1402 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable->Buffer); 1403 break; 1404 1405 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1406 1407 InfoTable = AcpiDmTableInfoSdev1; 1408 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable->Buffer); 1409 break; 1410 1411 default: 1412 1413 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV"); 1414 return (AE_ERROR); 1415 } 1416 1417 /* Compile SDEV subtable body */ 1418 1419 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1420 if (ACPI_FAILURE (Status)) 1421 { 1422 return (Status); 1423 } 1424 1425 ParentTable = DtPeekSubtable (); 1426 DtInsertSubtable (ParentTable, Subtable); 1427 1428 /* Optional data fields are appended to the main subtable body */ 1429 1430 switch (SdevHeader->Type) 1431 { 1432 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1433 1434 /* Append DeviceId namespace string */ 1435 1436 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev0a, 1437 &Subtable); 1438 if (ACPI_FAILURE (Status)) 1439 { 1440 return (Status); 1441 } 1442 1443 if (!Subtable) 1444 { 1445 break; 1446 } 1447 1448 ParentTable = DtPeekSubtable (); 1449 DtInsertSubtable (ParentTable, Subtable); 1450 1451 Namesp->DeviceIdOffset = sizeof (ACPI_SDEV_NAMESPACE); 1452 Namesp->DeviceIdLength = (UINT16) Subtable->Length; 1453 1454 /* Append Vendor data */ 1455 1456 Namesp->VendorDataLength = 0; 1457 Namesp->VendorDataOffset = 0; 1458 1459 if (*PFieldList) 1460 { 1461 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b, 1462 &Subtable); 1463 if (ACPI_FAILURE (Status)) 1464 { 1465 return (Status); 1466 } 1467 1468 if (Subtable) 1469 { 1470 ParentTable = DtPeekSubtable (); 1471 DtInsertSubtable (ParentTable, Subtable); 1472 1473 Namesp->VendorDataOffset = 1474 Namesp->DeviceIdOffset + Namesp->DeviceIdLength; 1475 Namesp->VendorDataLength = 1476 (UINT16) Subtable->Length; 1477 1478 /* Final size of entire namespace structure */ 1479 1480 SdevHeader->Length = (UINT16)(sizeof(ACPI_SDEV_NAMESPACE) + 1481 Subtable->Length + Namesp->DeviceIdLength); 1482 } 1483 } 1484 1485 break; 1486 1487 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1488 1489 /* Append the PCIe path info first */ 1490 1491 EntryCount = 0; 1492 while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device")) 1493 { 1494 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a, 1495 &Subtable); 1496 if (ACPI_FAILURE (Status)) 1497 { 1498 return (Status); 1499 } 1500 1501 if (!Subtable) 1502 { 1503 DtPopSubtable (); 1504 break; 1505 } 1506 1507 ParentTable = DtPeekSubtable (); 1508 DtInsertSubtable (ParentTable, Subtable); 1509 EntryCount++; 1510 } 1511 1512 /* Path offset will point immediately after the main subtable */ 1513 1514 Pcie->PathOffset = sizeof (ACPI_SDEV_PCIE); 1515 Pcie->PathLength = (UINT16) 1516 (EntryCount * sizeof (ACPI_SDEV_PCIE_PATH)); 1517 1518 /* Append the Vendor Data last */ 1519 1520 Pcie->VendorDataLength = 0; 1521 Pcie->VendorDataOffset = 0; 1522 1523 if (*PFieldList) 1524 { 1525 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b, 1526 &Subtable); 1527 if (ACPI_FAILURE (Status)) 1528 { 1529 return (Status); 1530 } 1531 1532 if (Subtable) 1533 { 1534 ParentTable = DtPeekSubtable (); 1535 DtInsertSubtable (ParentTable, Subtable); 1536 1537 Pcie->VendorDataOffset = 1538 Pcie->PathOffset + Pcie->PathLength; 1539 Pcie->VendorDataLength = (UINT16) 1540 Subtable->Length; 1541 } 1542 } 1543 1544 SdevHeader->Length = 1545 sizeof (ACPI_SDEV_PCIE) + 1546 Pcie->PathLength + Pcie->VendorDataLength; 1547 break; 1548 1549 default: 1550 1551 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV"); 1552 return (AE_ERROR); 1553 } 1554 1555 DtPopSubtable (); 1556 } 1557 1558 return (AE_OK); 1559 } 1560 1561 1562 /****************************************************************************** 1563 * 1564 * FUNCTION: DtCompileSlic 1565 * 1566 * PARAMETERS: List - Current field list pointer 1567 * 1568 * RETURN: Status 1569 * 1570 * DESCRIPTION: Compile SLIC. 1571 * 1572 *****************************************************************************/ 1573 1574 ACPI_STATUS 1575 DtCompileSlic ( 1576 void **List) 1577 { 1578 ACPI_STATUS Status; 1579 DT_SUBTABLE *Subtable; 1580 DT_SUBTABLE *ParentTable; 1581 DT_FIELD **PFieldList = (DT_FIELD **) List; 1582 1583 1584 while (*PFieldList) 1585 { 1586 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic, 1587 &Subtable); 1588 if (ACPI_FAILURE (Status)) 1589 { 1590 return (Status); 1591 } 1592 1593 ParentTable = DtPeekSubtable (); 1594 DtInsertSubtable (ParentTable, Subtable); 1595 DtPushSubtable (Subtable); 1596 DtPopSubtable (); 1597 } 1598 1599 return (AE_OK); 1600 } 1601 1602 1603 /****************************************************************************** 1604 * 1605 * FUNCTION: DtCompileSlit 1606 * 1607 * PARAMETERS: List - Current field list pointer 1608 * 1609 * RETURN: Status 1610 * 1611 * DESCRIPTION: Compile SLIT. 1612 * 1613 *****************************************************************************/ 1614 1615 ACPI_STATUS 1616 DtCompileSlit ( 1617 void **List) 1618 { 1619 ACPI_STATUS Status; 1620 DT_SUBTABLE *Subtable; 1621 DT_SUBTABLE *ParentTable; 1622 DT_FIELD **PFieldList = (DT_FIELD **) List; 1623 DT_FIELD *FieldList; 1624 DT_FIELD *EndOfFieldList = NULL; 1625 UINT32 Localities; 1626 UINT32 LocalityListLength; 1627 UINT8 *LocalityBuffer; 1628 1629 1630 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, 1631 &Subtable); 1632 if (ACPI_FAILURE (Status)) 1633 { 1634 return (Status); 1635 } 1636 1637 ParentTable = DtPeekSubtable (); 1638 DtInsertSubtable (ParentTable, Subtable); 1639 1640 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); 1641 LocalityBuffer = UtLocalCalloc (Localities); 1642 LocalityListLength = 0; 1643 1644 /* Compile each locality buffer */ 1645 1646 FieldList = *PFieldList; 1647 while (FieldList) 1648 { 1649 DtCompileBuffer (LocalityBuffer, 1650 FieldList->Value, FieldList, Localities); 1651 1652 LocalityListLength++; 1653 DtCreateSubtable (LocalityBuffer, Localities, &Subtable); 1654 DtInsertSubtable (ParentTable, Subtable); 1655 EndOfFieldList = FieldList; 1656 FieldList = FieldList->Next; 1657 } 1658 1659 if (LocalityListLength != Localities) 1660 { 1661 sprintf(AslGbl_MsgBuffer, 1662 "Found %u entries, must match LocalityCount: %u", 1663 LocalityListLength, Localities); 1664 DtError (ASL_ERROR, ASL_MSG_ENTRY_LIST, EndOfFieldList, AslGbl_MsgBuffer); 1665 return (AE_LIMIT); 1666 } 1667 1668 ACPI_FREE (LocalityBuffer); 1669 return (AE_OK); 1670 } 1671 1672 1673 /****************************************************************************** 1674 * 1675 * FUNCTION: DtCompileSrat 1676 * 1677 * PARAMETERS: List - Current field list pointer 1678 * 1679 * RETURN: Status 1680 * 1681 * DESCRIPTION: Compile SRAT. 1682 * 1683 *****************************************************************************/ 1684 1685 ACPI_STATUS 1686 DtCompileSrat ( 1687 void **List) 1688 { 1689 ACPI_STATUS Status; 1690 DT_SUBTABLE *Subtable; 1691 DT_SUBTABLE *ParentTable; 1692 DT_FIELD **PFieldList = (DT_FIELD **) List; 1693 DT_FIELD *SubtableStart; 1694 ACPI_SUBTABLE_HEADER *SratHeader; 1695 ACPI_DMTABLE_INFO *InfoTable; 1696 1697 1698 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat, 1699 &Subtable); 1700 if (ACPI_FAILURE (Status)) 1701 { 1702 return (Status); 1703 } 1704 1705 ParentTable = DtPeekSubtable (); 1706 DtInsertSubtable (ParentTable, Subtable); 1707 1708 while (*PFieldList) 1709 { 1710 SubtableStart = *PFieldList; 1711 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr, 1712 &Subtable); 1713 if (ACPI_FAILURE (Status)) 1714 { 1715 return (Status); 1716 } 1717 1718 ParentTable = DtPeekSubtable (); 1719 DtInsertSubtable (ParentTable, Subtable); 1720 DtPushSubtable (Subtable); 1721 1722 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1723 1724 switch (SratHeader->Type) 1725 { 1726 case ACPI_SRAT_TYPE_CPU_AFFINITY: 1727 1728 InfoTable = AcpiDmTableInfoSrat0; 1729 break; 1730 1731 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 1732 1733 InfoTable = AcpiDmTableInfoSrat1; 1734 break; 1735 1736 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 1737 1738 InfoTable = AcpiDmTableInfoSrat2; 1739 break; 1740 1741 case ACPI_SRAT_TYPE_GICC_AFFINITY: 1742 1743 InfoTable = AcpiDmTableInfoSrat3; 1744 break; 1745 1746 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY: 1747 1748 InfoTable = AcpiDmTableInfoSrat4; 1749 break; 1750 1751 case ACPI_SRAT_TYPE_GENERIC_AFFINITY: 1752 1753 InfoTable = AcpiDmTableInfoSrat5; 1754 break; 1755 1756 default: 1757 1758 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT"); 1759 return (AE_ERROR); 1760 } 1761 1762 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1763 if (ACPI_FAILURE (Status)) 1764 { 1765 return (Status); 1766 } 1767 1768 ParentTable = DtPeekSubtable (); 1769 DtInsertSubtable (ParentTable, Subtable); 1770 DtPopSubtable (); 1771 } 1772 1773 return (AE_OK); 1774 } 1775 1776 1777 /****************************************************************************** 1778 * 1779 * FUNCTION: DtCompileStao 1780 * 1781 * PARAMETERS: PFieldList - Current field list pointer 1782 * 1783 * RETURN: Status 1784 * 1785 * DESCRIPTION: Compile STAO. 1786 * 1787 *****************************************************************************/ 1788 1789 ACPI_STATUS 1790 DtCompileStao ( 1791 void **List) 1792 { 1793 DT_FIELD **PFieldList = (DT_FIELD **) List; 1794 DT_SUBTABLE *Subtable; 1795 DT_SUBTABLE *ParentTable; 1796 ACPI_STATUS Status; 1797 1798 1799 /* Compile the main table */ 1800 1801 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao, 1802 &Subtable); 1803 if (ACPI_FAILURE (Status)) 1804 { 1805 return (Status); 1806 } 1807 1808 ParentTable = DtPeekSubtable (); 1809 DtInsertSubtable (ParentTable, Subtable); 1810 1811 /* Compile each ASCII namestring as a subtable */ 1812 1813 while (*PFieldList) 1814 { 1815 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr, 1816 &Subtable); 1817 if (ACPI_FAILURE (Status)) 1818 { 1819 return (Status); 1820 } 1821 1822 ParentTable = DtPeekSubtable (); 1823 DtInsertSubtable (ParentTable, Subtable); 1824 } 1825 1826 return (AE_OK); 1827 } 1828 1829 1830 /****************************************************************************** 1831 * 1832 * FUNCTION: DtCompileTcpa 1833 * 1834 * PARAMETERS: PFieldList - Current field list pointer 1835 * 1836 * RETURN: Status 1837 * 1838 * DESCRIPTION: Compile TCPA. 1839 * 1840 *****************************************************************************/ 1841 1842 ACPI_STATUS 1843 DtCompileTcpa ( 1844 void **List) 1845 { 1846 DT_FIELD **PFieldList = (DT_FIELD **) List; 1847 DT_SUBTABLE *Subtable; 1848 ACPI_TABLE_TCPA_HDR *TcpaHeader; 1849 DT_SUBTABLE *ParentTable; 1850 ACPI_STATUS Status; 1851 1852 1853 /* Compile the main table */ 1854 1855 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr, 1856 &Subtable); 1857 if (ACPI_FAILURE (Status)) 1858 { 1859 return (Status); 1860 } 1861 1862 ParentTable = DtPeekSubtable (); 1863 DtInsertSubtable (ParentTable, Subtable); 1864 1865 /* 1866 * Examine the PlatformClass field to determine the table type. 1867 * Either a client or server table. Only one. 1868 */ 1869 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer); 1870 1871 switch (TcpaHeader->PlatformClass) 1872 { 1873 case ACPI_TCPA_CLIENT_TABLE: 1874 1875 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient, 1876 &Subtable); 1877 break; 1878 1879 case ACPI_TCPA_SERVER_TABLE: 1880 1881 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer, 1882 &Subtable); 1883 break; 1884 1885 default: 1886 1887 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 1888 TcpaHeader->PlatformClass); 1889 Status = AE_ERROR; 1890 break; 1891 } 1892 1893 ParentTable = DtPeekSubtable (); 1894 DtInsertSubtable (ParentTable, Subtable); 1895 return (Status); 1896 } 1897 1898 1899 /****************************************************************************** 1900 * 1901 * FUNCTION: DtCompileTpm2Rev3 1902 * 1903 * PARAMETERS: PFieldList - Current field list pointer 1904 * 1905 * RETURN: Status 1906 * 1907 * DESCRIPTION: Compile TPM2 revision 3 1908 * 1909 *****************************************************************************/ 1910 static ACPI_STATUS 1911 DtCompileTpm2Rev3 ( 1912 void **List) 1913 { 1914 DT_FIELD **PFieldList = (DT_FIELD **) List; 1915 DT_SUBTABLE *Subtable; 1916 ACPI_TABLE_TPM23 *Tpm23Header; 1917 DT_SUBTABLE *ParentTable; 1918 ACPI_STATUS Status = AE_OK; 1919 1920 1921 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23, 1922 &Subtable); 1923 1924 ParentTable = DtPeekSubtable (); 1925 DtInsertSubtable (ParentTable, Subtable); 1926 Tpm23Header = ACPI_CAST_PTR (ACPI_TABLE_TPM23, ParentTable->Buffer); 1927 1928 /* Subtable type depends on the StartMethod */ 1929 1930 switch (Tpm23Header->StartMethod) 1931 { 1932 case ACPI_TPM23_ACPI_START_METHOD: 1933 1934 /* Subtable specific to to ARM_SMC */ 1935 1936 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23a, 1937 &Subtable); 1938 if (ACPI_FAILURE (Status)) 1939 { 1940 return (Status); 1941 } 1942 1943 ParentTable = DtPeekSubtable (); 1944 DtInsertSubtable (ParentTable, Subtable); 1945 break; 1946 1947 default: 1948 break; 1949 } 1950 1951 return (Status); 1952 } 1953 1954 1955 /****************************************************************************** 1956 * 1957 * FUNCTION: DtCompileTpm2 1958 * 1959 * PARAMETERS: PFieldList - Current field list pointer 1960 * 1961 * RETURN: Status 1962 * 1963 * DESCRIPTION: Compile TPM2. 1964 * 1965 *****************************************************************************/ 1966 1967 ACPI_STATUS 1968 DtCompileTpm2 ( 1969 void **List) 1970 { 1971 DT_FIELD **PFieldList = (DT_FIELD **) List; 1972 DT_SUBTABLE *Subtable; 1973 ACPI_TABLE_TPM2 *Tpm2Header; 1974 DT_SUBTABLE *ParentTable; 1975 ACPI_STATUS Status = AE_OK; 1976 ACPI_TABLE_HEADER *Header; 1977 1978 1979 ParentTable = DtPeekSubtable (); 1980 1981 Header = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); 1982 1983 if (Header->Revision == 3) 1984 { 1985 return (DtCompileTpm2Rev3 (List)); 1986 } 1987 1988 /* Compile the main table */ 1989 1990 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2, 1991 &Subtable); 1992 if (ACPI_FAILURE (Status)) 1993 { 1994 return (Status); 1995 } 1996 1997 ParentTable = DtPeekSubtable (); 1998 DtInsertSubtable (ParentTable, Subtable); 1999 2000 Tpm2Header = ACPI_CAST_PTR (ACPI_TABLE_TPM2, ParentTable->Buffer); 2001 2002 /* Method parameters */ 2003 /* Optional: Log area minimum length */ 2004 /* Optional: Log area start address */ 2005 /* TBD: Optional fields above not fully implemented (not optional at this time) */ 2006 2007 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a, 2008 &Subtable); 2009 if (ACPI_FAILURE (Status)) 2010 { 2011 return (Status); 2012 } 2013 2014 ParentTable = DtPeekSubtable (); 2015 DtInsertSubtable (ParentTable, Subtable); 2016 2017 2018 /* Subtable type depends on the StartMethod */ 2019 2020 switch (Tpm2Header->StartMethod) 2021 { 2022 case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC: 2023 2024 /* Subtable specific to to ARM_SMC */ 2025 2026 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211, 2027 &Subtable); 2028 if (ACPI_FAILURE (Status)) 2029 { 2030 return (Status); 2031 } 2032 2033 ParentTable = DtPeekSubtable (); 2034 DtInsertSubtable (ParentTable, Subtable); 2035 break; 2036 2037 case ACPI_TPM2_START_METHOD: 2038 case ACPI_TPM2_MEMORY_MAPPED: 2039 case ACPI_TPM2_COMMAND_BUFFER: 2040 case ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD: 2041 break; 2042 2043 case ACPI_TPM2_RESERVED1: 2044 case ACPI_TPM2_RESERVED3: 2045 case ACPI_TPM2_RESERVED4: 2046 case ACPI_TPM2_RESERVED5: 2047 case ACPI_TPM2_RESERVED9: 2048 case ACPI_TPM2_RESERVED10: 2049 2050 AcpiOsPrintf ("\n**** Reserved TPM2 Start Method type 0x%X\n", 2051 Tpm2Header->StartMethod); 2052 Status = AE_ERROR; 2053 break; 2054 2055 case ACPI_TPM2_NOT_ALLOWED: 2056 default: 2057 2058 AcpiOsPrintf ("\n**** Unknown TPM2 Start Method type 0x%X\n", 2059 Tpm2Header->StartMethod); 2060 Status = AE_ERROR; 2061 break; 2062 } 2063 2064 return (Status); 2065 } 2066 2067 2068 /****************************************************************************** 2069 * 2070 * FUNCTION: DtGetGenericTableInfo 2071 * 2072 * PARAMETERS: Name - Generic type name 2073 * 2074 * RETURN: Info entry 2075 * 2076 * DESCRIPTION: Obtain table info for a generic name entry 2077 * 2078 *****************************************************************************/ 2079 2080 ACPI_DMTABLE_INFO * 2081 DtGetGenericTableInfo ( 2082 char *Name) 2083 { 2084 ACPI_DMTABLE_INFO *Info; 2085 UINT32 i; 2086 2087 2088 if (!Name) 2089 { 2090 return (NULL); 2091 } 2092 2093 /* Search info table for name match */ 2094 2095 for (i = 0; ; i++) 2096 { 2097 Info = AcpiDmTableInfoGeneric[i]; 2098 if (Info->Opcode == ACPI_DMT_EXIT) 2099 { 2100 Info = NULL; 2101 break; 2102 } 2103 2104 /* Use caseless compare for generic keywords */ 2105 2106 if (!AcpiUtStricmp (Name, Info->Name)) 2107 { 2108 break; 2109 } 2110 } 2111 2112 return (Info); 2113 } 2114 2115 2116 /****************************************************************************** 2117 * 2118 * FUNCTION: DtCompileUefi 2119 * 2120 * PARAMETERS: List - Current field list pointer 2121 * 2122 * RETURN: Status 2123 * 2124 * DESCRIPTION: Compile UEFI. 2125 * 2126 *****************************************************************************/ 2127 2128 ACPI_STATUS 2129 DtCompileUefi ( 2130 void **List) 2131 { 2132 ACPI_STATUS Status; 2133 DT_SUBTABLE *Subtable; 2134 DT_SUBTABLE *ParentTable; 2135 DT_FIELD **PFieldList = (DT_FIELD **) List; 2136 UINT16 *DataOffset; 2137 2138 2139 /* Compile the predefined portion of the UEFI table */ 2140 2141 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi, 2142 &Subtable); 2143 if (ACPI_FAILURE (Status)) 2144 { 2145 return (Status); 2146 } 2147 2148 DataOffset = (UINT16 *) (Subtable->Buffer + 16); 2149 *DataOffset = sizeof (ACPI_TABLE_UEFI); 2150 2151 ParentTable = DtPeekSubtable (); 2152 DtInsertSubtable (ParentTable, Subtable); 2153 2154 /* 2155 * Compile the "generic" portion of the UEFI table. This 2156 * part of the table is not predefined and any of the generic 2157 * operators may be used. 2158 */ 2159 DtCompileGeneric ((void **) PFieldList, NULL, NULL); 2160 return (AE_OK); 2161 } 2162 2163 2164 /****************************************************************************** 2165 * 2166 * FUNCTION: DtCompileVrtc 2167 * 2168 * PARAMETERS: List - Current field list pointer 2169 * 2170 * RETURN: Status 2171 * 2172 * DESCRIPTION: Compile VRTC. 2173 * 2174 *****************************************************************************/ 2175 2176 ACPI_STATUS 2177 DtCompileVrtc ( 2178 void **List) 2179 { 2180 ACPI_STATUS Status; 2181 2182 2183 Status = DtCompileTwoSubtables (List, 2184 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0); 2185 return (Status); 2186 } 2187 2188 2189 /****************************************************************************** 2190 * 2191 * FUNCTION: DtCompileWdat 2192 * 2193 * PARAMETERS: List - Current field list pointer 2194 * 2195 * RETURN: Status 2196 * 2197 * DESCRIPTION: Compile WDAT. 2198 * 2199 *****************************************************************************/ 2200 2201 ACPI_STATUS 2202 DtCompileWdat ( 2203 void **List) 2204 { 2205 ACPI_STATUS Status; 2206 2207 2208 Status = DtCompileTwoSubtables (List, 2209 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0); 2210 return (Status); 2211 } 2212 2213 2214 /****************************************************************************** 2215 * 2216 * FUNCTION: DtCompileWpbt 2217 * 2218 * PARAMETERS: List - Current field list pointer 2219 * 2220 * RETURN: Status 2221 * 2222 * DESCRIPTION: Compile WPBT. 2223 * 2224 *****************************************************************************/ 2225 2226 ACPI_STATUS 2227 DtCompileWpbt ( 2228 void **List) 2229 { 2230 DT_FIELD **PFieldList = (DT_FIELD **) List; 2231 DT_SUBTABLE *Subtable; 2232 DT_SUBTABLE *ParentTable; 2233 ACPI_TABLE_WPBT *Table; 2234 ACPI_STATUS Status; 2235 UINT16 Length; 2236 2237 2238 /* Compile the main table */ 2239 2240 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt, 2241 &Subtable); 2242 if (ACPI_FAILURE (Status)) 2243 { 2244 return (Status); 2245 } 2246 2247 ParentTable = DtPeekSubtable (); 2248 DtInsertSubtable (ParentTable, Subtable); 2249 2250 /* Compile the argument list subtable */ 2251 2252 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0, 2253 &Subtable); 2254 if (ACPI_FAILURE (Status)) 2255 { 2256 return (Status); 2257 } 2258 2259 /* Extract the length of the Arguments buffer, insert into main table */ 2260 2261 Length = (UINT16) Subtable->TotalLength; 2262 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer); 2263 Table->ArgumentsLength = Length; 2264 2265 ParentTable = DtPeekSubtable (); 2266 DtInsertSubtable (ParentTable, Subtable); 2267 return (AE_OK); 2268 } 2269 2270 2271 /****************************************************************************** 2272 * 2273 * FUNCTION: DtCompileXsdt 2274 * 2275 * PARAMETERS: List - Current field list pointer 2276 * 2277 * RETURN: Status 2278 * 2279 * DESCRIPTION: Compile XSDT. 2280 * 2281 *****************************************************************************/ 2282 2283 ACPI_STATUS 2284 DtCompileXsdt ( 2285 void **List) 2286 { 2287 DT_SUBTABLE *Subtable; 2288 DT_SUBTABLE *ParentTable; 2289 DT_FIELD *FieldList = *(DT_FIELD **) List; 2290 UINT64 Address; 2291 2292 2293 ParentTable = DtPeekSubtable (); 2294 2295 while (FieldList) 2296 { 2297 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO); 2298 2299 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable); 2300 DtInsertSubtable (ParentTable, Subtable); 2301 FieldList = FieldList->Next; 2302 } 2303 2304 return (AE_OK); 2305 } 2306 2307 2308 /****************************************************************************** 2309 * 2310 * FUNCTION: DtCompileGeneric 2311 * 2312 * PARAMETERS: List - Current field list pointer 2313 * Name - Field name to end generic compiling 2314 * Length - Compiled table length to return 2315 * 2316 * RETURN: Status 2317 * 2318 * DESCRIPTION: Compile generic unknown table. 2319 * 2320 *****************************************************************************/ 2321 2322 ACPI_STATUS 2323 DtCompileGeneric ( 2324 void **List, 2325 char *Name, 2326 UINT32 *Length) 2327 { 2328 ACPI_STATUS Status; 2329 DT_SUBTABLE *Subtable; 2330 DT_SUBTABLE *ParentTable; 2331 DT_FIELD **PFieldList = (DT_FIELD **) List; 2332 ACPI_DMTABLE_INFO *Info; 2333 2334 2335 ParentTable = DtPeekSubtable (); 2336 2337 /* 2338 * Compile the "generic" portion of the table. This 2339 * part of the table is not predefined and any of the generic 2340 * operators may be used. 2341 */ 2342 2343 /* Find any and all labels in the entire generic portion */ 2344 2345 DtDetectAllLabels (*PFieldList); 2346 2347 /* Now we can actually compile the parse tree */ 2348 2349 if (Length && *Length) 2350 { 2351 *Length = 0; 2352 } 2353 while (*PFieldList) 2354 { 2355 if (Name && !strcmp ((*PFieldList)->Name, Name)) 2356 { 2357 break; 2358 } 2359 2360 Info = DtGetGenericTableInfo ((*PFieldList)->Name); 2361 if (!Info) 2362 { 2363 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found", 2364 (*PFieldList)->Name); 2365 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2366 (*PFieldList), AslGbl_MsgBuffer); 2367 2368 *PFieldList = (*PFieldList)->Next; 2369 continue; 2370 } 2371 2372 Status = DtCompileTable (PFieldList, Info, 2373 &Subtable); 2374 if (ACPI_SUCCESS (Status)) 2375 { 2376 DtInsertSubtable (ParentTable, Subtable); 2377 if (Length) 2378 { 2379 *Length += Subtable->Length; 2380 } 2381 } 2382 else 2383 { 2384 *PFieldList = (*PFieldList)->Next; 2385 2386 if (Status == AE_NOT_FOUND) 2387 { 2388 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found", 2389 (*PFieldList)->Name); 2390 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2391 (*PFieldList), AslGbl_MsgBuffer); 2392 } 2393 } 2394 } 2395 2396 return (AE_OK); 2397 } 2398