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 - 2017, 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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, TRUE); 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 default: 701 702 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT"); 703 return (AE_ERROR); 704 } 705 706 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 707 if (ACPI_FAILURE (Status)) 708 { 709 return (Status); 710 } 711 712 ParentTable = DtPeekSubtable (); 713 DtInsertSubtable (ParentTable, Subtable); 714 DtPopSubtable (); 715 716 switch (NfitHeader->Type) 717 { 718 case ACPI_NFIT_TYPE_INTERLEAVE: 719 720 Count = 0; 721 DtPushSubtable (Subtable); 722 while (*PFieldList) 723 { 724 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a, 725 &Subtable, FALSE); 726 if (ACPI_FAILURE (Status)) 727 { 728 return (Status); 729 } 730 731 if (!Subtable) 732 { 733 DtPopSubtable (); 734 break; 735 } 736 737 ParentTable = DtPeekSubtable (); 738 DtInsertSubtable (ParentTable, Subtable); 739 Count++; 740 } 741 742 Interleave->LineCount = Count; 743 DtPopSubtable (); 744 break; 745 746 case ACPI_NFIT_TYPE_SMBIOS: 747 748 if (*PFieldList) 749 { 750 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a, 751 &Subtable, TRUE); 752 if (ACPI_FAILURE (Status)) 753 { 754 return (Status); 755 } 756 757 if (Subtable) 758 { 759 DtInsertSubtable (ParentTable, Subtable); 760 } 761 } 762 break; 763 764 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 765 766 Count = 0; 767 DtPushSubtable (Subtable); 768 while (*PFieldList) 769 { 770 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a, 771 &Subtable, FALSE); 772 if (ACPI_FAILURE (Status)) 773 { 774 return (Status); 775 } 776 777 if (!Subtable) 778 { 779 DtPopSubtable (); 780 break; 781 } 782 783 ParentTable = DtPeekSubtable (); 784 DtInsertSubtable (ParentTable, Subtable); 785 Count++; 786 } 787 788 Hint->HintCount = (UINT16) Count; 789 DtPopSubtable (); 790 break; 791 792 default: 793 break; 794 } 795 } 796 797 return (AE_OK); 798 } 799 800 801 /****************************************************************************** 802 * 803 * FUNCTION: DtCompilePcct 804 * 805 * PARAMETERS: List - Current field list pointer 806 * 807 * RETURN: Status 808 * 809 * DESCRIPTION: Compile PCCT. 810 * 811 *****************************************************************************/ 812 813 ACPI_STATUS 814 DtCompilePcct ( 815 void **List) 816 { 817 ACPI_STATUS Status; 818 DT_SUBTABLE *Subtable; 819 DT_SUBTABLE *ParentTable; 820 DT_FIELD **PFieldList = (DT_FIELD **) List; 821 DT_FIELD *SubtableStart; 822 ACPI_SUBTABLE_HEADER *PcctHeader; 823 ACPI_DMTABLE_INFO *InfoTable; 824 825 826 /* Main table */ 827 828 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct, 829 &Subtable, TRUE); 830 if (ACPI_FAILURE (Status)) 831 { 832 return (Status); 833 } 834 835 ParentTable = DtPeekSubtable (); 836 DtInsertSubtable (ParentTable, Subtable); 837 838 /* Subtables */ 839 840 while (*PFieldList) 841 { 842 SubtableStart = *PFieldList; 843 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr, 844 &Subtable, TRUE); 845 if (ACPI_FAILURE (Status)) 846 { 847 return (Status); 848 } 849 850 ParentTable = DtPeekSubtable (); 851 DtInsertSubtable (ParentTable, Subtable); 852 DtPushSubtable (Subtable); 853 854 PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 855 856 switch (PcctHeader->Type) 857 { 858 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 859 860 InfoTable = AcpiDmTableInfoPcct0; 861 break; 862 863 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 864 865 InfoTable = AcpiDmTableInfoPcct1; 866 break; 867 868 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 869 870 InfoTable = AcpiDmTableInfoPcct2; 871 break; 872 873 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 874 875 InfoTable = AcpiDmTableInfoPcct3; 876 break; 877 878 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 879 880 InfoTable = AcpiDmTableInfoPcct4; 881 break; 882 883 default: 884 885 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT"); 886 return (AE_ERROR); 887 } 888 889 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 890 if (ACPI_FAILURE (Status)) 891 { 892 return (Status); 893 } 894 895 ParentTable = DtPeekSubtable (); 896 DtInsertSubtable (ParentTable, Subtable); 897 DtPopSubtable (); 898 } 899 900 return (AE_OK); 901 } 902 903 904 /****************************************************************************** 905 * 906 * FUNCTION: DtCompilePdtt 907 * 908 * PARAMETERS: List - Current field list pointer 909 * 910 * RETURN: Status 911 * 912 * DESCRIPTION: Compile PDTT. 913 * 914 *****************************************************************************/ 915 916 ACPI_STATUS 917 DtCompilePdtt ( 918 void **List) 919 { 920 ACPI_STATUS Status; 921 DT_SUBTABLE *Subtable; 922 DT_SUBTABLE *ParentTable; 923 DT_FIELD **PFieldList = (DT_FIELD **) List; 924 ACPI_TABLE_PDTT *PdttHeader; 925 UINT32 Count = 0; 926 927 928 /* Main table */ 929 930 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt, &Subtable, TRUE); 931 if (ACPI_FAILURE (Status)) 932 { 933 return (Status); 934 } 935 936 ParentTable = DtPeekSubtable (); 937 DtInsertSubtable (ParentTable, Subtable); 938 939 PdttHeader = ACPI_CAST_PTR (ACPI_TABLE_PDTT, ParentTable->Buffer); 940 PdttHeader->ArrayOffset = sizeof (ACPI_TABLE_PDTT); 941 942 /* There is only one type of subtable at this time, no need to decode */ 943 944 while (*PFieldList) 945 { 946 /* List of subchannel IDs, each 2 bytes */ 947 948 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt0, 949 &Subtable, TRUE); 950 if (ACPI_FAILURE (Status)) 951 { 952 return (Status); 953 } 954 955 DtInsertSubtable (ParentTable, Subtable); 956 Count++; 957 } 958 959 PdttHeader->TriggerCount = (UINT8) Count; 960 return (AE_OK); 961 } 962 963 964 /****************************************************************************** 965 * 966 * FUNCTION: DtCompilePmtt 967 * 968 * PARAMETERS: List - Current field list pointer 969 * 970 * RETURN: Status 971 * 972 * DESCRIPTION: Compile PMTT. 973 * 974 *****************************************************************************/ 975 976 ACPI_STATUS 977 DtCompilePmtt ( 978 void **List) 979 { 980 ACPI_STATUS Status; 981 DT_SUBTABLE *Subtable; 982 DT_SUBTABLE *ParentTable; 983 DT_FIELD **PFieldList = (DT_FIELD **) List; 984 DT_FIELD *SubtableStart; 985 ACPI_PMTT_HEADER *PmttHeader; 986 ACPI_PMTT_CONTROLLER *PmttController; 987 UINT16 DomainCount; 988 UINT8 PrevType = ACPI_PMTT_TYPE_SOCKET; 989 990 991 /* Main table */ 992 993 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE); 994 if (ACPI_FAILURE (Status)) 995 { 996 return (Status); 997 } 998 999 ParentTable = DtPeekSubtable (); 1000 DtInsertSubtable (ParentTable, Subtable); 1001 DtPushSubtable (Subtable); 1002 1003 while (*PFieldList) 1004 { 1005 SubtableStart = *PFieldList; 1006 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr, 1007 &Subtable, TRUE); 1008 if (ACPI_FAILURE (Status)) 1009 { 1010 return (Status); 1011 } 1012 1013 PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer); 1014 while (PrevType >= PmttHeader->Type) 1015 { 1016 DtPopSubtable (); 1017 1018 if (PrevType == ACPI_PMTT_TYPE_SOCKET) 1019 { 1020 break; 1021 } 1022 1023 PrevType--; 1024 } 1025 1026 PrevType = PmttHeader->Type; 1027 1028 ParentTable = DtPeekSubtable (); 1029 DtInsertSubtable (ParentTable, Subtable); 1030 DtPushSubtable (Subtable); 1031 1032 switch (PmttHeader->Type) 1033 { 1034 case ACPI_PMTT_TYPE_SOCKET: 1035 1036 /* Subtable: Socket Structure */ 1037 1038 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0, 1039 &Subtable, TRUE); 1040 if (ACPI_FAILURE (Status)) 1041 { 1042 return (Status); 1043 } 1044 1045 ParentTable = DtPeekSubtable (); 1046 DtInsertSubtable (ParentTable, Subtable); 1047 break; 1048 1049 case ACPI_PMTT_TYPE_CONTROLLER: 1050 1051 /* Subtable: Memory Controller Structure */ 1052 1053 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1, 1054 &Subtable, TRUE); 1055 if (ACPI_FAILURE (Status)) 1056 { 1057 return (Status); 1058 } 1059 1060 ParentTable = DtPeekSubtable (); 1061 DtInsertSubtable (ParentTable, Subtable); 1062 1063 PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER, 1064 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER))); 1065 DomainCount = PmttController->DomainCount; 1066 1067 while (DomainCount) 1068 { 1069 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a, 1070 &Subtable, TRUE); 1071 if (ACPI_FAILURE (Status)) 1072 { 1073 return (Status); 1074 } 1075 1076 DtInsertSubtable (ParentTable, Subtable); 1077 DomainCount--; 1078 } 1079 break; 1080 1081 case ACPI_PMTT_TYPE_DIMM: 1082 1083 /* Subtable: Physical Component Structure */ 1084 1085 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2, 1086 &Subtable, TRUE); 1087 if (ACPI_FAILURE (Status)) 1088 { 1089 return (Status); 1090 } 1091 1092 ParentTable = DtPeekSubtable (); 1093 DtInsertSubtable (ParentTable, Subtable); 1094 break; 1095 1096 default: 1097 1098 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT"); 1099 return (AE_ERROR); 1100 } 1101 } 1102 1103 return (Status); 1104 } 1105 1106 1107 /****************************************************************************** 1108 * 1109 * FUNCTION: DtCompilePptt 1110 * 1111 * PARAMETERS: List - Current field list pointer 1112 * 1113 * RETURN: Status 1114 * 1115 * DESCRIPTION: Compile PPTT. 1116 * 1117 *****************************************************************************/ 1118 1119 ACPI_STATUS 1120 DtCompilePptt ( 1121 void **List) 1122 { 1123 ACPI_STATUS Status; 1124 ACPI_SUBTABLE_HEADER *PpttHeader; 1125 ACPI_PPTT_PROCESSOR *PpttProcessor = NULL; 1126 DT_SUBTABLE *Subtable; 1127 DT_SUBTABLE *ParentTable; 1128 ACPI_DMTABLE_INFO *InfoTable; 1129 DT_FIELD **PFieldList = (DT_FIELD **) List; 1130 DT_FIELD *SubtableStart; 1131 1132 1133 ParentTable = DtPeekSubtable (); 1134 while (*PFieldList) 1135 { 1136 SubtableStart = *PFieldList; 1137 1138 /* Compile PPTT subtable header */ 1139 1140 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPpttHdr, 1141 &Subtable, TRUE); 1142 if (ACPI_FAILURE (Status)) 1143 { 1144 return (Status); 1145 } 1146 DtInsertSubtable (ParentTable, Subtable); 1147 PpttHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1148 PpttHeader->Length = (UINT8)(Subtable->Length); 1149 1150 switch (PpttHeader->Type) 1151 { 1152 case ACPI_PPTT_TYPE_PROCESSOR: 1153 1154 InfoTable = AcpiDmTableInfoPptt0; 1155 break; 1156 1157 case ACPI_PPTT_TYPE_CACHE: 1158 1159 InfoTable = AcpiDmTableInfoPptt1; 1160 break; 1161 1162 case ACPI_PPTT_TYPE_ID: 1163 1164 InfoTable = AcpiDmTableInfoPptt2; 1165 break; 1166 1167 default: 1168 1169 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PPTT"); 1170 return (AE_ERROR); 1171 } 1172 1173 /* Compile PPTT subtable body */ 1174 1175 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1176 if (ACPI_FAILURE (Status)) 1177 { 1178 return (Status); 1179 } 1180 DtInsertSubtable (ParentTable, Subtable); 1181 PpttHeader->Length += (UINT8)(Subtable->Length); 1182 1183 /* Compile PPTT subtable additionals */ 1184 1185 switch (PpttHeader->Type) 1186 { 1187 case ACPI_PPTT_TYPE_PROCESSOR: 1188 1189 PpttProcessor = ACPI_SUB_PTR (ACPI_PPTT_PROCESSOR, 1190 Subtable->Buffer, sizeof (ACPI_SUBTABLE_HEADER)); 1191 if (PpttProcessor) 1192 { 1193 /* Compile initiator proximity domain list */ 1194 1195 PpttProcessor->NumberOfPrivResources = 0; 1196 while (*PFieldList) 1197 { 1198 Status = DtCompileTable (PFieldList, 1199 AcpiDmTableInfoPptt0a, &Subtable, TRUE); 1200 if (ACPI_FAILURE (Status)) 1201 { 1202 return (Status); 1203 } 1204 if (!Subtable) 1205 { 1206 break; 1207 } 1208 1209 DtInsertSubtable (ParentTable, Subtable); 1210 PpttHeader->Length += (UINT8)(Subtable->Length); 1211 PpttProcessor->NumberOfPrivResources++; 1212 } 1213 } 1214 break; 1215 1216 default: 1217 1218 break; 1219 } 1220 } 1221 1222 return (AE_OK); 1223 } 1224 1225 1226 /****************************************************************************** 1227 * 1228 * FUNCTION: DtCompileRsdt 1229 * 1230 * PARAMETERS: List - Current field list pointer 1231 * 1232 * RETURN: Status 1233 * 1234 * DESCRIPTION: Compile RSDT. 1235 * 1236 *****************************************************************************/ 1237 1238 ACPI_STATUS 1239 DtCompileRsdt ( 1240 void **List) 1241 { 1242 DT_SUBTABLE *Subtable; 1243 DT_SUBTABLE *ParentTable; 1244 DT_FIELD *FieldList = *(DT_FIELD **) List; 1245 UINT32 Address; 1246 1247 1248 ParentTable = DtPeekSubtable (); 1249 1250 while (FieldList) 1251 { 1252 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO); 1253 1254 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable); 1255 DtInsertSubtable (ParentTable, Subtable); 1256 FieldList = FieldList->Next; 1257 } 1258 1259 return (AE_OK); 1260 } 1261 1262 1263 /****************************************************************************** 1264 * 1265 * FUNCTION: DtCompileS3pt 1266 * 1267 * PARAMETERS: PFieldList - Current field list pointer 1268 * 1269 * RETURN: Status 1270 * 1271 * DESCRIPTION: Compile S3PT (Pointed to by FPDT) 1272 * 1273 *****************************************************************************/ 1274 1275 ACPI_STATUS 1276 DtCompileS3pt ( 1277 DT_FIELD **PFieldList) 1278 { 1279 ACPI_STATUS Status; 1280 ACPI_FPDT_HEADER *S3ptHeader; 1281 DT_SUBTABLE *Subtable; 1282 DT_SUBTABLE *ParentTable; 1283 ACPI_DMTABLE_INFO *InfoTable; 1284 DT_FIELD *SubtableStart; 1285 1286 1287 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt, 1288 &Gbl_RootTable, TRUE); 1289 if (ACPI_FAILURE (Status)) 1290 { 1291 return (Status); 1292 } 1293 1294 DtPushSubtable (Gbl_RootTable); 1295 1296 while (*PFieldList) 1297 { 1298 SubtableStart = *PFieldList; 1299 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr, 1300 &Subtable, TRUE); 1301 if (ACPI_FAILURE (Status)) 1302 { 1303 return (Status); 1304 } 1305 1306 ParentTable = DtPeekSubtable (); 1307 DtInsertSubtable (ParentTable, Subtable); 1308 DtPushSubtable (Subtable); 1309 1310 S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer); 1311 1312 switch (S3ptHeader->Type) 1313 { 1314 case ACPI_S3PT_TYPE_RESUME: 1315 1316 InfoTable = AcpiDmTableInfoS3pt0; 1317 break; 1318 1319 case ACPI_S3PT_TYPE_SUSPEND: 1320 1321 InfoTable = AcpiDmTableInfoS3pt1; 1322 break; 1323 1324 default: 1325 1326 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT"); 1327 return (AE_ERROR); 1328 } 1329 1330 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1331 if (ACPI_FAILURE (Status)) 1332 { 1333 return (Status); 1334 } 1335 1336 ParentTable = DtPeekSubtable (); 1337 DtInsertSubtable (ParentTable, Subtable); 1338 DtPopSubtable (); 1339 } 1340 1341 return (AE_OK); 1342 } 1343 1344 1345 /****************************************************************************** 1346 * 1347 * FUNCTION: DtCompileSdev 1348 * 1349 * PARAMETERS: List - Current field list pointer 1350 * 1351 * RETURN: Status 1352 * 1353 * DESCRIPTION: Compile SDEV. 1354 * 1355 *****************************************************************************/ 1356 1357 ACPI_STATUS 1358 DtCompileSdev ( 1359 void **List) 1360 { 1361 ACPI_STATUS Status; 1362 ACPI_SDEV_HEADER *SdevHeader; 1363 DT_SUBTABLE *Subtable; 1364 DT_SUBTABLE *ParentTable; 1365 ACPI_DMTABLE_INFO *InfoTable; 1366 DT_FIELD **PFieldList = (DT_FIELD **) List; 1367 DT_FIELD *SubtableStart; 1368 ACPI_SDEV_PCIE *Pcie = NULL; 1369 ACPI_SDEV_NAMESPACE *Namesp = NULL; 1370 UINT32 EntryCount; 1371 1372 1373 /* Subtables */ 1374 1375 while (*PFieldList) 1376 { 1377 /* Compile common SDEV subtable header */ 1378 1379 SubtableStart = *PFieldList; 1380 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdevHdr, 1381 &Subtable, TRUE); 1382 if (ACPI_FAILURE (Status)) 1383 { 1384 return (Status); 1385 } 1386 1387 ParentTable = DtPeekSubtable (); 1388 DtInsertSubtable (ParentTable, Subtable); 1389 DtPushSubtable (Subtable); 1390 1391 SdevHeader = ACPI_CAST_PTR (ACPI_SDEV_HEADER, Subtable->Buffer); 1392 SdevHeader->Length = (UINT8)(sizeof (ACPI_SDEV_HEADER)); 1393 1394 switch (SdevHeader->Type) 1395 { 1396 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1397 1398 InfoTable = AcpiDmTableInfoSdev0; 1399 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable->Buffer); 1400 break; 1401 1402 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1403 1404 InfoTable = AcpiDmTableInfoSdev1; 1405 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable->Buffer); 1406 break; 1407 1408 default: 1409 1410 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV"); 1411 return (AE_ERROR); 1412 } 1413 1414 /* Compile SDEV subtable body */ 1415 1416 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1417 if (ACPI_FAILURE (Status)) 1418 { 1419 return (Status); 1420 } 1421 1422 ParentTable = DtPeekSubtable (); 1423 DtInsertSubtable (ParentTable, Subtable); 1424 1425 /* Optional data fields are appended to the main subtable body */ 1426 1427 switch (SdevHeader->Type) 1428 { 1429 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1430 1431 /* Append DeviceId namespace string */ 1432 1433 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev0a, 1434 &Subtable, TRUE); 1435 if (ACPI_FAILURE (Status)) 1436 { 1437 return (Status); 1438 } 1439 1440 if (!Subtable) 1441 { 1442 break; 1443 } 1444 1445 ParentTable = DtPeekSubtable (); 1446 DtInsertSubtable (ParentTable, Subtable); 1447 1448 Namesp->DeviceIdOffset = sizeof (ACPI_SDEV_NAMESPACE); 1449 Namesp->DeviceIdLength = (UINT16) Subtable->Length; 1450 1451 /* Append Vendor data */ 1452 1453 Namesp->VendorDataLength = 0; 1454 Namesp->VendorDataOffset = 0; 1455 1456 if (*PFieldList) 1457 { 1458 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b, 1459 &Subtable, TRUE); 1460 if (ACPI_FAILURE (Status)) 1461 { 1462 return (Status); 1463 } 1464 1465 if (Subtable) 1466 { 1467 ParentTable = DtPeekSubtable (); 1468 DtInsertSubtable (ParentTable, Subtable); 1469 1470 Namesp->VendorDataOffset = 1471 Namesp->DeviceIdOffset + Namesp->DeviceIdLength; 1472 Namesp->VendorDataLength = 1473 (UINT16) Subtable->Length; 1474 } 1475 } 1476 1477 /* Final size of entire namespace structure */ 1478 1479 SdevHeader->Length = (UINT16) (sizeof (ACPI_SDEV_NAMESPACE) + 1480 Subtable->Length + Namesp->DeviceIdLength); 1481 break; 1482 1483 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1484 1485 /* Append the PCIe path info first */ 1486 1487 EntryCount = 0; 1488 while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device")) 1489 { 1490 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a, 1491 &Subtable, FALSE); 1492 if (ACPI_FAILURE (Status)) 1493 { 1494 return (Status); 1495 } 1496 1497 if (!Subtable) 1498 { 1499 DtPopSubtable (); 1500 break; 1501 } 1502 1503 ParentTable = DtPeekSubtable (); 1504 DtInsertSubtable (ParentTable, Subtable); 1505 EntryCount++; 1506 } 1507 1508 /* Path offset will point immediately after the main subtable */ 1509 1510 Pcie->PathOffset = sizeof (ACPI_SDEV_PCIE); 1511 Pcie->PathLength = (UINT16) 1512 (EntryCount * sizeof (ACPI_SDEV_PCIE_PATH)); 1513 1514 /* Append the Vendor Data last */ 1515 1516 Pcie->VendorDataLength = 0; 1517 Pcie->VendorDataOffset = 0; 1518 1519 if (*PFieldList) 1520 { 1521 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b, 1522 &Subtable, TRUE); 1523 if (ACPI_FAILURE (Status)) 1524 { 1525 return (Status); 1526 } 1527 1528 if (Subtable) 1529 { 1530 ParentTable = DtPeekSubtable (); 1531 DtInsertSubtable (ParentTable, Subtable); 1532 1533 Pcie->VendorDataOffset = 1534 Pcie->PathOffset + Pcie->PathLength; 1535 Pcie->VendorDataLength = (UINT16) 1536 Subtable->Length; 1537 } 1538 } 1539 1540 SdevHeader->Length = 1541 sizeof (ACPI_SDEV_PCIE) + 1542 Pcie->PathLength + Pcie->VendorDataLength; 1543 break; 1544 1545 default: 1546 1547 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV"); 1548 return (AE_ERROR); 1549 } 1550 1551 DtPopSubtable (); 1552 } 1553 1554 return (AE_OK); 1555 } 1556 1557 1558 /****************************************************************************** 1559 * 1560 * FUNCTION: DtCompileSlic 1561 * 1562 * PARAMETERS: List - Current field list pointer 1563 * 1564 * RETURN: Status 1565 * 1566 * DESCRIPTION: Compile SLIC. 1567 * 1568 *****************************************************************************/ 1569 1570 ACPI_STATUS 1571 DtCompileSlic ( 1572 void **List) 1573 { 1574 ACPI_STATUS Status; 1575 DT_SUBTABLE *Subtable; 1576 DT_SUBTABLE *ParentTable; 1577 DT_FIELD **PFieldList = (DT_FIELD **) List; 1578 1579 1580 while (*PFieldList) 1581 { 1582 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic, 1583 &Subtable, TRUE); 1584 if (ACPI_FAILURE (Status)) 1585 { 1586 return (Status); 1587 } 1588 1589 ParentTable = DtPeekSubtable (); 1590 DtInsertSubtable (ParentTable, Subtable); 1591 DtPushSubtable (Subtable); 1592 DtPopSubtable (); 1593 } 1594 1595 return (AE_OK); 1596 } 1597 1598 1599 /****************************************************************************** 1600 * 1601 * FUNCTION: DtCompileSlit 1602 * 1603 * PARAMETERS: List - Current field list pointer 1604 * 1605 * RETURN: Status 1606 * 1607 * DESCRIPTION: Compile SLIT. 1608 * 1609 *****************************************************************************/ 1610 1611 ACPI_STATUS 1612 DtCompileSlit ( 1613 void **List) 1614 { 1615 ACPI_STATUS Status; 1616 DT_SUBTABLE *Subtable; 1617 DT_SUBTABLE *ParentTable; 1618 DT_FIELD **PFieldList = (DT_FIELD **) List; 1619 DT_FIELD *FieldList; 1620 UINT32 Localities; 1621 UINT8 *LocalityBuffer; 1622 1623 1624 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, 1625 &Subtable, TRUE); 1626 if (ACPI_FAILURE (Status)) 1627 { 1628 return (Status); 1629 } 1630 1631 ParentTable = DtPeekSubtable (); 1632 DtInsertSubtable (ParentTable, Subtable); 1633 1634 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); 1635 LocalityBuffer = UtLocalCalloc (Localities); 1636 1637 /* Compile each locality buffer */ 1638 1639 FieldList = *PFieldList; 1640 while (FieldList) 1641 { 1642 DtCompileBuffer (LocalityBuffer, 1643 FieldList->Value, FieldList, Localities); 1644 1645 DtCreateSubtable (LocalityBuffer, Localities, &Subtable); 1646 DtInsertSubtable (ParentTable, Subtable); 1647 FieldList = FieldList->Next; 1648 } 1649 1650 ACPI_FREE (LocalityBuffer); 1651 return (AE_OK); 1652 } 1653 1654 1655 /****************************************************************************** 1656 * 1657 * FUNCTION: DtCompileSrat 1658 * 1659 * PARAMETERS: List - Current field list pointer 1660 * 1661 * RETURN: Status 1662 * 1663 * DESCRIPTION: Compile SRAT. 1664 * 1665 *****************************************************************************/ 1666 1667 ACPI_STATUS 1668 DtCompileSrat ( 1669 void **List) 1670 { 1671 ACPI_STATUS Status; 1672 DT_SUBTABLE *Subtable; 1673 DT_SUBTABLE *ParentTable; 1674 DT_FIELD **PFieldList = (DT_FIELD **) List; 1675 DT_FIELD *SubtableStart; 1676 ACPI_SUBTABLE_HEADER *SratHeader; 1677 ACPI_DMTABLE_INFO *InfoTable; 1678 1679 1680 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat, 1681 &Subtable, TRUE); 1682 if (ACPI_FAILURE (Status)) 1683 { 1684 return (Status); 1685 } 1686 1687 ParentTable = DtPeekSubtable (); 1688 DtInsertSubtable (ParentTable, Subtable); 1689 1690 while (*PFieldList) 1691 { 1692 SubtableStart = *PFieldList; 1693 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr, 1694 &Subtable, TRUE); 1695 if (ACPI_FAILURE (Status)) 1696 { 1697 return (Status); 1698 } 1699 1700 ParentTable = DtPeekSubtable (); 1701 DtInsertSubtable (ParentTable, Subtable); 1702 DtPushSubtable (Subtable); 1703 1704 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1705 1706 switch (SratHeader->Type) 1707 { 1708 case ACPI_SRAT_TYPE_CPU_AFFINITY: 1709 1710 InfoTable = AcpiDmTableInfoSrat0; 1711 break; 1712 1713 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 1714 1715 InfoTable = AcpiDmTableInfoSrat1; 1716 break; 1717 1718 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 1719 1720 InfoTable = AcpiDmTableInfoSrat2; 1721 break; 1722 1723 case ACPI_SRAT_TYPE_GICC_AFFINITY: 1724 1725 InfoTable = AcpiDmTableInfoSrat3; 1726 break; 1727 1728 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY: 1729 1730 InfoTable = AcpiDmTableInfoSrat4; 1731 break; 1732 1733 default: 1734 1735 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT"); 1736 return (AE_ERROR); 1737 } 1738 1739 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1740 if (ACPI_FAILURE (Status)) 1741 { 1742 return (Status); 1743 } 1744 1745 ParentTable = DtPeekSubtable (); 1746 DtInsertSubtable (ParentTable, Subtable); 1747 DtPopSubtable (); 1748 } 1749 1750 return (AE_OK); 1751 } 1752 1753 1754 /****************************************************************************** 1755 * 1756 * FUNCTION: DtCompileStao 1757 * 1758 * PARAMETERS: PFieldList - Current field list pointer 1759 * 1760 * RETURN: Status 1761 * 1762 * DESCRIPTION: Compile STAO. 1763 * 1764 *****************************************************************************/ 1765 1766 ACPI_STATUS 1767 DtCompileStao ( 1768 void **List) 1769 { 1770 DT_FIELD **PFieldList = (DT_FIELD **) List; 1771 DT_SUBTABLE *Subtable; 1772 DT_SUBTABLE *ParentTable; 1773 ACPI_STATUS Status; 1774 1775 1776 /* Compile the main table */ 1777 1778 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao, 1779 &Subtable, TRUE); 1780 if (ACPI_FAILURE (Status)) 1781 { 1782 return (Status); 1783 } 1784 1785 ParentTable = DtPeekSubtable (); 1786 DtInsertSubtable (ParentTable, Subtable); 1787 1788 /* Compile each ASCII namestring as a subtable */ 1789 1790 while (*PFieldList) 1791 { 1792 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr, 1793 &Subtable, TRUE); 1794 if (ACPI_FAILURE (Status)) 1795 { 1796 return (Status); 1797 } 1798 1799 ParentTable = DtPeekSubtable (); 1800 DtInsertSubtable (ParentTable, Subtable); 1801 } 1802 1803 return (AE_OK); 1804 } 1805 1806 1807 /****************************************************************************** 1808 * 1809 * FUNCTION: DtCompileTcpa 1810 * 1811 * PARAMETERS: PFieldList - Current field list pointer 1812 * 1813 * RETURN: Status 1814 * 1815 * DESCRIPTION: Compile TCPA. 1816 * 1817 *****************************************************************************/ 1818 1819 ACPI_STATUS 1820 DtCompileTcpa ( 1821 void **List) 1822 { 1823 DT_FIELD **PFieldList = (DT_FIELD **) List; 1824 DT_SUBTABLE *Subtable; 1825 ACPI_TABLE_TCPA_HDR *TcpaHeader; 1826 DT_SUBTABLE *ParentTable; 1827 ACPI_STATUS Status; 1828 1829 1830 /* Compile the main table */ 1831 1832 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr, 1833 &Subtable, TRUE); 1834 if (ACPI_FAILURE (Status)) 1835 { 1836 return (Status); 1837 } 1838 1839 ParentTable = DtPeekSubtable (); 1840 DtInsertSubtable (ParentTable, Subtable); 1841 1842 /* 1843 * Examine the PlatformClass field to determine the table type. 1844 * Either a client or server table. Only one. 1845 */ 1846 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer); 1847 1848 switch (TcpaHeader->PlatformClass) 1849 { 1850 case ACPI_TCPA_CLIENT_TABLE: 1851 1852 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient, 1853 &Subtable, TRUE); 1854 break; 1855 1856 case ACPI_TCPA_SERVER_TABLE: 1857 1858 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer, 1859 &Subtable, TRUE); 1860 break; 1861 1862 default: 1863 1864 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 1865 TcpaHeader->PlatformClass); 1866 Status = AE_ERROR; 1867 break; 1868 } 1869 1870 ParentTable = DtPeekSubtable (); 1871 DtInsertSubtable (ParentTable, Subtable); 1872 return (Status); 1873 } 1874 1875 1876 /****************************************************************************** 1877 * 1878 * FUNCTION: DtCompileTpm2 1879 * 1880 * PARAMETERS: PFieldList - Current field list pointer 1881 * 1882 * RETURN: Status 1883 * 1884 * DESCRIPTION: Compile TPM2. 1885 * 1886 *****************************************************************************/ 1887 1888 ACPI_STATUS 1889 DtCompileTpm2 ( 1890 void **List) 1891 { 1892 DT_FIELD **PFieldList = (DT_FIELD **) List; 1893 DT_SUBTABLE *Subtable; 1894 ACPI_TABLE_TPM2 *Tpm2Header; 1895 DT_SUBTABLE *ParentTable; 1896 ACPI_STATUS Status = AE_OK; 1897 1898 1899 /* Compile the main table */ 1900 1901 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2, 1902 &Subtable, TRUE); 1903 if (ACPI_FAILURE (Status)) 1904 { 1905 return (Status); 1906 } 1907 1908 ParentTable = DtPeekSubtable (); 1909 DtInsertSubtable (ParentTable, Subtable); 1910 1911 Tpm2Header = ACPI_CAST_PTR (ACPI_TABLE_TPM2, ParentTable->Buffer); 1912 1913 /* Method parameters */ 1914 /* Optional: Log area minimum length */ 1915 /* Optional: Log area start address */ 1916 /* TBD: Optional fields above not fully implemented (not optional at this time) */ 1917 1918 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a, 1919 &Subtable, TRUE); 1920 if (ACPI_FAILURE (Status)) 1921 { 1922 return (Status); 1923 } 1924 1925 ParentTable = DtPeekSubtable (); 1926 DtInsertSubtable (ParentTable, Subtable); 1927 1928 1929 /* Subtable type depends on the StartMethod */ 1930 1931 switch (Tpm2Header->StartMethod) 1932 { 1933 case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC: 1934 1935 /* Subtable specific to to ARM_SMC */ 1936 1937 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211, 1938 &Subtable, TRUE); 1939 if (ACPI_FAILURE (Status)) 1940 { 1941 return (Status); 1942 } 1943 1944 ParentTable = DtPeekSubtable (); 1945 DtInsertSubtable (ParentTable, Subtable); 1946 break; 1947 1948 case ACPI_TPM2_START_METHOD: 1949 case ACPI_TPM2_MEMORY_MAPPED: 1950 case ACPI_TPM2_COMMAND_BUFFER: 1951 case ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD: 1952 break; 1953 1954 case ACPI_TPM2_RESERVED1: 1955 case ACPI_TPM2_RESERVED3: 1956 case ACPI_TPM2_RESERVED4: 1957 case ACPI_TPM2_RESERVED5: 1958 case ACPI_TPM2_RESERVED9: 1959 case ACPI_TPM2_RESERVED10: 1960 1961 AcpiOsPrintf ("\n**** Reserved TPM2 Start Method type 0x%X\n", 1962 Tpm2Header->StartMethod); 1963 Status = AE_ERROR; 1964 break; 1965 1966 case ACPI_TPM2_NOT_ALLOWED: 1967 default: 1968 1969 AcpiOsPrintf ("\n**** Unknown TPM2 Start Method type 0x%X\n", 1970 Tpm2Header->StartMethod); 1971 Status = AE_ERROR; 1972 break; 1973 } 1974 1975 return (Status); 1976 } 1977 1978 1979 /****************************************************************************** 1980 * 1981 * FUNCTION: DtGetGenericTableInfo 1982 * 1983 * PARAMETERS: Name - Generic type name 1984 * 1985 * RETURN: Info entry 1986 * 1987 * DESCRIPTION: Obtain table info for a generic name entry 1988 * 1989 *****************************************************************************/ 1990 1991 ACPI_DMTABLE_INFO * 1992 DtGetGenericTableInfo ( 1993 char *Name) 1994 { 1995 ACPI_DMTABLE_INFO *Info; 1996 UINT32 i; 1997 1998 1999 if (!Name) 2000 { 2001 return (NULL); 2002 } 2003 2004 /* Search info table for name match */ 2005 2006 for (i = 0; ; i++) 2007 { 2008 Info = AcpiDmTableInfoGeneric[i]; 2009 if (Info->Opcode == ACPI_DMT_EXIT) 2010 { 2011 Info = NULL; 2012 break; 2013 } 2014 2015 /* Use caseless compare for generic keywords */ 2016 2017 if (!AcpiUtStricmp (Name, Info->Name)) 2018 { 2019 break; 2020 } 2021 } 2022 2023 return (Info); 2024 } 2025 2026 2027 /****************************************************************************** 2028 * 2029 * FUNCTION: DtCompileUefi 2030 * 2031 * PARAMETERS: List - Current field list pointer 2032 * 2033 * RETURN: Status 2034 * 2035 * DESCRIPTION: Compile UEFI. 2036 * 2037 *****************************************************************************/ 2038 2039 ACPI_STATUS 2040 DtCompileUefi ( 2041 void **List) 2042 { 2043 ACPI_STATUS Status; 2044 DT_SUBTABLE *Subtable; 2045 DT_SUBTABLE *ParentTable; 2046 DT_FIELD **PFieldList = (DT_FIELD **) List; 2047 UINT16 *DataOffset; 2048 2049 2050 /* Compile the predefined portion of the UEFI table */ 2051 2052 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi, 2053 &Subtable, TRUE); 2054 if (ACPI_FAILURE (Status)) 2055 { 2056 return (Status); 2057 } 2058 2059 DataOffset = (UINT16 *) (Subtable->Buffer + 16); 2060 *DataOffset = sizeof (ACPI_TABLE_UEFI); 2061 2062 ParentTable = DtPeekSubtable (); 2063 DtInsertSubtable (ParentTable, Subtable); 2064 2065 /* 2066 * Compile the "generic" portion of the UEFI table. This 2067 * part of the table is not predefined and any of the generic 2068 * operators may be used. 2069 */ 2070 DtCompileGeneric ((void **) PFieldList, NULL, NULL); 2071 return (AE_OK); 2072 } 2073 2074 2075 /****************************************************************************** 2076 * 2077 * FUNCTION: DtCompileVrtc 2078 * 2079 * PARAMETERS: List - Current field list pointer 2080 * 2081 * RETURN: Status 2082 * 2083 * DESCRIPTION: Compile VRTC. 2084 * 2085 *****************************************************************************/ 2086 2087 ACPI_STATUS 2088 DtCompileVrtc ( 2089 void **List) 2090 { 2091 ACPI_STATUS Status; 2092 2093 2094 Status = DtCompileTwoSubtables (List, 2095 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0); 2096 return (Status); 2097 } 2098 2099 2100 /****************************************************************************** 2101 * 2102 * FUNCTION: DtCompileWdat 2103 * 2104 * PARAMETERS: List - Current field list pointer 2105 * 2106 * RETURN: Status 2107 * 2108 * DESCRIPTION: Compile WDAT. 2109 * 2110 *****************************************************************************/ 2111 2112 ACPI_STATUS 2113 DtCompileWdat ( 2114 void **List) 2115 { 2116 ACPI_STATUS Status; 2117 2118 2119 Status = DtCompileTwoSubtables (List, 2120 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0); 2121 return (Status); 2122 } 2123 2124 2125 /****************************************************************************** 2126 * 2127 * FUNCTION: DtCompileWpbt 2128 * 2129 * PARAMETERS: List - Current field list pointer 2130 * 2131 * RETURN: Status 2132 * 2133 * DESCRIPTION: Compile WPBT. 2134 * 2135 *****************************************************************************/ 2136 2137 ACPI_STATUS 2138 DtCompileWpbt ( 2139 void **List) 2140 { 2141 DT_FIELD **PFieldList = (DT_FIELD **) List; 2142 DT_SUBTABLE *Subtable; 2143 DT_SUBTABLE *ParentTable; 2144 ACPI_TABLE_WPBT *Table; 2145 ACPI_STATUS Status; 2146 UINT16 Length; 2147 2148 2149 /* Compile the main table */ 2150 2151 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt, 2152 &Subtable, TRUE); 2153 if (ACPI_FAILURE (Status)) 2154 { 2155 return (Status); 2156 } 2157 2158 ParentTable = DtPeekSubtable (); 2159 DtInsertSubtable (ParentTable, Subtable); 2160 2161 /* Compile the argument list subtable */ 2162 2163 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0, 2164 &Subtable, TRUE); 2165 if (ACPI_FAILURE (Status)) 2166 { 2167 return (Status); 2168 } 2169 2170 /* Extract the length of the Arguments buffer, insert into main table */ 2171 2172 Length = (UINT16) Subtable->TotalLength; 2173 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer); 2174 Table->ArgumentsLength = Length; 2175 2176 ParentTable = DtPeekSubtable (); 2177 DtInsertSubtable (ParentTable, Subtable); 2178 return (AE_OK); 2179 } 2180 2181 2182 /****************************************************************************** 2183 * 2184 * FUNCTION: DtCompileXsdt 2185 * 2186 * PARAMETERS: List - Current field list pointer 2187 * 2188 * RETURN: Status 2189 * 2190 * DESCRIPTION: Compile XSDT. 2191 * 2192 *****************************************************************************/ 2193 2194 ACPI_STATUS 2195 DtCompileXsdt ( 2196 void **List) 2197 { 2198 DT_SUBTABLE *Subtable; 2199 DT_SUBTABLE *ParentTable; 2200 DT_FIELD *FieldList = *(DT_FIELD **) List; 2201 UINT64 Address; 2202 2203 2204 ParentTable = DtPeekSubtable (); 2205 2206 while (FieldList) 2207 { 2208 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO); 2209 2210 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable); 2211 DtInsertSubtable (ParentTable, Subtable); 2212 FieldList = FieldList->Next; 2213 } 2214 2215 return (AE_OK); 2216 } 2217 2218 2219 /****************************************************************************** 2220 * 2221 * FUNCTION: DtCompileGeneric 2222 * 2223 * PARAMETERS: List - Current field list pointer 2224 * Name - Field name to end generic compiling 2225 * Length - Compiled table length to return 2226 * 2227 * RETURN: Status 2228 * 2229 * DESCRIPTION: Compile generic unknown table. 2230 * 2231 *****************************************************************************/ 2232 2233 ACPI_STATUS 2234 DtCompileGeneric ( 2235 void **List, 2236 char *Name, 2237 UINT32 *Length) 2238 { 2239 ACPI_STATUS Status; 2240 DT_SUBTABLE *Subtable; 2241 DT_SUBTABLE *ParentTable; 2242 DT_FIELD **PFieldList = (DT_FIELD **) List; 2243 ACPI_DMTABLE_INFO *Info; 2244 2245 2246 ParentTable = DtPeekSubtable (); 2247 2248 /* 2249 * Compile the "generic" portion of the table. This 2250 * part of the table is not predefined and any of the generic 2251 * operators may be used. 2252 */ 2253 2254 /* Find any and all labels in the entire generic portion */ 2255 2256 DtDetectAllLabels (*PFieldList); 2257 2258 /* Now we can actually compile the parse tree */ 2259 2260 if (Length && *Length) 2261 { 2262 *Length = 0; 2263 } 2264 while (*PFieldList) 2265 { 2266 if (Name && !strcmp ((*PFieldList)->Name, Name)) 2267 { 2268 break; 2269 } 2270 2271 Info = DtGetGenericTableInfo ((*PFieldList)->Name); 2272 if (!Info) 2273 { 2274 sprintf (MsgBuffer, "Generic data type \"%s\" not found", 2275 (*PFieldList)->Name); 2276 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2277 (*PFieldList), MsgBuffer); 2278 2279 *PFieldList = (*PFieldList)->Next; 2280 continue; 2281 } 2282 2283 Status = DtCompileTable (PFieldList, Info, 2284 &Subtable, TRUE); 2285 if (ACPI_SUCCESS (Status)) 2286 { 2287 DtInsertSubtable (ParentTable, Subtable); 2288 if (Length) 2289 { 2290 *Length += Subtable->Length; 2291 } 2292 } 2293 else 2294 { 2295 *PFieldList = (*PFieldList)->Next; 2296 2297 if (Status == AE_NOT_FOUND) 2298 { 2299 sprintf (MsgBuffer, "Generic data type \"%s\" not found", 2300 (*PFieldList)->Name); 2301 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 2302 (*PFieldList), MsgBuffer); 2303 } 2304 } 2305 } 2306 2307 return (AE_OK); 2308 } 2309