dttable.c revision 1.1.1.1
1 /****************************************************************************** 2 * 3 * Module Name: dttable.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 - 2010, 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 #define __DTTABLE_C__ 117 118 /* Compile all complex data tables */ 119 120 #include "aslcompiler.h" 121 #include "dtcompiler.h" 122 123 #define _COMPONENT DT_COMPILER 124 ACPI_MODULE_NAME ("dttable") 125 126 127 /* TBD: merge these into dmtbinfo.c? */ 128 129 static ACPI_DMTABLE_INFO TableInfoAsfAddress[] = 130 { 131 {ACPI_DMT_BUFFER, 0, "Addresses", 0}, 132 {ACPI_DMT_EXIT, 0, NULL, 0} 133 }; 134 135 static ACPI_DMTABLE_INFO TableInfoDmarPciPath[] = 136 { 137 {ACPI_DMT_PCI_PATH, 0, "PCI Path", 0}, 138 {ACPI_DMT_EXIT, 0, NULL, 0} 139 }; 140 141 142 /* TBD: move to acmacros.h */ 143 144 #define ACPI_SUB_PTR(t, a, b) \ 145 ACPI_CAST_PTR (t, (ACPI_CAST_PTR (UINT8, (a)) - (ACPI_SIZE)(b))) 146 147 148 /* Local prototypes */ 149 150 static ACPI_STATUS 151 DtCompileTwoSubtables ( 152 void **List, 153 ACPI_DMTABLE_INFO *TableInfo1, 154 ACPI_DMTABLE_INFO *TableInfo2); 155 156 157 /****************************************************************************** 158 * 159 * FUNCTION: DtCompileTwoSubtables 160 * 161 * PARAMETERS: List - Current field list pointer 162 * TableInfo1 - Info table 1 163 * TableInfo1 - Info table 2 164 * 165 * RETURN: Status 166 * 167 * DESCRIPTION: Compile tables with a header and one or more same subtables. 168 * Include CPEP, EINJ, ERST, MCFG, MSCT, WDAT 169 * 170 *****************************************************************************/ 171 172 static ACPI_STATUS 173 DtCompileTwoSubtables ( 174 void **List, 175 ACPI_DMTABLE_INFO *TableInfo1, 176 ACPI_DMTABLE_INFO *TableInfo2) 177 { 178 ACPI_STATUS Status; 179 DT_SUBTABLE *Subtable; 180 DT_SUBTABLE *ParentTable; 181 DT_FIELD **PFieldList = (DT_FIELD **) List; 182 183 184 Status = DtCompileTable (PFieldList, TableInfo1, &Subtable, TRUE); 185 if (ACPI_FAILURE (Status)) 186 { 187 return (Status); 188 } 189 190 ParentTable = DtPeekSubtable (); 191 DtInsertSubtable (ParentTable, Subtable); 192 193 while (*PFieldList) 194 { 195 Status = DtCompileTable (PFieldList, TableInfo2, &Subtable, FALSE); 196 if (ACPI_FAILURE (Status)) 197 { 198 return (Status); 199 } 200 201 DtInsertSubtable (ParentTable, Subtable); 202 } 203 204 return (AE_OK); 205 } 206 207 208 /****************************************************************************** 209 * 210 * FUNCTION: DtCompileFacs 211 * 212 * PARAMETERS: PFieldList - Current field list pointer 213 * 214 * RETURN: Status 215 * 216 * DESCRIPTION: Compile FACS. 217 * 218 *****************************************************************************/ 219 220 ACPI_STATUS 221 DtCompileFacs ( 222 DT_FIELD **PFieldList) 223 { 224 DT_SUBTABLE *Subtable; 225 UINT8 *ReservedBuffer; 226 ACPI_STATUS Status; 227 UINT32 ReservedSize; 228 229 230 Status = DtCompileTable (PFieldList, AcpiDmTableInfoFacs, 231 &Gbl_RootTable, TRUE); 232 if (ACPI_FAILURE (Status)) 233 { 234 return (Status); 235 } 236 237 /* Large FACS reserved area at the end of the table */ 238 239 ReservedSize = (UINT32) sizeof (((ACPI_TABLE_FACS *) NULL)->Reserved1); 240 ReservedBuffer = UtLocalCalloc (ReservedSize); 241 242 DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable); 243 244 ACPI_FREE (ReservedBuffer); 245 DtInsertSubtable (Gbl_RootTable, Subtable); 246 return (AE_OK); 247 } 248 249 250 /****************************************************************************** 251 * 252 * FUNCTION: DtCompileRsdp 253 * 254 * PARAMETERS: PFieldList - Current field list pointer 255 * 256 * RETURN: Status 257 * 258 * DESCRIPTION: Compile RSDP. 259 * 260 *****************************************************************************/ 261 262 ACPI_STATUS 263 DtCompileRsdp ( 264 DT_FIELD **PFieldList) 265 { 266 DT_SUBTABLE *Subtable; 267 ACPI_TABLE_RSDP *Table; 268 ACPI_STATUS Status; 269 270 271 Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp1, 272 &Gbl_RootTable, TRUE); 273 if (ACPI_FAILURE (Status)) 274 { 275 return (Status); 276 } 277 278 Table = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Gbl_RootTable->Buffer); 279 DtSetTableChecksum (&Table->Checksum); 280 281 if (Table->Revision > 0) 282 { 283 Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp2, 284 &Subtable, TRUE); 285 if (ACPI_FAILURE (Status)) 286 { 287 return (Status); 288 } 289 290 DtInsertSubtable (Gbl_RootTable, Subtable); 291 DtSetTableChecksum (&Table->ExtendedChecksum); 292 } 293 294 return (AE_OK); 295 } 296 297 298 /****************************************************************************** 299 * 300 * FUNCTION: DtCompileAsf 301 * 302 * PARAMETERS: List - Current field list pointer 303 * 304 * RETURN: Status 305 * 306 * DESCRIPTION: Compile ASF!. 307 * 308 *****************************************************************************/ 309 310 ACPI_STATUS 311 DtCompileAsf ( 312 void **List) 313 { 314 ACPI_ASF_INFO *AsfTable; 315 DT_SUBTABLE *Subtable; 316 DT_SUBTABLE *ParentTable; 317 ACPI_DMTABLE_INFO *InfoTable; 318 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 319 UINT32 DataCount = 0; 320 ACPI_STATUS Status; 321 UINT32 i; 322 DT_FIELD **PFieldList = (DT_FIELD **) List; 323 DT_FIELD *SubtableStart; 324 325 326 while (*PFieldList) 327 { 328 SubtableStart = *PFieldList; 329 Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr, 330 &Subtable, TRUE); 331 if (ACPI_FAILURE (Status)) 332 { 333 return (Status); 334 } 335 336 ParentTable = DtPeekSubtable (); 337 DtInsertSubtable (ParentTable, Subtable); 338 DtPushSubtable (Subtable); 339 340 AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer); 341 342 switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */ 343 { 344 case ACPI_ASF_TYPE_INFO: 345 InfoTable = AcpiDmTableInfoAsf0; 346 break; 347 348 case ACPI_ASF_TYPE_ALERT: 349 InfoTable = AcpiDmTableInfoAsf1; 350 break; 351 352 case ACPI_ASF_TYPE_CONTROL: 353 InfoTable = AcpiDmTableInfoAsf2; 354 break; 355 356 case ACPI_ASF_TYPE_BOOT: 357 InfoTable = AcpiDmTableInfoAsf3; 358 break; 359 360 case ACPI_ASF_TYPE_ADDRESS: 361 InfoTable = AcpiDmTableInfoAsf4; 362 break; 363 364 default: 365 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!"); 366 return (AE_ERROR); 367 } 368 369 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 370 if (ACPI_FAILURE (Status)) 371 { 372 return (Status); 373 } 374 375 ParentTable = DtPeekSubtable (); 376 DtInsertSubtable (ParentTable, Subtable); 377 378 switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */ 379 { 380 case ACPI_ASF_TYPE_INFO: 381 DataInfoTable = NULL; 382 break; 383 384 case ACPI_ASF_TYPE_ALERT: 385 DataInfoTable = AcpiDmTableInfoAsf1a; 386 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, 387 ACPI_SUB_PTR (UINT8, Subtable->Buffer, 388 sizeof (ACPI_ASF_HEADER)))->Alerts; 389 break; 390 391 case ACPI_ASF_TYPE_CONTROL: 392 DataInfoTable = AcpiDmTableInfoAsf2a; 393 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, 394 ACPI_SUB_PTR (UINT8, Subtable->Buffer, 395 sizeof (ACPI_ASF_HEADER)))->Controls; 396 break; 397 398 case ACPI_ASF_TYPE_BOOT: 399 DataInfoTable = NULL; 400 break; 401 402 case ACPI_ASF_TYPE_ADDRESS: 403 DataInfoTable = TableInfoAsfAddress; 404 DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, 405 ACPI_SUB_PTR (UINT8, Subtable->Buffer, 406 sizeof (ACPI_ASF_HEADER)))->Devices; 407 break; 408 409 default: 410 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!"); 411 return (AE_ERROR); 412 } 413 414 if (DataInfoTable) 415 { 416 switch (AsfTable->Header.Type & 0x7F) 417 { 418 case ACPI_ASF_TYPE_ADDRESS: 419 420 while (DataCount > 0) 421 { 422 Status = DtCompileTable (PFieldList, DataInfoTable, 423 &Subtable, TRUE); 424 if (ACPI_FAILURE (Status)) 425 { 426 return (Status); 427 } 428 429 DtInsertSubtable (ParentTable, Subtable); 430 DataCount = DataCount - Subtable->Length; 431 } 432 break; 433 434 default: 435 436 for (i = 0; i < DataCount; i++) 437 { 438 Status = DtCompileTable (PFieldList, DataInfoTable, 439 &Subtable, TRUE); 440 if (ACPI_FAILURE (Status)) 441 { 442 return (Status); 443 } 444 445 DtInsertSubtable (ParentTable, Subtable); 446 } 447 break; 448 } 449 } 450 451 DtPopSubtable (); 452 } 453 454 return (AE_OK); 455 } 456 457 458 /****************************************************************************** 459 * 460 * FUNCTION: DtCompileCpep 461 * 462 * PARAMETERS: List - Current field list pointer 463 * 464 * RETURN: Status 465 * 466 * DESCRIPTION: Compile CPEP. 467 * 468 *****************************************************************************/ 469 470 ACPI_STATUS 471 DtCompileCpep ( 472 void **List) 473 { 474 ACPI_STATUS Status; 475 476 477 Status = DtCompileTwoSubtables (List, 478 AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0); 479 return (Status); 480 } 481 482 483 /****************************************************************************** 484 * 485 * FUNCTION: DtCompileDmar 486 * 487 * PARAMETERS: List - Current field list pointer 488 * 489 * RETURN: Status 490 * 491 * DESCRIPTION: Compile DMAR. 492 * 493 *****************************************************************************/ 494 495 ACPI_STATUS 496 DtCompileDmar ( 497 void **List) 498 { 499 ACPI_STATUS Status; 500 DT_SUBTABLE *Subtable; 501 DT_SUBTABLE *ParentTable; 502 DT_FIELD **PFieldList = (DT_FIELD **) List; 503 DT_FIELD *SubtableStart; 504 ACPI_DMTABLE_INFO *InfoTable; 505 ACPI_DMAR_HEADER *DmarHeader; 506 UINT8 *ReservedBuffer; 507 UINT32 ReservedSize; 508 509 510 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE); 511 if (ACPI_FAILURE (Status)) 512 { 513 return (Status); 514 } 515 516 ParentTable = DtPeekSubtable (); 517 DtInsertSubtable (ParentTable, Subtable); 518 519 /* DMAR Reserved area */ 520 521 ReservedSize = (UINT32) sizeof (((ACPI_TABLE_DMAR *) NULL)->Reserved); 522 ReservedBuffer = UtLocalCalloc (ReservedSize); 523 524 DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable); 525 526 ACPI_FREE (ReservedBuffer); 527 ParentTable = DtPeekSubtable (); 528 DtInsertSubtable (ParentTable, Subtable); 529 530 while (*PFieldList) 531 { 532 /* DMAR Header */ 533 534 SubtableStart = *PFieldList; 535 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarHdr, 536 &Subtable, TRUE); 537 if (ACPI_FAILURE (Status)) 538 { 539 return (Status); 540 } 541 542 ParentTable = DtPeekSubtable (); 543 DtInsertSubtable (ParentTable, Subtable); 544 DtPushSubtable (Subtable); 545 546 DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer); 547 548 switch (DmarHeader->Type) 549 { 550 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 551 InfoTable = AcpiDmTableInfoDmar0; 552 break; 553 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 554 InfoTable = AcpiDmTableInfoDmar1; 555 break; 556 case ACPI_DMAR_TYPE_ATSR: 557 InfoTable = AcpiDmTableInfoDmar2; 558 break; 559 case ACPI_DMAR_HARDWARE_AFFINITY: 560 InfoTable = AcpiDmTableInfoDmar3; 561 break; 562 default: 563 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "DMAR"); 564 return (AE_ERROR); 565 } 566 567 /* DMAR Subtable */ 568 569 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 570 if (ACPI_FAILURE (Status)) 571 { 572 return (Status); 573 } 574 575 ParentTable = DtPeekSubtable (); 576 DtInsertSubtable (ParentTable, Subtable); 577 578 /* Optional Device Scope subtables */ 579 580 while (*PFieldList) 581 { 582 Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope, 583 &Subtable, FALSE); 584 if (Status == AE_NOT_FOUND) 585 { 586 break; 587 } 588 589 ParentTable = DtPeekSubtable (); 590 DtInsertSubtable (ParentTable, Subtable); 591 DtPushSubtable (Subtable); 592 593 /* Optional PCI Paths */ 594 595 while (*PFieldList) 596 { 597 Status = DtCompileTable (PFieldList, TableInfoDmarPciPath, 598 &Subtable, FALSE); 599 if (Status == AE_NOT_FOUND) 600 { 601 DtPopSubtable (); 602 break; 603 } 604 605 ParentTable = DtPeekSubtable (); 606 DtInsertSubtable (ParentTable, Subtable); 607 } 608 } 609 610 DtPopSubtable (); 611 } 612 613 return (AE_OK); 614 } 615 616 617 /****************************************************************************** 618 * 619 * FUNCTION: DtCompileEinj 620 * 621 * PARAMETERS: List - Current field list pointer 622 * 623 * RETURN: Status 624 * 625 * DESCRIPTION: Compile EINJ. 626 * 627 *****************************************************************************/ 628 629 ACPI_STATUS 630 DtCompileEinj ( 631 void **List) 632 { 633 ACPI_STATUS Status; 634 635 636 Status = DtCompileTwoSubtables (List, 637 AcpiDmTableInfoEinj, AcpiDmTableInfoEinj0); 638 return (Status); 639 } 640 641 642 /****************************************************************************** 643 * 644 * FUNCTION: DtCompileErst 645 * 646 * PARAMETERS: List - Current field list pointer 647 * 648 * RETURN: Status 649 * 650 * DESCRIPTION: Compile ERST. 651 * 652 *****************************************************************************/ 653 654 ACPI_STATUS 655 DtCompileErst ( 656 void **List) 657 { 658 ACPI_STATUS Status; 659 660 661 Status = DtCompileTwoSubtables (List, 662 AcpiDmTableInfoErst, AcpiDmTableInfoEinj0); 663 return (Status); 664 } 665 666 667 /****************************************************************************** 668 * 669 * FUNCTION: DtCompileFadt 670 * 671 * PARAMETERS: List - Current field list pointer 672 * 673 * RETURN: Status 674 * 675 * DESCRIPTION: Compile FADT. 676 * 677 *****************************************************************************/ 678 679 ACPI_STATUS 680 DtCompileFadt ( 681 void **List) 682 { 683 ACPI_STATUS Status; 684 DT_SUBTABLE *Subtable; 685 DT_SUBTABLE *ParentTable; 686 DT_FIELD **PFieldList = (DT_FIELD **) List; 687 ACPI_TABLE_HEADER *Table; 688 UINT8 Revision; 689 690 691 Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt1, 692 &Subtable, TRUE); 693 if (ACPI_FAILURE (Status)) 694 { 695 return (Status); 696 } 697 698 ParentTable = DtPeekSubtable (); 699 DtInsertSubtable (ParentTable, Subtable); 700 701 Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer); 702 Revision = Table->Revision; 703 704 if (Revision == 2) 705 { 706 Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt2, 707 &Subtable, TRUE); 708 if (ACPI_FAILURE (Status)) 709 { 710 return (Status); 711 } 712 713 DtInsertSubtable (ParentTable, Subtable); 714 } 715 else if (Revision >= 2) 716 { 717 Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt3, 718 &Subtable, TRUE); 719 if (ACPI_FAILURE (Status)) 720 { 721 return (Status); 722 } 723 724 DtInsertSubtable (ParentTable, Subtable); 725 } 726 727 return (AE_OK); 728 } 729 730 731 /****************************************************************************** 732 * 733 * FUNCTION: DtCompileHest 734 * 735 * PARAMETERS: List - Current field list pointer 736 * 737 * RETURN: Status 738 * 739 * DESCRIPTION: Compile HEST. 740 * 741 *****************************************************************************/ 742 743 ACPI_STATUS 744 DtCompileHest ( 745 void **List) 746 { 747 ACPI_STATUS Status; 748 DT_SUBTABLE *Subtable; 749 DT_SUBTABLE *ParentTable; 750 DT_FIELD **PFieldList = (DT_FIELD **) List; 751 DT_FIELD *SubtableStart; 752 ACPI_DMTABLE_INFO *InfoTable; 753 UINT16 Type; 754 UINT32 BankCount; 755 756 757 Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest, 758 &Subtable, TRUE); 759 if (ACPI_FAILURE (Status)) 760 { 761 return (Status); 762 } 763 764 ParentTable = DtPeekSubtable (); 765 DtInsertSubtable (ParentTable, Subtable); 766 767 while (*PFieldList) 768 { 769 /* Get subtable type */ 770 771 SubtableStart = *PFieldList; 772 DtCompileInteger ((UINT8 *) &Type, *PFieldList, 2, 0); 773 774 switch (Type) 775 { 776 case ACPI_HEST_TYPE_IA32_CHECK: 777 InfoTable = AcpiDmTableInfoHest0; 778 break; 779 780 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 781 InfoTable = AcpiDmTableInfoHest1; 782 break; 783 784 case ACPI_HEST_TYPE_IA32_NMI: 785 InfoTable = AcpiDmTableInfoHest2; 786 break; 787 788 case ACPI_HEST_TYPE_AER_ROOT_PORT: 789 InfoTable = AcpiDmTableInfoHest6; 790 break; 791 792 case ACPI_HEST_TYPE_AER_ENDPOINT: 793 InfoTable = AcpiDmTableInfoHest7; 794 break; 795 796 case ACPI_HEST_TYPE_AER_BRIDGE: 797 InfoTable = AcpiDmTableInfoHest8; 798 break; 799 800 case ACPI_HEST_TYPE_GENERIC_ERROR: 801 InfoTable = AcpiDmTableInfoHest9; 802 break; 803 804 default: 805 /* Cannot continue on unknown type */ 806 807 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HEST"); 808 return (AE_ERROR); 809 } 810 811 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 812 if (ACPI_FAILURE (Status)) 813 { 814 return (Status); 815 } 816 817 DtInsertSubtable (ParentTable, Subtable); 818 819 /* 820 * Additional subtable data - IA32 Error Bank(s) 821 */ 822 BankCount = 0; 823 switch (Type) 824 { 825 case ACPI_HEST_TYPE_IA32_CHECK: 826 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 827 Subtable->Buffer))->NumHardwareBanks; 828 break; 829 830 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 831 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 832 Subtable->Buffer))->NumHardwareBanks; 833 break; 834 835 default: 836 break; 837 } 838 839 while (BankCount) 840 { 841 Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank, 842 &Subtable, TRUE); 843 if (ACPI_FAILURE (Status)) 844 { 845 return (Status); 846 } 847 848 DtInsertSubtable (ParentTable, Subtable); 849 BankCount--; 850 } 851 } 852 853 return AE_OK; 854 } 855 856 857 /****************************************************************************** 858 * 859 * FUNCTION: DtCompileIvrs 860 * 861 * PARAMETERS: List - Current field list pointer 862 * 863 * RETURN: Status 864 * 865 * DESCRIPTION: Compile IVRS. 866 * 867 *****************************************************************************/ 868 869 ACPI_STATUS 870 DtCompileIvrs ( 871 void **List) 872 { 873 ACPI_STATUS Status; 874 DT_SUBTABLE *Subtable; 875 DT_SUBTABLE *ParentTable; 876 DT_FIELD **PFieldList = (DT_FIELD **) List; 877 DT_FIELD *SubtableStart; 878 ACPI_DMTABLE_INFO *InfoTable; 879 ACPI_IVRS_HEADER *IvrsHeader; 880 UINT8 EntryType; 881 882 883 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs, 884 &Subtable, TRUE); 885 if (ACPI_FAILURE (Status)) 886 { 887 return (Status); 888 } 889 890 ParentTable = DtPeekSubtable (); 891 DtInsertSubtable (ParentTable, Subtable); 892 893 while (*PFieldList) 894 { 895 SubtableStart = *PFieldList; 896 Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHdr, 897 &Subtable, TRUE); 898 if (ACPI_FAILURE (Status)) 899 { 900 return (Status); 901 } 902 903 ParentTable = DtPeekSubtable (); 904 DtInsertSubtable (ParentTable, Subtable); 905 DtPushSubtable (Subtable); 906 907 IvrsHeader = ACPI_CAST_PTR (ACPI_IVRS_HEADER, Subtable->Buffer); 908 909 switch (IvrsHeader->Type) 910 { 911 case ACPI_IVRS_TYPE_HARDWARE: 912 InfoTable = AcpiDmTableInfoIvrs0; 913 break; 914 915 case ACPI_IVRS_TYPE_MEMORY1: 916 case ACPI_IVRS_TYPE_MEMORY2: 917 case ACPI_IVRS_TYPE_MEMORY3: 918 InfoTable = AcpiDmTableInfoIvrs1; 919 break; 920 921 default: 922 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IVRS"); 923 return (AE_ERROR); 924 } 925 926 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 927 if (ACPI_FAILURE (Status)) 928 { 929 return (Status); 930 } 931 932 ParentTable = DtPeekSubtable (); 933 DtInsertSubtable (ParentTable, Subtable); 934 935 if (IvrsHeader->Type == ACPI_IVRS_TYPE_HARDWARE) 936 { 937 while (*PFieldList && 938 !ACPI_STRCMP ((*PFieldList)->Name, "Entry Type")) 939 { 940 SubtableStart = *PFieldList; 941 DtCompileInteger (&EntryType, *PFieldList, 1, 0); 942 943 switch (EntryType) 944 { 945 /* 4-byte device entries */ 946 947 case ACPI_IVRS_TYPE_PAD4: 948 case ACPI_IVRS_TYPE_ALL: 949 case ACPI_IVRS_TYPE_SELECT: 950 case ACPI_IVRS_TYPE_START: 951 case ACPI_IVRS_TYPE_END: 952 953 InfoTable = AcpiDmTableInfoIvrs4; 954 break; 955 956 /* 8-byte entries, type A */ 957 958 case ACPI_IVRS_TYPE_ALIAS_SELECT: 959 case ACPI_IVRS_TYPE_ALIAS_START: 960 961 InfoTable = AcpiDmTableInfoIvrs8a; 962 break; 963 964 /* 8-byte entries, type B */ 965 966 case ACPI_IVRS_TYPE_PAD8: 967 case ACPI_IVRS_TYPE_EXT_SELECT: 968 case ACPI_IVRS_TYPE_EXT_START: 969 970 InfoTable = AcpiDmTableInfoIvrs8b; 971 break; 972 973 /* 8-byte entries, type C */ 974 975 case ACPI_IVRS_TYPE_SPECIAL: 976 977 InfoTable = AcpiDmTableInfoIvrs8c; 978 break; 979 980 default: 981 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, 982 "IVRS Device Entry"); 983 return (AE_ERROR); 984 } 985 986 Status = DtCompileTable (PFieldList, InfoTable, 987 &Subtable, TRUE); 988 if (ACPI_FAILURE (Status)) 989 { 990 return (Status); 991 } 992 993 DtInsertSubtable (ParentTable, Subtable); 994 } 995 } 996 997 DtPopSubtable (); 998 } 999 1000 return (AE_OK); 1001 } 1002 1003 1004 /****************************************************************************** 1005 * 1006 * FUNCTION: DtCompileMadt 1007 * 1008 * PARAMETERS: List - Current field list pointer 1009 * 1010 * RETURN: Status 1011 * 1012 * DESCRIPTION: Compile MADT. 1013 * 1014 *****************************************************************************/ 1015 1016 ACPI_STATUS 1017 DtCompileMadt ( 1018 void **List) 1019 { 1020 ACPI_STATUS Status; 1021 DT_SUBTABLE *Subtable; 1022 DT_SUBTABLE *ParentTable; 1023 DT_FIELD **PFieldList = (DT_FIELD **) List; 1024 DT_FIELD *SubtableStart; 1025 ACPI_SUBTABLE_HEADER *MadtHeader; 1026 ACPI_DMTABLE_INFO *InfoTable; 1027 1028 1029 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt, 1030 &Subtable, TRUE); 1031 if (ACPI_FAILURE (Status)) 1032 { 1033 return (Status); 1034 } 1035 1036 ParentTable = DtPeekSubtable (); 1037 DtInsertSubtable (ParentTable, Subtable); 1038 1039 while (*PFieldList) 1040 { 1041 SubtableStart = *PFieldList; 1042 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr, 1043 &Subtable, TRUE); 1044 if (ACPI_FAILURE (Status)) 1045 { 1046 return (Status); 1047 } 1048 1049 ParentTable = DtPeekSubtable (); 1050 DtInsertSubtable (ParentTable, Subtable); 1051 DtPushSubtable (Subtable); 1052 1053 MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1054 1055 switch (MadtHeader->Type) 1056 { 1057 case ACPI_MADT_TYPE_LOCAL_APIC: 1058 InfoTable = AcpiDmTableInfoMadt0; 1059 break; 1060 case ACPI_MADT_TYPE_IO_APIC: 1061 InfoTable = AcpiDmTableInfoMadt1; 1062 break; 1063 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 1064 InfoTable = AcpiDmTableInfoMadt2; 1065 break; 1066 case ACPI_MADT_TYPE_NMI_SOURCE: 1067 InfoTable = AcpiDmTableInfoMadt3; 1068 break; 1069 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 1070 InfoTable = AcpiDmTableInfoMadt4; 1071 break; 1072 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 1073 InfoTable = AcpiDmTableInfoMadt5; 1074 break; 1075 case ACPI_MADT_TYPE_IO_SAPIC: 1076 InfoTable = AcpiDmTableInfoMadt6; 1077 break; 1078 case ACPI_MADT_TYPE_LOCAL_SAPIC: 1079 InfoTable = AcpiDmTableInfoMadt7; 1080 break; 1081 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 1082 InfoTable = AcpiDmTableInfoMadt8; 1083 break; 1084 case ACPI_MADT_TYPE_LOCAL_X2APIC: 1085 InfoTable = AcpiDmTableInfoMadt9; 1086 break; 1087 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 1088 InfoTable = AcpiDmTableInfoMadt10; 1089 break; 1090 default: 1091 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT"); 1092 return (AE_ERROR); 1093 } 1094 1095 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1096 if (ACPI_FAILURE (Status)) 1097 { 1098 return (Status); 1099 } 1100 1101 ParentTable = DtPeekSubtable (); 1102 DtInsertSubtable (ParentTable, Subtable); 1103 DtPopSubtable (); 1104 } 1105 1106 return (AE_OK); 1107 } 1108 1109 1110 /****************************************************************************** 1111 * 1112 * FUNCTION: DtCompileMcfg 1113 * 1114 * PARAMETERS: List - Current field list pointer 1115 * 1116 * RETURN: Status 1117 * 1118 * DESCRIPTION: Compile MCFG. 1119 * 1120 *****************************************************************************/ 1121 1122 ACPI_STATUS 1123 DtCompileMcfg ( 1124 void **List) 1125 { 1126 ACPI_STATUS Status; 1127 1128 1129 Status = DtCompileTwoSubtables (List, 1130 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0); 1131 return (Status); 1132 } 1133 1134 1135 /****************************************************************************** 1136 * 1137 * FUNCTION: DtCompileMsct 1138 * 1139 * PARAMETERS: List - Current field list pointer 1140 * 1141 * RETURN: Status 1142 * 1143 * DESCRIPTION: Compile MSCT. 1144 * 1145 *****************************************************************************/ 1146 1147 ACPI_STATUS 1148 DtCompileMsct ( 1149 void **List) 1150 { 1151 ACPI_STATUS Status; 1152 1153 1154 Status = DtCompileTwoSubtables (List, 1155 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0); 1156 return (Status); 1157 } 1158 1159 1160 /****************************************************************************** 1161 * 1162 * FUNCTION: DtCompileRsdt 1163 * 1164 * PARAMETERS: List - Current field list pointer 1165 * 1166 * RETURN: Status 1167 * 1168 * DESCRIPTION: Compile RSDT. 1169 * 1170 *****************************************************************************/ 1171 1172 ACPI_STATUS 1173 DtCompileRsdt ( 1174 void **List) 1175 { 1176 DT_SUBTABLE *Subtable; 1177 DT_SUBTABLE *ParentTable; 1178 DT_FIELD *FieldList = *(DT_FIELD **) List; 1179 UINT32 Address; 1180 1181 1182 ParentTable = DtPeekSubtable (); 1183 1184 while (FieldList) 1185 { 1186 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO); 1187 1188 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable); 1189 DtInsertSubtable (ParentTable, Subtable); 1190 FieldList = FieldList->Next; 1191 } 1192 1193 return (AE_OK); 1194 } 1195 1196 1197 /****************************************************************************** 1198 * 1199 * FUNCTION: DtCompileSlit 1200 * 1201 * PARAMETERS: List - Current field list pointer 1202 * 1203 * RETURN: Status 1204 * 1205 * DESCRIPTION: Compile SLIT. 1206 * 1207 *****************************************************************************/ 1208 1209 ACPI_STATUS 1210 DtCompileSlit ( 1211 void **List) 1212 { 1213 ACPI_STATUS Status; 1214 DT_SUBTABLE *Subtable; 1215 DT_SUBTABLE *ParentTable; 1216 DT_FIELD **PFieldList = (DT_FIELD **) List; 1217 DT_FIELD *FieldList; 1218 UINT32 Localities; 1219 UINT8 *LocalityBuffer; 1220 UINT32 RemainingData; 1221 1222 1223 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit, 1224 &Subtable, TRUE); 1225 if (ACPI_FAILURE (Status)) 1226 { 1227 return (Status); 1228 } 1229 1230 ParentTable = DtPeekSubtable (); 1231 DtInsertSubtable (ParentTable, Subtable); 1232 1233 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer); 1234 LocalityBuffer = UtLocalCalloc (Localities); 1235 1236 FieldList = *PFieldList; 1237 while (FieldList) 1238 { 1239 /* Handle multiple-line buffer */ 1240 1241 RemainingData = Localities; 1242 while (RemainingData && FieldList) 1243 { 1244 RemainingData = DtCompileBuffer ( 1245 LocalityBuffer + (Localities - RemainingData), 1246 FieldList->Value, FieldList, RemainingData); 1247 FieldList = FieldList->Next; 1248 } 1249 1250 DtCreateSubtable (LocalityBuffer, Localities, &Subtable); 1251 DtInsertSubtable (ParentTable, Subtable); 1252 } 1253 1254 ACPI_FREE (LocalityBuffer); 1255 return (AE_OK); 1256 } 1257 1258 1259 /****************************************************************************** 1260 * 1261 * FUNCTION: DtCompileSrat 1262 * 1263 * PARAMETERS: List - Current field list pointer 1264 * 1265 * RETURN: Status 1266 * 1267 * DESCRIPTION: Compile SRAT. 1268 * 1269 *****************************************************************************/ 1270 1271 ACPI_STATUS 1272 DtCompileSrat ( 1273 void **List) 1274 { 1275 ACPI_STATUS Status; 1276 DT_SUBTABLE *Subtable; 1277 DT_SUBTABLE *ParentTable; 1278 DT_FIELD **PFieldList = (DT_FIELD **) List; 1279 DT_FIELD *SubtableStart; 1280 ACPI_SUBTABLE_HEADER *SratHeader; 1281 ACPI_DMTABLE_INFO *InfoTable; 1282 1283 1284 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat, 1285 &Subtable, TRUE); 1286 if (ACPI_FAILURE (Status)) 1287 { 1288 return (Status); 1289 } 1290 1291 ParentTable = DtPeekSubtable (); 1292 DtInsertSubtable (ParentTable, Subtable); 1293 1294 while (*PFieldList) 1295 { 1296 SubtableStart = *PFieldList; 1297 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr, 1298 &Subtable, TRUE); 1299 if (ACPI_FAILURE (Status)) 1300 { 1301 return (Status); 1302 } 1303 1304 ParentTable = DtPeekSubtable (); 1305 DtInsertSubtable (ParentTable, Subtable); 1306 DtPushSubtable (Subtable); 1307 1308 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer); 1309 1310 switch (SratHeader->Type) 1311 { 1312 case ACPI_SRAT_TYPE_CPU_AFFINITY: 1313 InfoTable = AcpiDmTableInfoSrat0; 1314 break; 1315 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 1316 InfoTable = AcpiDmTableInfoSrat1; 1317 break; 1318 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 1319 InfoTable = AcpiDmTableInfoSrat2; 1320 break; 1321 default: 1322 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT"); 1323 return (AE_ERROR); 1324 } 1325 1326 Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE); 1327 if (ACPI_FAILURE (Status)) 1328 { 1329 return (Status); 1330 } 1331 1332 ParentTable = DtPeekSubtable (); 1333 DtInsertSubtable (ParentTable, Subtable); 1334 DtPopSubtable (); 1335 } 1336 1337 return (AE_OK); 1338 } 1339 1340 1341 /****************************************************************************** 1342 * 1343 * FUNCTION: DtCompileWdat 1344 * 1345 * PARAMETERS: List - Current field list pointer 1346 * 1347 * RETURN: Status 1348 * 1349 * DESCRIPTION: Compile WDAT. 1350 * 1351 *****************************************************************************/ 1352 1353 ACPI_STATUS 1354 DtCompileWdat ( 1355 void **List) 1356 { 1357 ACPI_STATUS Status; 1358 1359 1360 Status = DtCompileTwoSubtables (List, 1361 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0); 1362 return (Status); 1363 } 1364 1365 1366 /****************************************************************************** 1367 * 1368 * FUNCTION: DtCompileXsdt 1369 * 1370 * PARAMETERS: List - Current field list pointer 1371 * 1372 * RETURN: Status 1373 * 1374 * DESCRIPTION: Compile XSDT. 1375 * 1376 *****************************************************************************/ 1377 1378 ACPI_STATUS 1379 DtCompileXsdt ( 1380 void **List) 1381 { 1382 DT_SUBTABLE *Subtable; 1383 DT_SUBTABLE *ParentTable; 1384 DT_FIELD *FieldList = *(DT_FIELD **) List; 1385 UINT64 Address; 1386 1387 ParentTable = DtPeekSubtable (); 1388 1389 while (FieldList) 1390 { 1391 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO); 1392 1393 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable); 1394 DtInsertSubtable (ParentTable, Subtable); 1395 FieldList = FieldList->Next; 1396 } 1397 1398 return (AE_OK); 1399 } 1400
Indexes created Thu Oct 02 07:10:07 GMT 2025