1 /****************************************************************************** 2 * 3 * Module Name: dttable2.c - handling for specific ACPI tables 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 /* Compile all complex data tables, signatures starting with L-Z */ 45 46 #include "aslcompiler.h" 47 #include "dtcompiler.h" 48 49 #define _COMPONENT DT_COMPILER 50 ACPI_MODULE_NAME ("dttable2") 51 52 53 /****************************************************************************** 54 * 55 * FUNCTION: DtCompileLpit 56 * 57 * PARAMETERS: List - Current field list pointer 58 * 59 * RETURN: Status 60 * 61 * DESCRIPTION: Compile LPIT. 62 * 63 *****************************************************************************/ 64 65 ACPI_STATUS 66 DtCompileLpit ( 67 void **List) 68 { 69 ACPI_STATUS Status; 70 DT_SUBTABLE *Subtable; 71 DT_SUBTABLE *ParentTable; 72 DT_FIELD **PFieldList = (DT_FIELD **) List; 73 DT_FIELD *SubtableStart; 74 ACPI_DMTABLE_INFO *InfoTable; 75 ACPI_LPIT_HEADER *LpitHeader; 76 77 78 /* Note: Main table consists only of the standard ACPI table header */ 79 80 while (*PFieldList) 81 { 82 SubtableStart = *PFieldList; 83 84 /* LPIT Subtable header */ 85 86 Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr, 87 &Subtable, TRUE); 88 if (ACPI_FAILURE (Status)) 89 { 90 return (Status); 91 } 92 93 ParentTable = DtPeekSubtable (); 94 DtInsertSubtable (ParentTable, Subtable); 95 DtPushSubtable (Subtable); 96 97 LpitHeader = ACPI_CAST_PTR (ACPI_LPIT_HEADER, Subtable->Buffer); 98 99 switch (LpitHeader->Type) 100 { 101 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 102 103 InfoTable = AcpiDmTableInfoLpit0; 104 break; 105 106 default: 107 108 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "LPIT"); 109 return (AE_ERROR); 110 } 111 112 /* LPIT Subtable */ 113 114 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 115 if (ACPI_FAILURE (Status)) 116 { 117 return (Status); 118 } 119 120 ParentTable = DtPeekSubtable (); 121 DtInsertSubtable (ParentTable, Subtable); 122 DtPopSubtable (); 123 } 124 125 return (AE_OK); 126 } 127 128 129 /****************************************************************************** 130 * 131 * FUNCTION: DtCompileMadt 132 * 133 * PARAMETERS: List - Current field list pointer 134 * 135 * RETURN: Status 136 * 137 * DESCRIPTION: Compile MADT. 138 * 139 *****************************************************************************/ 140 141 ACPI_STATUS 142 DtCompileMadt ( 143 void **List) 144 { 145 ACPI_STATUS Status; 146 DT_SUBTABLE *Subtable; 147 DT_SUBTABLE *ParentTable; 148 DT_FIELD **PFieldList = (DT_FIELD **) List; 149 DT_FIELD *SubtableStart; 150 ACPI_SUBTABLE_HEADER *MadtHeader; 151 ACPI_DMTABLE_INFO *InfoTable; 152 153 154 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt, 155 &Subtable, TRUE); 156 if (ACPI_FAILURE (Status)) 157 { 158 return (Status); 159 } 160 161 ParentTable = DtPeekSubtable (); 162 DtInsertSubtable (ParentTable, Subtable); 163 164 while (*PFieldList) 165 { 166 SubtableStart = *PFieldList; 167 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr, 168 &Subtable, TRUE); 169 if (ACPI_FAILURE (Status)) 170 { 171 return (Status); 172 } 173 174 ParentTable = DtPeekSubtable (); 175 DtInsertSubtable (ParentTable, Subtable); 176 DtPushSubtable (Subtable); 177 178 MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 179 180 switch (MadtHeader->Type) 181 { 182 case ACPI_MADT_TYPE_LOCAL_APIC: 183 184 InfoTable = AcpiDmTableInfoMadt0; 185 break; 186 187 case ACPI_MADT_TYPE_IO_APIC: 188 189 InfoTable = AcpiDmTableInfoMadt1; 190 break; 191 192 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 193 194 InfoTable = AcpiDmTableInfoMadt2; 195 break; 196 197 case ACPI_MADT_TYPE_NMI_SOURCE: 198 199 InfoTable = AcpiDmTableInfoMadt3; 200 break; 201 202 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 203 204 InfoTable = AcpiDmTableInfoMadt4; 205 break; 206 207 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 208 209 InfoTable = AcpiDmTableInfoMadt5; 210 break; 211 212 case ACPI_MADT_TYPE_IO_SAPIC: 213 214 InfoTable = AcpiDmTableInfoMadt6; 215 break; 216 217 case ACPI_MADT_TYPE_LOCAL_SAPIC: 218 219 InfoTable = AcpiDmTableInfoMadt7; 220 break; 221 222 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 223 224 InfoTable = AcpiDmTableInfoMadt8; 225 break; 226 227 case ACPI_MADT_TYPE_LOCAL_X2APIC: 228 229 InfoTable = AcpiDmTableInfoMadt9; 230 break; 231 232 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 233 234 InfoTable = AcpiDmTableInfoMadt10; 235 break; 236 237 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 238 239 InfoTable = AcpiDmTableInfoMadt11; 240 break; 241 242 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 243 244 InfoTable = AcpiDmTableInfoMadt12; 245 break; 246 247 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 248 249 InfoTable = AcpiDmTableInfoMadt13; 250 break; 251 252 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 253 254 InfoTable = AcpiDmTableInfoMadt14; 255 break; 256 257 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 258 259 InfoTable = AcpiDmTableInfoMadt15; 260 break; 261 262 default: 263 264 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT"); 265 return (AE_ERROR); 266 } 267 268 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 269 if (ACPI_FAILURE (Status)) 270 { 271 return (Status); 272 } 273 274 ParentTable = DtPeekSubtable (); 275 DtInsertSubtable (ParentTable, Subtable); 276 DtPopSubtable (); 277 } 278 279 return (AE_OK); 280 } 281 282 283 /****************************************************************************** 284 * 285 * FUNCTION: DtCompileMcfg 286 * 287 * PARAMETERS: List - Current field list pointer 288 * 289 * RETURN: Status 290 * 291 * DESCRIPTION: Compile MCFG. 292 * 293 *****************************************************************************/ 294 295 ACPI_STATUS 296 DtCompileMcfg ( 297 void **List) 298 { 299 ACPI_STATUS Status; 300 301 302 Status = DtCompileTwoSubtables (List, 303 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0); 304 return (Status); 305 } 306 307 308 /****************************************************************************** 309 * 310 * FUNCTION: DtCompileMpst 311 * 312 * PARAMETERS: List - Current field list pointer 313 * 314 * RETURN: Status 315 * 316 * DESCRIPTION: Compile MPST. 317 * 318 *****************************************************************************/ 319 320 ACPI_STATUS 321 DtCompileMpst ( 322 void **List) 323 { 324 ACPI_STATUS Status; 325 DT_SUBTABLE *Subtable; 326 DT_SUBTABLE *ParentTable; 327 DT_FIELD **PFieldList = (DT_FIELD **) List; 328 ACPI_MPST_CHANNEL *MpstChannelInfo; 329 ACPI_MPST_POWER_NODE *MpstPowerNode; 330 ACPI_MPST_DATA_HDR *MpstDataHeader; 331 UINT16 SubtableCount; 332 UINT32 PowerStateCount; 333 UINT32 ComponentCount; 334 335 336 /* Main table */ 337 338 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable, TRUE); 339 if (ACPI_FAILURE (Status)) 340 { 341 return (Status); 342 } 343 344 ParentTable = DtPeekSubtable (); 345 DtInsertSubtable (ParentTable, Subtable); 346 DtPushSubtable (Subtable); 347 348 MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer); 349 SubtableCount = MpstChannelInfo->PowerNodeCount; 350 351 while (*PFieldList && SubtableCount) 352 { 353 /* Subtable: Memory Power Node(s) */ 354 355 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0, 356 &Subtable, TRUE); 357 if (ACPI_FAILURE (Status)) 358 { 359 return (Status); 360 } 361 362 ParentTable = DtPeekSubtable (); 363 DtInsertSubtable (ParentTable, Subtable); 364 DtPushSubtable (Subtable); 365 366 MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer); 367 PowerStateCount = MpstPowerNode->NumPowerStates; 368 ComponentCount = MpstPowerNode->NumPhysicalComponents; 369 370 ParentTable = DtPeekSubtable (); 371 372 /* Sub-subtables - Memory Power State Structure(s) */ 373 374 while (*PFieldList && PowerStateCount) 375 { 376 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A, 377 &Subtable, TRUE); 378 if (ACPI_FAILURE (Status)) 379 { 380 return (Status); 381 } 382 383 DtInsertSubtable (ParentTable, Subtable); 384 PowerStateCount--; 385 } 386 387 /* Sub-subtables - Physical Component ID Structure(s) */ 388 389 while (*PFieldList && ComponentCount) 390 { 391 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B, 392 &Subtable, TRUE); 393 if (ACPI_FAILURE (Status)) 394 { 395 return (Status); 396 } 397 398 DtInsertSubtable (ParentTable, Subtable); 399 ComponentCount--; 400 } 401 402 SubtableCount--; 403 DtPopSubtable (); 404 } 405 406 /* Subtable: Count of Memory Power State Characteristic structures */ 407 408 DtPopSubtable (); 409 410 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable, TRUE); 411 if (ACPI_FAILURE (Status)) 412 { 413 return (Status); 414 } 415 416 ParentTable = DtPeekSubtable (); 417 DtInsertSubtable (ParentTable, Subtable); 418 DtPushSubtable (Subtable); 419 420 MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer); 421 SubtableCount = MpstDataHeader->CharacteristicsCount; 422 423 ParentTable = DtPeekSubtable (); 424 425 /* Subtable: Memory Power State Characteristics structure(s) */ 426 427 while (*PFieldList && SubtableCount) 428 { 429 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2, 430 &Subtable, TRUE); 431 if (ACPI_FAILURE (Status)) 432 { 433 return (Status); 434 } 435 436 DtInsertSubtable (ParentTable, Subtable); 437 SubtableCount--; 438 } 439 440 DtPopSubtable (); 441 return (AE_OK); 442 } 443 444 445 /****************************************************************************** 446 * 447 * FUNCTION: DtCompileMsct 448 * 449 * PARAMETERS: List - Current field list pointer 450 * 451 * RETURN: Status 452 * 453 * DESCRIPTION: Compile MSCT. 454 * 455 *****************************************************************************/ 456 457 ACPI_STATUS 458 DtCompileMsct ( 459 void **List) 460 { 461 ACPI_STATUS Status; 462 463 464 Status = DtCompileTwoSubtables (List, 465 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0); 466 return (Status); 467 } 468 469 470 /****************************************************************************** 471 * 472 * FUNCTION: DtCompileMtmr 473 * 474 * PARAMETERS: List - Current field list pointer 475 * 476 * RETURN: Status 477 * 478 * DESCRIPTION: Compile MTMR. 479 * 480 *****************************************************************************/ 481 482 ACPI_STATUS 483 DtCompileMtmr ( 484 void **List) 485 { 486 ACPI_STATUS Status; 487 488 489 Status = DtCompileTwoSubtables (List, 490 AcpiDmTableInfoMtmr, AcpiDmTableInfoMtmr0); 491 return (Status); 492 } 493 494 495 /****************************************************************************** 496 * 497 * FUNCTION: DtCompileNfit 498 * 499 * PARAMETERS: List - Current field list pointer 500 * 501 * RETURN: Status 502 * 503 * DESCRIPTION: Compile NFIT. 504 * 505 *****************************************************************************/ 506 507 ACPI_STATUS 508 DtCompileNfit ( 509 void **List) 510 { 511 ACPI_STATUS Status; 512 DT_SUBTABLE *Subtable; 513 DT_SUBTABLE *ParentTable; 514 DT_FIELD **PFieldList = (DT_FIELD **) List; 515 DT_FIELD *SubtableStart; 516 ACPI_NFIT_HEADER *NfitHeader; 517 ACPI_DMTABLE_INFO *InfoTable; 518 UINT32 Count; 519 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 520 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 521 522 523 /* Main table */ 524 525 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit, 526 &Subtable, TRUE); 527 if (ACPI_FAILURE (Status)) 528 { 529 return (Status); 530 } 531 532 ParentTable = DtPeekSubtable (); 533 DtInsertSubtable (ParentTable, Subtable); 534 DtPushSubtable (Subtable); 535 536 /* Subtables */ 537 538 while (*PFieldList) 539 { 540 SubtableStart = *PFieldList; 541 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr, 542 &Subtable, TRUE); 543 if (ACPI_FAILURE (Status)) 544 { 545 return (Status); 546 } 547 548 ParentTable = DtPeekSubtable (); 549 DtInsertSubtable (ParentTable, Subtable); 550 DtPushSubtable (Subtable); 551 552 NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer); 553 554 switch (NfitHeader->Type) 555 { 556 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 557 558 InfoTable = AcpiDmTableInfoNfit0; 559 break; 560 561 case ACPI_NFIT_TYPE_MEMORY_MAP: 562 563 InfoTable = AcpiDmTableInfoNfit1; 564 break; 565 566 case ACPI_NFIT_TYPE_INTERLEAVE: 567 568 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer); 569 InfoTable = AcpiDmTableInfoNfit2; 570 break; 571 572 case ACPI_NFIT_TYPE_SMBIOS: 573 574 InfoTable = AcpiDmTableInfoNfit3; 575 break; 576 577 case ACPI_NFIT_TYPE_CONTROL_REGION: 578 579 InfoTable = AcpiDmTableInfoNfit4; 580 break; 581 582 case ACPI_NFIT_TYPE_DATA_REGION: 583 584 InfoTable = AcpiDmTableInfoNfit5; 585 break; 586 587 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 588 589 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer); 590 InfoTable = AcpiDmTableInfoNfit6; 591 break; 592 593 default: 594 595 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT"); 596 return (AE_ERROR); 597 } 598 599 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 600 if (ACPI_FAILURE (Status)) 601 { 602 return (Status); 603 } 604 605 ParentTable = DtPeekSubtable (); 606 DtInsertSubtable (ParentTable, Subtable); 607 DtPopSubtable (); 608 609 switch (NfitHeader->Type) 610 { 611 case ACPI_NFIT_TYPE_INTERLEAVE: 612 613 Count = 0; 614 DtPushSubtable (Subtable); 615 while (*PFieldList) 616 { 617 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a, 618 &Subtable, FALSE); 619 if (ACPI_FAILURE (Status)) 620 { 621 return (Status); 622 } 623 624 if (!Subtable) 625 { 626 DtPopSubtable (); 627 break; 628 } 629 630 ParentTable = DtPeekSubtable (); 631 DtInsertSubtable (ParentTable, Subtable); 632 Count++; 633 } 634 635 Interleave->LineCount = Count; 636 DtPopSubtable (); 637 break; 638 639 case ACPI_NFIT_TYPE_SMBIOS: 640 641 if (*PFieldList) 642 { 643 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a, 644 &Subtable, TRUE); 645 if (ACPI_FAILURE (Status)) 646 { 647 return (Status); 648 } 649 650 if (Subtable) 651 { 652 DtInsertSubtable (ParentTable, Subtable); 653 } 654 } 655 break; 656 657 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 658 659 Count = 0; 660 DtPushSubtable (Subtable); 661 while (*PFieldList) 662 { 663 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a, 664 &Subtable, FALSE); 665 if (ACPI_FAILURE (Status)) 666 { 667 return (Status); 668 } 669 670 if (!Subtable) 671 { 672 DtPopSubtable (); 673 break; 674 } 675 676 ParentTable = DtPeekSubtable (); 677 DtInsertSubtable (ParentTable, Subtable); 678 Count++; 679 } 680 681 Hint->HintCount = (UINT16) Count; 682 DtPopSubtable (); 683 break; 684 685 default: 686 break; 687 } 688 } 689 690 return (AE_OK); 691 } 692 693 694 /****************************************************************************** 695 * 696 * FUNCTION: DtCompilePcct 697 * 698 * PARAMETERS: List - Current field list pointer 699 * 700 * RETURN: Status 701 * 702 * DESCRIPTION: Compile PCCT. 703 * 704 *****************************************************************************/ 705 706 ACPI_STATUS 707 DtCompilePcct ( 708 void **List) 709 { 710 ACPI_STATUS Status; 711 DT_SUBTABLE *Subtable; 712 DT_SUBTABLE *ParentTable; 713 DT_FIELD **PFieldList = (DT_FIELD **) List; 714 DT_FIELD *SubtableStart; 715 ACPI_SUBTABLE_HEADER *PcctHeader; 716 ACPI_DMTABLE_INFO *InfoTable; 717 718 719 /* Main table */ 720 721 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct, 722 &Subtable, TRUE); 723 if (ACPI_FAILURE (Status)) 724 { 725 return (Status); 726 } 727 728 ParentTable = DtPeekSubtable (); 729 DtInsertSubtable (ParentTable, Subtable); 730 731 /* Subtables */ 732 733 while (*PFieldList) 734 { 735 SubtableStart = *PFieldList; 736 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr, 737 &Subtable, TRUE); 738 if (ACPI_FAILURE (Status)) 739 { 740 return (Status); 741 } 742 743 ParentTable = DtPeekSubtable (); 744 DtInsertSubtable (ParentTable, Subtable); 745 DtPushSubtable (Subtable); 746 747 PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 748 749 switch (PcctHeader->Type) 750 { 751 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 752 753 InfoTable = AcpiDmTableInfoPcct0; 754 break; 755 756 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 757 758 InfoTable = AcpiDmTableInfoPcct1; 759 break; 760 761 default: 762 763 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT"); 764 return (AE_ERROR); 765 } 766 767 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 768 if (ACPI_FAILURE (Status)) 769 { 770 return (Status); 771 } 772 773 ParentTable = DtPeekSubtable (); 774 DtInsertSubtable (ParentTable, Subtable); 775 DtPopSubtable (); 776 } 777 778 return (AE_OK); 779 } 780 781 782 /****************************************************************************** 783 * 784 * FUNCTION: DtCompilePmtt 785 * 786 * PARAMETERS: List - Current field list pointer 787 * 788 * RETURN: Status 789 * 790 * DESCRIPTION: Compile PMTT. 791 * 792 *****************************************************************************/ 793 794 ACPI_STATUS 795 DtCompilePmtt ( 796 void **List) 797 { 798 ACPI_STATUS Status; 799 DT_SUBTABLE *Subtable; 800 DT_SUBTABLE *ParentTable; 801 DT_FIELD **PFieldList = (DT_FIELD **) List; 802 DT_FIELD *SubtableStart; 803 ACPI_PMTT_HEADER *PmttHeader; 804 ACPI_PMTT_CONTROLLER *PmttController; 805 UINT16 DomainCount; 806 UINT8 PrevType = ACPI_PMTT_TYPE_SOCKET; 807 808 809 /* Main table */ 810 811 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE); 812 if (ACPI_FAILURE (Status)) 813 { 814 return (Status); 815 } 816 817 ParentTable = DtPeekSubtable (); 818 DtInsertSubtable (ParentTable, Subtable); 819 DtPushSubtable (Subtable); 820 821 while (*PFieldList) 822 { 823 SubtableStart = *PFieldList; 824 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr, 825 &Subtable, TRUE); 826 if (ACPI_FAILURE (Status)) 827 { 828 return (Status); 829 } 830 831 PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer); 832 while (PrevType >= PmttHeader->Type) 833 { 834 DtPopSubtable (); 835 836 if (PrevType == ACPI_PMTT_TYPE_SOCKET) 837 { 838 break; 839 } 840 841 PrevType--; 842 } 843 844 PrevType = PmttHeader->Type; 845 846 ParentTable = DtPeekSubtable (); 847 DtInsertSubtable (ParentTable, Subtable); 848 DtPushSubtable (Subtable); 849 850 switch (PmttHeader->Type) 851 { 852 case ACPI_PMTT_TYPE_SOCKET: 853 854 /* Subtable: Socket Structure */ 855 856 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0, 857 &Subtable, TRUE); 858 if (ACPI_FAILURE (Status)) 859 { 860 return (Status); 861 } 862 863 ParentTable = DtPeekSubtable (); 864 DtInsertSubtable (ParentTable, Subtable); 865 break; 866 867 case ACPI_PMTT_TYPE_CONTROLLER: 868 869 /* Subtable: Memory Controller Structure */ 870 871 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1, 872 &Subtable, TRUE); 873 if (ACPI_FAILURE (Status)) 874 { 875 return (Status); 876 } 877 878 ParentTable = DtPeekSubtable (); 879 DtInsertSubtable (ParentTable, Subtable); 880 881 PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER, 882 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER))); 883 DomainCount = PmttController->DomainCount; 884 885 while (DomainCount) 886 { 887 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a, 888 &Subtable, TRUE); 889 if (ACPI_FAILURE (Status)) 890 { 891 return (Status); 892 } 893 894 DtInsertSubtable (ParentTable, Subtable); 895 DomainCount--; 896 } 897 break; 898 899 case ACPI_PMTT_TYPE_DIMM: 900 901 /* Subtable: Physical Component Structure */ 902 903 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2, 904 &Subtable, TRUE); 905 if (ACPI_FAILURE (Status)) 906 { 907 return (Status); 908 } 909 910 ParentTable = DtPeekSubtable (); 911 DtInsertSubtable (ParentTable, Subtable); 912 break; 913 914 default: 915 916 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT"); 917 return (AE_ERROR); 918 } 919 } 920 921 return (Status); 922 } 923 924 925 /****************************************************************************** 926 * 927 * FUNCTION: DtCompileRsdt 928 * 929 * PARAMETERS: List - Current field list pointer 930 * 931 * RETURN: Status 932 * 933 * DESCRIPTION: Compile RSDT. 934 * 935 *****************************************************************************/ 936 937 ACPI_STATUS 938 DtCompileRsdt ( 939 void **List) 940 { 941 DT_SUBTABLE *Subtable; 942 DT_SUBTABLE *ParentTable; 943 DT_FIELD *FieldList = *(DT_FIELD **) List; 944 UINT32 Address; 945 946 947 ParentTable = DtPeekSubtable (); 948 949 while (FieldList) 950 { 951 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO); 952 953 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable); 954 DtInsertSubtable (ParentTable, Subtable); 955 FieldList = FieldList->Next; 956 } 957 958 return (AE_OK); 959 } 960 961 962 /****************************************************************************** 963 * 964 * FUNCTION: DtCompileS3pt 965 * 966 * PARAMETERS: PFieldList - Current field list pointer 967 * 968 * RETURN: Status 969 * 970 * DESCRIPTION: Compile S3PT (Pointed to by FPDT) 971 * 972 *****************************************************************************/ 973 974 ACPI_STATUS 975 DtCompileS3pt ( 976 DT_FIELD **PFieldList) 977 { 978 ACPI_STATUS Status; 979 ACPI_S3PT_HEADER *S3ptHeader; 980 DT_SUBTABLE *Subtable; 981 DT_SUBTABLE *ParentTable; 982 ACPI_DMTABLE_INFO *InfoTable; 983 DT_FIELD *SubtableStart; 984 985 986 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt, 987 &Gbl_RootTable, TRUE); 988 if (ACPI_FAILURE (Status)) 989 { 990 return (Status); 991 } 992 993 DtPushSubtable (Gbl_RootTable); 994 995 while (*PFieldList) 996 { 997 SubtableStart = *PFieldList; 998 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr, 999 &Subtable, TRUE); 1000 if (ACPI_FAILURE (Status)) 1001 { 1002 return (Status); 1003 } 1004 1005 ParentTable = DtPeekSubtable (); 1006 DtInsertSubtable (ParentTable, Subtable); 1007 DtPushSubtable (Subtable); 1008 1009 S3ptHeader = ACPI_CAST_PTR (ACPI_S3PT_HEADER, Subtable->Buffer); 1010 1011 switch (S3ptHeader->Type) 1012 { 1013 case ACPI_S3PT_TYPE_RESUME: 1014 1015 InfoTable = AcpiDmTableInfoS3pt0; 1016 break; 1017 1018 case ACPI_S3PT_TYPE_SUSPEND: 1019 1020 InfoTable = AcpiDmTableInfoS3pt1; 1021 break; 1022 1023 default: 1024 1025 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT"); 1026 return (AE_ERROR); 1027 } 1028 1029 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1030 if (ACPI_FAILURE (Status)) 1031 { 1032 return (Status); 1033 } 1034 1035 ParentTable = DtPeekSubtable (); 1036 DtInsertSubtable (ParentTable, Subtable); 1037 DtPopSubtable (); 1038 } 1039 1040 return (AE_OK); 1041 } 1042 1043 1044 /****************************************************************************** 1045 * 1046 * FUNCTION: DtCompileSlic 1047 * 1048 * PARAMETERS: List - Current field list pointer 1049 * 1050 * RETURN: Status 1051 * 1052 * DESCRIPTION: Compile SLIC. 1053 * 1054 *****************************************************************************/ 1055 1056 ACPI_STATUS 1057 DtCompileSlic ( 1058 void **List) 1059 { 1060 ACPI_STATUS Status; 1061 DT_SUBTABLE *Subtable; 1062 DT_SUBTABLE *ParentTable; 1063 DT_FIELD **PFieldList = (DT_FIELD **) List; 1064 1065 1066 while (*PFieldList) 1067 { 1068 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic, 1069 &Subtable, TRUE); 1070 if (ACPI_FAILURE (Status)) 1071 { 1072 return (Status); 1073 } 1074 1075 ParentTable = DtPeekSubtable (); 1076 DtInsertSubtable (ParentTable, Subtable); 1077 DtPushSubtable (Subtable); 1078 DtPopSubtable (); 1079 } 1080 1081 return (AE_OK); 1082 } 1083 1084 1085 /****************************************************************************** 1086 * 1087 * FUNCTION: DtCompileSlit 1088 * 1089 * PARAMETERS: List - Current field list pointer 1090 * 1091 * RETURN: Status 1092 * 1093 * DESCRIPTION: Compile SLIT. 1094 * 1095 *****************************************************************************/ 1096 1097 ACPI_STATUS 1098 DtCompileSlit ( 1099 void **List) 1100 { 1101 ACPI_STATUS Status; 1102 DT_SUBTABLE *Subtable; 1103 DT_SUBTABLE *ParentTable; 1104 DT_FIELD **PFieldList = (DT_FIELD **) List; 1105 DT_FIELD *FieldList; 1106 UINT32 Localities; 1107 UINT8 *LocalityBuffer; 1108 1109 1110 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, 1111 &Subtable, TRUE); 1112 if (ACPI_FAILURE (Status)) 1113 { 1114 return (Status); 1115 } 1116 1117 ParentTable = DtPeekSubtable (); 1118 DtInsertSubtable (ParentTable, Subtable); 1119 1120 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); 1121 LocalityBuffer = UtLocalCalloc (Localities); 1122 1123 /* Compile each locality buffer */ 1124 1125 FieldList = *PFieldList; 1126 while (FieldList) 1127 { 1128 DtCompileBuffer (LocalityBuffer, 1129 FieldList->Value, FieldList, Localities); 1130 1131 DtCreateSubtable (LocalityBuffer, Localities, &Subtable); 1132 DtInsertSubtable (ParentTable, Subtable); 1133 FieldList = FieldList->Next; 1134 } 1135 1136 ACPI_FREE (LocalityBuffer); 1137 return (AE_OK); 1138 } 1139 1140 1141 /****************************************************************************** 1142 * 1143 * FUNCTION: DtCompileSrat 1144 * 1145 * PARAMETERS: List - Current field list pointer 1146 * 1147 * RETURN: Status 1148 * 1149 * DESCRIPTION: Compile SRAT. 1150 * 1151 *****************************************************************************/ 1152 1153 ACPI_STATUS 1154 DtCompileSrat ( 1155 void **List) 1156 { 1157 ACPI_STATUS Status; 1158 DT_SUBTABLE *Subtable; 1159 DT_SUBTABLE *ParentTable; 1160 DT_FIELD **PFieldList = (DT_FIELD **) List; 1161 DT_FIELD *SubtableStart; 1162 ACPI_SUBTABLE_HEADER *SratHeader; 1163 ACPI_DMTABLE_INFO *InfoTable; 1164 1165 1166 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat, 1167 &Subtable, TRUE); 1168 if (ACPI_FAILURE (Status)) 1169 { 1170 return (Status); 1171 } 1172 1173 ParentTable = DtPeekSubtable (); 1174 DtInsertSubtable (ParentTable, Subtable); 1175 1176 while (*PFieldList) 1177 { 1178 SubtableStart = *PFieldList; 1179 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr, 1180 &Subtable, TRUE); 1181 if (ACPI_FAILURE (Status)) 1182 { 1183 return (Status); 1184 } 1185 1186 ParentTable = DtPeekSubtable (); 1187 DtInsertSubtable (ParentTable, Subtable); 1188 DtPushSubtable (Subtable); 1189 1190 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1191 1192 switch (SratHeader->Type) 1193 { 1194 case ACPI_SRAT_TYPE_CPU_AFFINITY: 1195 1196 InfoTable = AcpiDmTableInfoSrat0; 1197 break; 1198 1199 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 1200 1201 InfoTable = AcpiDmTableInfoSrat1; 1202 break; 1203 1204 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 1205 1206 InfoTable = AcpiDmTableInfoSrat2; 1207 break; 1208 1209 case ACPI_SRAT_TYPE_GICC_AFFINITY: 1210 1211 InfoTable = AcpiDmTableInfoSrat3; 1212 break; 1213 1214 default: 1215 1216 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT"); 1217 return (AE_ERROR); 1218 } 1219 1220 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1221 if (ACPI_FAILURE (Status)) 1222 { 1223 return (Status); 1224 } 1225 1226 ParentTable = DtPeekSubtable (); 1227 DtInsertSubtable (ParentTable, Subtable); 1228 DtPopSubtable (); 1229 } 1230 1231 return (AE_OK); 1232 } 1233 1234 1235 /****************************************************************************** 1236 * 1237 * FUNCTION: DtCompileStao 1238 * 1239 * PARAMETERS: PFieldList - Current field list pointer 1240 * 1241 * RETURN: Status 1242 * 1243 * DESCRIPTION: Compile STAO. 1244 * 1245 *****************************************************************************/ 1246 1247 ACPI_STATUS 1248 DtCompileStao ( 1249 void **List) 1250 { 1251 DT_FIELD **PFieldList = (DT_FIELD **) List; 1252 DT_SUBTABLE *Subtable; 1253 DT_SUBTABLE *ParentTable; 1254 ACPI_STATUS Status; 1255 1256 1257 /* Compile the main table */ 1258 1259 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao, 1260 &Subtable, TRUE); 1261 if (ACPI_FAILURE (Status)) 1262 { 1263 return (Status); 1264 } 1265 1266 ParentTable = DtPeekSubtable (); 1267 DtInsertSubtable (ParentTable, Subtable); 1268 1269 /* Compile each ASCII namestring as a subtable */ 1270 1271 while (*PFieldList) 1272 { 1273 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr, 1274 &Subtable, TRUE); 1275 if (ACPI_FAILURE (Status)) 1276 { 1277 return (Status); 1278 } 1279 1280 ParentTable = DtPeekSubtable (); 1281 DtInsertSubtable (ParentTable, Subtable); 1282 } 1283 1284 return (AE_OK); 1285 } 1286 1287 1288 /****************************************************************************** 1289 * 1290 * FUNCTION: DtCompileTcpa 1291 * 1292 * PARAMETERS: PFieldList - Current field list pointer 1293 * 1294 * RETURN: Status 1295 * 1296 * DESCRIPTION: Compile TCPA. 1297 * 1298 *****************************************************************************/ 1299 1300 ACPI_STATUS 1301 DtCompileTcpa ( 1302 void **List) 1303 { 1304 DT_FIELD **PFieldList = (DT_FIELD **) List; 1305 DT_SUBTABLE *Subtable; 1306 ACPI_TABLE_TCPA_HDR *TcpaHeader; 1307 DT_SUBTABLE *ParentTable; 1308 ACPI_STATUS Status; 1309 1310 1311 /* Compile the main table */ 1312 1313 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr, 1314 &Subtable, TRUE); 1315 if (ACPI_FAILURE (Status)) 1316 { 1317 return (Status); 1318 } 1319 1320 ParentTable = DtPeekSubtable (); 1321 DtInsertSubtable (ParentTable, Subtable); 1322 1323 /* 1324 * Examine the PlatformClass field to determine the table type. 1325 * Either a client or server table. Only one. 1326 */ 1327 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer); 1328 1329 switch (TcpaHeader->PlatformClass) 1330 { 1331 case ACPI_TCPA_CLIENT_TABLE: 1332 1333 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient, 1334 &Subtable, TRUE); 1335 break; 1336 1337 case ACPI_TCPA_SERVER_TABLE: 1338 1339 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer, 1340 &Subtable, TRUE); 1341 break; 1342 1343 default: 1344 1345 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 1346 TcpaHeader->PlatformClass); 1347 Status = AE_ERROR; 1348 break; 1349 } 1350 1351 ParentTable = DtPeekSubtable (); 1352 DtInsertSubtable (ParentTable, Subtable); 1353 return (Status); 1354 } 1355 1356 1357 /****************************************************************************** 1358 * 1359 * FUNCTION: DtGetGenericTableInfo 1360 * 1361 * PARAMETERS: Name - Generic type name 1362 * 1363 * RETURN: Info entry 1364 * 1365 * DESCRIPTION: Obtain table info for a generic name entry 1366 * 1367 *****************************************************************************/ 1368 1369 ACPI_DMTABLE_INFO * 1370 DtGetGenericTableInfo ( 1371 char *Name) 1372 { 1373 ACPI_DMTABLE_INFO *Info; 1374 UINT32 i; 1375 1376 1377 if (!Name) 1378 { 1379 return (NULL); 1380 } 1381 1382 /* Search info table for name match */ 1383 1384 for (i = 0; ; i++) 1385 { 1386 Info = AcpiDmTableInfoGeneric[i]; 1387 if (Info->Opcode == ACPI_DMT_EXIT) 1388 { 1389 Info = NULL; 1390 break; 1391 } 1392 1393 /* Use caseless compare for generic keywords */ 1394 1395 if (!AcpiUtStricmp (Name, Info->Name)) 1396 { 1397 break; 1398 } 1399 } 1400 1401 return (Info); 1402 } 1403 1404 1405 /****************************************************************************** 1406 * 1407 * FUNCTION: DtCompileUefi 1408 * 1409 * PARAMETERS: List - Current field list pointer 1410 * 1411 * RETURN: Status 1412 * 1413 * DESCRIPTION: Compile UEFI. 1414 * 1415 *****************************************************************************/ 1416 1417 ACPI_STATUS 1418 DtCompileUefi ( 1419 void **List) 1420 { 1421 ACPI_STATUS Status; 1422 DT_SUBTABLE *Subtable; 1423 DT_SUBTABLE *ParentTable; 1424 DT_FIELD **PFieldList = (DT_FIELD **) List; 1425 UINT16 *DataOffset; 1426 1427 1428 /* Compile the predefined portion of the UEFI table */ 1429 1430 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi, 1431 &Subtable, TRUE); 1432 if (ACPI_FAILURE (Status)) 1433 { 1434 return (Status); 1435 } 1436 1437 DataOffset = (UINT16 *) (Subtable->Buffer + 16); 1438 *DataOffset = sizeof (ACPI_TABLE_UEFI); 1439 1440 ParentTable = DtPeekSubtable (); 1441 DtInsertSubtable (ParentTable, Subtable); 1442 1443 /* 1444 * Compile the "generic" portion of the UEFI table. This 1445 * part of the table is not predefined and any of the generic 1446 * operators may be used. 1447 */ 1448 DtCompileGeneric ((void **) PFieldList, NULL, NULL); 1449 return (AE_OK); 1450 } 1451 1452 1453 /****************************************************************************** 1454 * 1455 * FUNCTION: DtCompileVrtc 1456 * 1457 * PARAMETERS: List - Current field list pointer 1458 * 1459 * RETURN: Status 1460 * 1461 * DESCRIPTION: Compile VRTC. 1462 * 1463 *****************************************************************************/ 1464 1465 ACPI_STATUS 1466 DtCompileVrtc ( 1467 void **List) 1468 { 1469 ACPI_STATUS Status; 1470 1471 1472 Status = DtCompileTwoSubtables (List, 1473 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0); 1474 return (Status); 1475 } 1476 1477 1478 /****************************************************************************** 1479 * 1480 * FUNCTION: DtCompileWdat 1481 * 1482 * PARAMETERS: List - Current field list pointer 1483 * 1484 * RETURN: Status 1485 * 1486 * DESCRIPTION: Compile WDAT. 1487 * 1488 *****************************************************************************/ 1489 1490 ACPI_STATUS 1491 DtCompileWdat ( 1492 void **List) 1493 { 1494 ACPI_STATUS Status; 1495 1496 1497 Status = DtCompileTwoSubtables (List, 1498 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0); 1499 return (Status); 1500 } 1501 1502 1503 /****************************************************************************** 1504 * 1505 * FUNCTION: DtCompileWpbt 1506 * 1507 * PARAMETERS: List - Current field list pointer 1508 * 1509 * RETURN: Status 1510 * 1511 * DESCRIPTION: Compile WPBT. 1512 * 1513 *****************************************************************************/ 1514 1515 ACPI_STATUS 1516 DtCompileWpbt ( 1517 void **List) 1518 { 1519 DT_FIELD **PFieldList = (DT_FIELD **) List; 1520 DT_SUBTABLE *Subtable; 1521 DT_SUBTABLE *ParentTable; 1522 ACPI_TABLE_WPBT *Table; 1523 ACPI_STATUS Status; 1524 UINT16 Length; 1525 1526 1527 /* Compile the main table */ 1528 1529 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt, 1530 &Subtable, TRUE); 1531 if (ACPI_FAILURE (Status)) 1532 { 1533 return (Status); 1534 } 1535 1536 ParentTable = DtPeekSubtable (); 1537 DtInsertSubtable (ParentTable, Subtable); 1538 1539 /* Compile the argument list subtable */ 1540 1541 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0, 1542 &Subtable, TRUE); 1543 if (ACPI_FAILURE (Status)) 1544 { 1545 return (Status); 1546 } 1547 1548 /* Extract the length of the Arguments buffer, insert into main table */ 1549 1550 Length = (UINT16) Subtable->TotalLength; 1551 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer); 1552 Table->ArgumentsLength = Length; 1553 1554 ParentTable = DtPeekSubtable (); 1555 DtInsertSubtable (ParentTable, Subtable); 1556 return (AE_OK); 1557 } 1558 1559 1560 /****************************************************************************** 1561 * 1562 * FUNCTION: DtCompileXsdt 1563 * 1564 * PARAMETERS: List - Current field list pointer 1565 * 1566 * RETURN: Status 1567 * 1568 * DESCRIPTION: Compile XSDT. 1569 * 1570 *****************************************************************************/ 1571 1572 ACPI_STATUS 1573 DtCompileXsdt ( 1574 void **List) 1575 { 1576 DT_SUBTABLE *Subtable; 1577 DT_SUBTABLE *ParentTable; 1578 DT_FIELD *FieldList = *(DT_FIELD **) List; 1579 UINT64 Address; 1580 1581 1582 ParentTable = DtPeekSubtable (); 1583 1584 while (FieldList) 1585 { 1586 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO); 1587 1588 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable); 1589 DtInsertSubtable (ParentTable, Subtable); 1590 FieldList = FieldList->Next; 1591 } 1592 1593 return (AE_OK); 1594 } 1595 1596 1597 /****************************************************************************** 1598 * 1599 * FUNCTION: DtCompileGeneric 1600 * 1601 * PARAMETERS: List - Current field list pointer 1602 * Name - Field name to end generic compiling 1603 * Length - Compiled table length to return 1604 * 1605 * RETURN: Status 1606 * 1607 * DESCRIPTION: Compile generic unknown table. 1608 * 1609 *****************************************************************************/ 1610 1611 ACPI_STATUS 1612 DtCompileGeneric ( 1613 void **List, 1614 char *Name, 1615 UINT32 *Length) 1616 { 1617 ACPI_STATUS Status; 1618 DT_SUBTABLE *Subtable; 1619 DT_SUBTABLE *ParentTable; 1620 DT_FIELD **PFieldList = (DT_FIELD **) List; 1621 ACPI_DMTABLE_INFO *Info; 1622 1623 1624 ParentTable = DtPeekSubtable (); 1625 1626 /* 1627 * Compile the "generic" portion of the table. This 1628 * part of the table is not predefined and any of the generic 1629 * operators may be used. 1630 */ 1631 1632 /* Find any and all labels in the entire generic portion */ 1633 1634 DtDetectAllLabels (*PFieldList); 1635 1636 /* Now we can actually compile the parse tree */ 1637 1638 if (Length && *Length) 1639 { 1640 *Length = 0; 1641 } 1642 while (*PFieldList) 1643 { 1644 if (Name && !strcmp ((*PFieldList)->Name, Name)) 1645 { 1646 break; 1647 } 1648 1649 Info = DtGetGenericTableInfo ((*PFieldList)->Name); 1650 if (!Info) 1651 { 1652 sprintf (MsgBuffer, "Generic data type \"%s\" not found", 1653 (*PFieldList)->Name); 1654 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 1655 (*PFieldList), MsgBuffer); 1656 1657 *PFieldList = (*PFieldList)->Next; 1658 continue; 1659 } 1660 1661 Status = DtCompileTable (PFieldList, Info, 1662 &Subtable, TRUE); 1663 if (ACPI_SUCCESS (Status)) 1664 { 1665 DtInsertSubtable (ParentTable, Subtable); 1666 if (Length) 1667 { 1668 *Length += Subtable->Length; 1669 } 1670 } 1671 else 1672 { 1673 *PFieldList = (*PFieldList)->Next; 1674 1675 if (Status == AE_NOT_FOUND) 1676 { 1677 sprintf (MsgBuffer, "Generic data type \"%s\" not found", 1678 (*PFieldList)->Name); 1679 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 1680 (*PFieldList), MsgBuffer); 1681 } 1682 } 1683 } 1684 1685 return (AE_OK); 1686 } 1687