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 } 1479 1480 /* Final size of entire namespace structure */ 1481 1482 SdevHeader->Length = (UINT16) (sizeof (ACPI_SDEV_NAMESPACE) + 1483 Subtable->Length + Namesp->DeviceIdLength); 1484 break; 1485 1486 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1487 1488 /* Append the PCIe path info first */ 1489 1490 EntryCount = 0; 1491 while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device")) 1492 { 1493 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a, 1494 &Subtable); 1495 if (ACPI_FAILURE (Status)) 1496 { 1497 return (Status); 1498 } 1499 1500 if (!Subtable) 1501 { 1502 DtPopSubtable (); 1503 break; 1504 } 1505 1506 ParentTable = DtPeekSubtable (); 1507 DtInsertSubtable (ParentTable, Subtable); 1508 EntryCount++; 1509 } 1510 1511 /* Path offset will point immediately after the main subtable */ 1512 1513 Pcie->PathOffset = sizeof (ACPI_SDEV_PCIE); 1514 Pcie->PathLength = (UINT16) 1515 (EntryCount * sizeof (ACPI_SDEV_PCIE_PATH)); 1516 1517 /* Append the Vendor Data last */ 1518 1519 Pcie->VendorDataLength = 0; 1520 Pcie->VendorDataOffset = 0; 1521 1522 if (*PFieldList) 1523 { 1524 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b, 1525 &Subtable); 1526 if (ACPI_FAILURE (Status)) 1527 { 1528 return (Status); 1529 } 1530 1531 if (Subtable) 1532 { 1533 ParentTable = DtPeekSubtable (); 1534 DtInsertSubtable (ParentTable, Subtable); 1535 1536 Pcie->VendorDataOffset = 1537 Pcie->PathOffset + Pcie->PathLength; 1538 Pcie->VendorDataLength = (UINT16) 1539 Subtable->Length; 1540 } 1541 } 1542 1543 SdevHeader->Length = 1544 sizeof (ACPI_SDEV_PCIE) + 1545 Pcie->PathLength + Pcie->VendorDataLength; 1546 break; 1547 1548 default: 1549 1550 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV"); 1551 return (AE_ERROR); 1552 } 1553 1554 DtPopSubtable (); 1555 } 1556 1557 return (AE_OK); 1558 } 1559 1560 1561 /****************************************************************************** 1562 * 1563 * FUNCTION: DtCompileSlic 1564 * 1565 * PARAMETERS: List - Current field list pointer 1566 * 1567 * RETURN: Status 1568 * 1569 * DESCRIPTION: Compile SLIC. 1570 * 1571 *****************************************************************************/ 1572 1573 ACPI_STATUS 1574 DtCompileSlic ( 1575 void **List) 1576 { 1577 ACPI_STATUS Status; 1578 DT_SUBTABLE *Subtable; 1579 DT_SUBTABLE *ParentTable; 1580 DT_FIELD **PFieldList = (DT_FIELD **) List; 1581 1582 1583 while (*PFieldList) 1584 { 1585 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic, 1586 &Subtable); 1587 if (ACPI_FAILURE (Status)) 1588 { 1589 return (Status); 1590 } 1591 1592 ParentTable = DtPeekSubtable (); 1593 DtInsertSubtable (ParentTable, Subtable); 1594 DtPushSubtable (Subtable); 1595 DtPopSubtable (); 1596 } 1597 1598 return (AE_OK); 1599 } 1600 1601 1602 /****************************************************************************** 1603 * 1604 * FUNCTION: DtCompileSlit 1605 * 1606 * PARAMETERS: List - Current field list pointer 1607 * 1608 * RETURN: Status 1609 * 1610 * DESCRIPTION: Compile SLIT. 1611 * 1612 *****************************************************************************/ 1613 1614 ACPI_STATUS 1615 DtCompileSlit ( 1616 void **List) 1617 { 1618 ACPI_STATUS Status; 1619 DT_SUBTABLE *Subtable; 1620 DT_SUBTABLE *ParentTable; 1621 DT_FIELD **PFieldList = (DT_FIELD **) List; 1622 DT_FIELD *FieldList; 1623 UINT32 Localities; 1624 UINT8 *LocalityBuffer; 1625 1626 1627 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, 1628 &Subtable); 1629 if (ACPI_FAILURE (Status)) 1630 { 1631 return (Status); 1632 } 1633 1634 ParentTable = DtPeekSubtable (); 1635 DtInsertSubtable (ParentTable, Subtable); 1636 1637 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); 1638 LocalityBuffer = UtLocalCalloc (Localities); 1639 1640 /* Compile each locality buffer */ 1641 1642 FieldList = *PFieldList; 1643 while (FieldList) 1644 { 1645 DtCompileBuffer (LocalityBuffer, 1646 FieldList->Value, FieldList, Localities); 1647 1648 DtCreateSubtable (LocalityBuffer, Localities, &Subtable); 1649 DtInsertSubtable (ParentTable, Subtable); 1650 FieldList = FieldList->Next; 1651 } 1652 1653 ACPI_FREE (LocalityBuffer); 1654 return (AE_OK); 1655 } 1656 1657 1658 /****************************************************************************** 1659 * 1660 * FUNCTION: DtCompileSrat 1661 * 1662 * PARAMETERS: List - Current field list pointer 1663 * 1664 * RETURN: Status 1665 * 1666 * DESCRIPTION: Compile SRAT. 1667 * 1668 *****************************************************************************/ 1669 1670 ACPI_STATUS 1671 DtCompileSrat ( 1672 void **List) 1673 { 1674 ACPI_STATUS Status; 1675 DT_SUBTABLE *Subtable; 1676 DT_SUBTABLE *ParentTable; 1677 DT_FIELD **PFieldList = (DT_FIELD **) List; 1678 DT_FIELD *SubtableStart; 1679 ACPI_SUBTABLE_HEADER *SratHeader; 1680 ACPI_DMTABLE_INFO *InfoTable; 1681 1682 1683 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat, 1684 &Subtable); 1685 if (ACPI_FAILURE (Status)) 1686 { 1687 return (Status); 1688 } 1689 1690 ParentTable = DtPeekSubtable (); 1691 DtInsertSubtable (ParentTable, Subtable); 1692 1693 while (*PFieldList) 1694 { 1695 SubtableStart = *PFieldList; 1696 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr, 1697 &Subtable); 1698 if (ACPI_FAILURE (Status)) 1699 { 1700 return (Status); 1701 } 1702 1703 ParentTable = DtPeekSubtable (); 1704 DtInsertSubtable (ParentTable, Subtable); 1705 DtPushSubtable (Subtable); 1706 1707 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1708 1709 switch (SratHeader->Type) 1710 { 1711 case ACPI_SRAT_TYPE_CPU_AFFINITY: 1712 1713 InfoTable = AcpiDmTableInfoSrat0; 1714 break; 1715 1716 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 1717 1718 InfoTable = AcpiDmTableInfoSrat1; 1719 break; 1720 1721 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 1722 1723 InfoTable = AcpiDmTableInfoSrat2; 1724 break; 1725 1726 case ACPI_SRAT_TYPE_GICC_AFFINITY: 1727 1728 InfoTable = AcpiDmTableInfoSrat3; 1729 break; 1730 1731 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY: 1732 1733 InfoTable = AcpiDmTableInfoSrat4; 1734 break; 1735 1736 case ACPI_SRAT_TYPE_GENERIC_AFFINITY: 1737 1738 InfoTable = AcpiDmTableInfoSrat5; 1739 break; 1740 1741 default: 1742 1743 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT"); 1744 return (AE_ERROR); 1745 } 1746 1747 Status = DtCompileTable (PFieldList, InfoTable, &Subtable); 1748 if (ACPI_FAILURE (Status)) 1749 { 1750 return (Status); 1751 } 1752 1753 ParentTable = DtPeekSubtable (); 1754 DtInsertSubtable (ParentTable, Subtable); 1755 DtPopSubtable (); 1756 } 1757 1758 return (AE_OK); 1759 } 1760 1761 1762 /****************************************************************************** 1763 * 1764 * FUNCTION: DtCompileStao 1765 * 1766 * PARAMETERS: PFieldList - Current field list pointer 1767 * 1768 * RETURN: Status 1769 * 1770 * DESCRIPTION: Compile STAO. 1771 * 1772 *****************************************************************************/ 1773 1774 ACPI_STATUS 1775 DtCompileStao ( 1776 void **List) 1777 { 1778 DT_FIELD **PFieldList = (DT_FIELD **) List; 1779 DT_SUBTABLE *Subtable; 1780 DT_SUBTABLE *ParentTable; 1781 ACPI_STATUS Status; 1782 1783 1784 /* Compile the main table */ 1785 1786 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao, 1787 &Subtable); 1788 if (ACPI_FAILURE (Status)) 1789 { 1790 return (Status); 1791 } 1792 1793 ParentTable = DtPeekSubtable (); 1794 DtInsertSubtable (ParentTable, Subtable); 1795 1796 /* Compile each ASCII namestring as a subtable */ 1797 1798 while (*PFieldList) 1799 { 1800 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr, 1801 &Subtable); 1802 if (ACPI_FAILURE (Status)) 1803 { 1804 return (Status); 1805 } 1806 1807 ParentTable = DtPeekSubtable (); 1808 DtInsertSubtable (ParentTable, Subtable); 1809 } 1810 1811 return (AE_OK); 1812 } 1813 1814 1815 /****************************************************************************** 1816 * 1817 * FUNCTION: DtCompileTcpa 1818 * 1819 * PARAMETERS: PFieldList - Current field list pointer 1820 * 1821 * RETURN: Status 1822 * 1823 * DESCRIPTION: Compile TCPA. 1824 * 1825 *****************************************************************************/ 1826 1827 ACPI_STATUS 1828 DtCompileTcpa ( 1829 void **List) 1830 { 1831 DT_FIELD **PFieldList = (DT_FIELD **) List; 1832 DT_SUBTABLE *Subtable; 1833 ACPI_TABLE_TCPA_HDR *TcpaHeader; 1834 DT_SUBTABLE *ParentTable; 1835 ACPI_STATUS Status; 1836 1837 1838 /* Compile the main table */ 1839 1840 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr, 1841 &Subtable); 1842 if (ACPI_FAILURE (Status)) 1843 { 1844 return (Status); 1845 } 1846 1847 ParentTable = DtPeekSubtable (); 1848 DtInsertSubtable (ParentTable, Subtable); 1849 1850 /* 1851 * Examine the PlatformClass field to determine the table type. 1852 * Either a client or server table. Only one. 1853 */ 1854 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer); 1855 1856 switch (TcpaHeader->PlatformClass) 1857 { 1858 case ACPI_TCPA_CLIENT_TABLE: 1859 1860 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient, 1861 &Subtable); 1862 break; 1863 1864 case ACPI_TCPA_SERVER_TABLE: 1865 1866 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer, 1867 &Subtable); 1868 break; 1869 1870 default: 1871 1872 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 1873 TcpaHeader->PlatformClass); 1874 Status = AE_ERROR; 1875 break; 1876 } 1877 1878 ParentTable = DtPeekSubtable (); 1879 DtInsertSubtable (ParentTable, Subtable); 1880 return (Status); 1881 } 1882 1883 1884 /****************************************************************************** 1885 * 1886 * FUNCTION: DtCompileTpm2Rev3 1887 * 1888 * PARAMETERS: PFieldList - Current field list pointer 1889 * 1890 * RETURN: Status 1891 * 1892 * DESCRIPTION: Compile TPM2 revision 3 1893 * 1894 *****************************************************************************/ 1895 static ACPI_STATUS 1896 DtCompileTpm2Rev3 ( 1897 void **List) 1898 { 1899 DT_FIELD **PFieldList = (DT_FIELD **) List; 1900 DT_SUBTABLE *Subtable; 1901 ACPI_TABLE_TPM23 *Tpm23Header; 1902 DT_SUBTABLE *ParentTable; 1903 ACPI_STATUS Status = AE_OK; 1904 1905 1906 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23, 1907 &Subtable); 1908 1909 ParentTable = DtPeekSubtable (); 1910 DtInsertSubtable (ParentTable, Subtable); 1911 Tpm23Header = ACPI_CAST_PTR (ACPI_TABLE_TPM23, ParentTable->Buffer); 1912 1913 /* Subtable type depends on the StartMethod */ 1914 1915 switch (Tpm23Header->StartMethod) 1916 { 1917 case ACPI_TPM23_ACPI_START_METHOD: 1918 1919 /* Subtable specific to to ARM_SMC */ 1920 1921 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23a, 1922 &Subtable); 1923 if (ACPI_FAILURE (Status)) 1924 { 1925 return (Status); 1926 } 1927 1928 ParentTable = DtPeekSubtable (); 1929 DtInsertSubtable (ParentTable, Subtable); 1930 break; 1931 1932 default: 1933 break; 1934 } 1935 1936 return (Status); 1937 } 1938 1939 1940 /****************************************************************************** 1941 * 1942 * FUNCTION: DtCompileTpm2 1943 * 1944 * PARAMETERS: PFieldList - Current field list pointer 1945 * 1946 * RETURN: Status 1947 * 1948 * DESCRIPTION: Compile TPM2. 1949 * 1950 *****************************************************************************/ 1951 1952 ACPI_STATUS 1953 DtCompileTpm2 ( 1954 void **List) 1955 { 1956 DT_FIELD **PFieldList = (DT_FIELD **) List; 1957 DT_SUBTABLE *Subtable; 1958 ACPI_TABLE_TPM2 *Tpm2Header; 1959 DT_SUBTABLE *ParentTable; 1960 ACPI_STATUS Status = AE_OK; 1961 ACPI_TABLE_HEADER *Header; 1962 1963 1964 ParentTable = DtPeekSubtable (); 1965 1966 Header = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); 1967 1968 if (Header->Revision == 3) 1969 { 1970 return (DtCompileTpm2Rev3 (List)); 1971 } 1972 1973 /* Compile the main table */ 1974 1975 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2, 1976 &Subtable); 1977 if (ACPI_FAILURE (Status)) 1978 { 1979 return (Status); 1980 } 1981 1982 ParentTable = DtPeekSubtable (); 1983 DtInsertSubtable (ParentTable, Subtable); 1984 1985 Tpm2Header = ACPI_CAST_PTR (ACPI_TABLE_TPM2, ParentTable->Buffer); 1986 1987 /* Method parameters */ 1988 /* Optional: Log area minimum length */ 1989 /* Optional: Log area start address */ 1990 /* TBD: Optional fields above not fully implemented (not optional at this time) */ 1991 1992 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a, 1993 &Subtable); 1994 if (ACPI_FAILURE (Status)) 1995 { 1996 return (Status); 1997 } 1998 1999 ParentTable = DtPeekSubtable (); 2000 DtInsertSubtable (ParentTable, Subtable); 2001 2002 2003 /* Subtable type depends on the StartMethod */ 2004 2005 switch (Tpm2Header->StartMethod) 2006 { 2007 case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC: 2008 2009 /* Subtable specific to to ARM_SMC */ 2010 2011 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211, 2012 &Subtable); 2013 if (ACPI_FAILURE (Status)) 2014 { 2015 return (Status); 2016 } 2017 2018 ParentTable = DtPeekSubtable (); 2019 DtInsertSubtable (ParentTable, Subtable); 2020 break; 2021 2022 case ACPI_TPM2_START_METHOD: 2023 case ACPI_TPM2_MEMORY_MAPPED: 2024 case ACPI_TPM2_COMMAND_BUFFER: 2025 case ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD: 2026 break; 2027 2028 case ACPI_TPM2_RESERVED1: 2029 case ACPI_TPM2_RESERVED3: 2030 case ACPI_TPM2_RESERVED4: 2031 case ACPI_TPM2_RESERVED5: 2032 case ACPI_TPM2_RESERVED9: 2033 case ACPI_TPM2_RESERVED10: 2034 2035 AcpiOsPrintf ("\n**** Reserved TPM2 Start Method type 0x%X\n", 2036 Tpm2Header->StartMethod); 2037 Status = AE_ERROR; 2038 break; 2039 2040 case ACPI_TPM2_NOT_ALLOWED: 2041 default: 2042 2043 AcpiOsPrintf ("\n**** Unknown TPM2 Start Method type 0x%X\n", 2044 Tpm2Header->StartMethod); 2045 Status = AE_ERROR; 2046 break; 2047 } 2048 2049 return (Status); 2050 } 2051 2052 2053 /****************************************************************************** 2054 * 2055 * FUNCTION: DtGetGenericTableInfo 2056 * 2057 * PARAMETERS: Name - Generic type name 2058 * 2059 * RETURN: Info entry 2060 * 2061 * DESCRIPTION: Obtain table info for a generic name entry 2062 * 2063 *****************************************************************************/ 2064 2065 ACPI_DMTABLE_INFO * 2066 DtGetGenericTableInfo ( 2067 char *Name) 2068 { 2069 ACPI_DMTABLE_INFO *Info; 2070 UINT32 i; 2071 2072 2073 if (!Name) 2074 { 2075 return (NULL); 2076 } 2077 2078 /* Search info table for name match */ 2079 2080 for (i = 0; ; i++) 2081 { 2082 Info = AcpiDmTableInfoGeneric[i]; 2083 if (Info->Opcode == ACPI_DMT_EXIT) 2084 { 2085 Info = NULL; 2086 break; 2087 } 2088 2089 /* Use caseless compare for generic keywords */ 2090 2091 if (!AcpiUtStricmp (Name, Info->Name)) 2092 { 2093 break; 2094 } 2095 } 2096 2097 return (Info); 2098 } 2099 2100 2101 /****************************************************************************** 2102 * 2103 * FUNCTION: DtCompileUefi 2104 * 2105 * PARAMETERS: List - Current field list pointer 2106 * 2107 * RETURN: Status 2108 * 2109 * DESCRIPTION: Compile UEFI. 2110 * 2111 *****************************************************************************/ 2112 2113 ACPI_STATUS 2114 DtCompileUefi ( 2115 void **List) 2116 { 2117 ACPI_STATUS Status; 2118 DT_SUBTABLE *Subtable; 2119 DT_SUBTABLE *ParentTable; 2120 DT_FIELD **PFieldList = (DT_FIELD **) List; 2121 UINT16 *DataOffset; 2122 2123 2124 /* Compile the predefined portion of the UEFI table */ 2125 2126 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi, 2127 &Subtable); 2128 if (ACPI_FAILURE (Status)) 2129 { 2130 return (Status); 2131 } 2132 2133 DataOffset = (UINT16 *) (Subtable->Buffer + 16); 2134 *DataOffset = sizeof (ACPI_TABLE_UEFI); 2135 2136 ParentTable = DtPeekSubtable (); 2137 DtInsertSubtable (ParentTable, Subtable); 2138 2139 /* 2140 * Compile the "generic" portion of the UEFI table. This 2141 * part of the table is not predefined and any of the generic 2142 * operators may be used. 2143 */ 2144 DtCompileGeneric ((void **) PFieldList, NULL, NULL); 2145 return (AE_OK); 2146 } 2147 2148 2149 /****************************************************************************** 2150 * 2151 * FUNCTION: DtCompileVrtc 2152 * 2153 * PARAMETERS: List - Current field list pointer 2154 * 2155 * RETURN: Status 2156 * 2157 * DESCRIPTION: Compile VRTC. 2158 * 2159 *****************************************************************************/ 2160 2161 ACPI_STATUS 2162 DtCompileVrtc ( 2163 void **List) 2164 { 2165 ACPI_STATUS Status; 2166 2167 2168 Status = DtCompileTwoSubtables (List, 2169 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0); 2170 return (Status); 2171 } 2172 2173 2174 /****************************************************************************** 2175 * 2176 * FUNCTION: DtCompileWdat 2177 * 2178 * PARAMETERS: List - Current field list pointer 2179 * 2180 * RETURN: Status 2181 * 2182 * DESCRIPTION: Compile WDAT. 2183 * 2184 *****************************************************************************/ 2185 2186 ACPI_STATUS 2187 DtCompileWdat ( 2188 void **List) 2189 { 2190 ACPI_STATUS Status; 2191 2192 2193 Status = DtCompileTwoSubtables (List, 2194 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0); 2195 return (Status); 2196 } 2197 2198 2199 /****************************************************************************** 2200 * 2201 * FUNCTION: DtCompileWpbt 2202 * 2203 * PARAMETERS: List - Current field list pointer 2204 * 2205 * RETURN: Status 2206 * 2207 * DESCRIPTION: Compile WPBT. 2208 * 2209 *****************************************************************************/ 2210 2211 ACPI_STATUS 2212 DtCompileWpbt ( 2213 void **List) 2214 { 2215 DT_FIELD **PFieldList = (DT_FIELD **) List; 2216 DT_SUBTABLE *Subtable; 2217 DT_SUBTABLE *ParentTable; 2218 ACPI_TABLE_WPBT *Table; 2219 ACPI_STATUS Status; 2220 UINT16 Length; 2221 2222 2223 /* Compile the main table */ 2224 2225 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt, 2226 &Subtable); 2227 if (ACPI_FAILURE (Status)) 2228 { 2229 return (Status); 2230 } 2231 2232 ParentTable = DtPeekSubtable (); 2233 DtInsertSubtable (ParentTable, Subtable); 2234 2235 /* Compile the argument list subtable */ 2236 2237 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0, 2238 &Subtable); 2239 if (ACPI_FAILURE (Status)) 2240 { 2241 return (Status); 2242 } 2243 2244 /* Extract the length of the Arguments buffer, insert into main table */ 2245 2246 Length = (UINT16) Subtable->TotalLength; 2247 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer); 2248 Table->ArgumentsLength = Length; 2249 2250 ParentTable = DtPeekSubtable (); 2251 DtInsertSubtable (ParentTable, Subtable); 2252 return (AE_OK); 2253 } 2254 2255 2256 /****************************************************************************** 2257 * 2258 * FUNCTION: DtCompileXsdt 2259 * 2260 * PARAMETERS: List - Current field list pointer 2261 * 2262 * RETURN: Status 2263 * 2264 * DESCRIPTION: Compile XSDT. 2265 * 2266 *****************************************************************************/ 2267 2268 ACPI_STATUS 2269 DtCompileXsdt ( 2270 void **List) 2271 { 2272 DT_SUBTABLE *Subtable; 2273 DT_SUBTABLE *ParentTable; 2274 DT_FIELD *FieldList = *(DT_FIELD **) List; 2275 UINT64 Address; 2276 2277 2278 ParentTable = DtPeekSubtable (); 2279 2280 while (FieldList) 2281 { 2282 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO); 2283 2284 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable); 2285 DtInsertSubtable (ParentTable, Subtable); 2286 FieldList = FieldList->Next; 2287 } 2288 2289 return (AE_OK); 2290 } 2291 2292 2293 /****************************************************************************** 2294 * 2295 * FUNCTION: DtCompileGeneric 2296 * 2297 * PARAMETERS: List - Current field list pointer 2298 * Name - Field name to end generic compiling 2299 * Length - Compiled table length to return 2300 * 2301 * RETURN: Status 2302 * 2303 * DESCRIPTION: Compile generic unknown table. 2304 * 2305 *****************************************************************************/ 2306 2307 ACPI_STATUS 2308 DtCompileGeneric ( 2309 void **List, 2310 char *Name, 2311 UINT32 *Length) 2312 { 2313 ACPI_STATUS Status; 2314 DT_SUBTABLE *Subtable; 2315 DT_SUBTABLE *ParentTable; 2316 DT_FIELD **PFieldList = (DT_FIELD **) List; 2317 ACPI_DMTABLE_INFO *Info; 2318 2319 2320 ParentTable = DtPeekSubtable (); 2321 2322 /* 2323 * Compile the "generic" portion of the table. This 2324 * part of the table is not predefined and any of the generic 2325 * operators may be used. 2326 */ 2327 2328 /* Find any and all labels in the entire generic portion */ 2329 2330 DtDetectAllLabels (*PFieldList); 2331 2332 /* Now we can actually compile the parse tree */ 2333 2334 if (Length && *Length) 2335 { 2336 *Length = 0; 2337 } 2338 while (*PFieldList) 2339 { 2340 if (Name && !strcmp ((*PFieldList)->Name, Name)) 2341 { 2342 break; 2343 } 2344 2345 Info = DtGetGenericTableInfo ((*PFieldList)->Name); 2346 if (!Info) 2347 { 2348 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found", 2349 (*PFieldList)->Name); 2350 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2351 (*PFieldList), AslGbl_MsgBuffer); 2352 2353 *PFieldList = (*PFieldList)->Next; 2354 continue; 2355 } 2356 2357 Status = DtCompileTable (PFieldList, Info, 2358 &Subtable); 2359 if (ACPI_SUCCESS (Status)) 2360 { 2361 DtInsertSubtable (ParentTable, Subtable); 2362 if (Length) 2363 { 2364 *Length += Subtable->Length; 2365 } 2366 } 2367 else 2368 { 2369 *PFieldList = (*PFieldList)->Next; 2370 2371 if (Status == AE_NOT_FOUND) 2372 { 2373 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found", 2374 (*PFieldList)->Name); 2375 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2376 (*PFieldList), AslGbl_MsgBuffer); 2377 } 2378 } 2379 } 2380 2381 return (AE_OK); 2382 } 2383