1 /****************************************************************************** 2 * 3 * Module Name: aslcodegen - AML code generation 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2018, 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 #include "aslcompiler.h" 153 #include "aslcompiler.y.h" 154 #include "amlcode.h" 155 #include "acconvert.h" 156 157 #define _COMPONENT ACPI_COMPILER 158 ACPI_MODULE_NAME ("aslcodegen") 159 160 /* Local prototypes */ 161 162 static ACPI_STATUS 163 CgAmlWriteWalk ( 164 ACPI_PARSE_OBJECT *Op, 165 UINT32 Level, 166 void *Context); 167 168 static void 169 CgWriteAmlOpcode ( 170 ACPI_PARSE_OBJECT *Op); 171 172 static void 173 CgWriteTableHeader ( 174 ACPI_PARSE_OBJECT *Op); 175 176 static void 177 CgCloseTable ( 178 void); 179 180 static void 181 CgWriteNode ( 182 ACPI_PARSE_OBJECT *Op); 183 184 185 /******************************************************************************* 186 * 187 * FUNCTION: CgGenerateAmlOutput 188 * 189 * PARAMETERS: None. 190 * 191 * RETURN: None 192 * 193 * DESCRIPTION: Generate AML code. Currently generates the listing file 194 * simultaneously. 195 * 196 ******************************************************************************/ 197 198 void 199 CgGenerateAmlOutput ( 200 void) 201 { 202 203 /* Generate the AML output file */ 204 205 FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0); 206 Gbl_SourceLine = 0; 207 Gbl_NextError = Gbl_ErrorLog; 208 209 TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD, 210 CgAmlWriteWalk, NULL, NULL); 211 212 DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER2); 213 CgCloseTable (); 214 } 215 216 217 /******************************************************************************* 218 * 219 * FUNCTION: CgAmlWriteWalk 220 * 221 * PARAMETERS: ASL_WALK_CALLBACK 222 * 223 * RETURN: Status 224 * 225 * DESCRIPTION: Parse tree walk to generate the AML code. 226 * 227 ******************************************************************************/ 228 229 static ACPI_STATUS 230 CgAmlWriteWalk ( 231 ACPI_PARSE_OBJECT *Op, 232 UINT32 Level, 233 void *Context) 234 { 235 236 /* Generate the AML for this node */ 237 238 CgWriteNode (Op); 239 240 if (!Gbl_DebugFlag) 241 { 242 return (AE_OK); 243 } 244 245 /* Print header at level 0. Alignment assumes 32-bit pointers */ 246 247 if (!Level) 248 { 249 DbgPrint (ASL_TREE_OUTPUT, 250 "\nFinal parse tree used for AML output:\n"); 251 DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER2); 252 } 253 254 /* Dump ParseOp name and possible value */ 255 256 switch (Op->Asl.ParseOpcode) 257 { 258 case PARSEOP_NAMESEG: 259 case PARSEOP_NAMESTRING: 260 case PARSEOP_METHODCALL: 261 case PARSEOP_STRING_LITERAL: 262 263 UtDumpStringOp (Op, Level); 264 break; 265 266 default: 267 268 UtDumpBasicOp (Op, Level); 269 break; 270 } 271 272 DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_DEBUG2, 273 /* 1 */ (UINT32) Op->Asl.Value.Integer, 274 /* 2 */ Op->Asl.ParseOpcode, 275 /* 3 */ Op->Asl.AmlOpcode, 276 /* 4 */ Op->Asl.AmlOpcodeLength, 277 /* 5 */ Op->Asl.AmlPkgLenBytes, 278 /* 6 */ Op->Asl.AmlLength, 279 /* 7 */ Op->Asl.AmlSubtreeLength, 280 /* 8 */ Op->Asl.Parent ? Op->Asl.Parent->Asl.AmlSubtreeLength : 0, 281 /* 9 */ Op, 282 /* 10 */ Op->Asl.Parent, 283 /* 11 */ Op->Asl.Child, 284 /* 12 */ Op->Asl.Next, 285 /* 13 */ Op->Asl.CompileFlags, 286 /* 14 */ Op->Asl.AcpiBtype, 287 /* 15 */ Op->Asl.FinalAmlLength, 288 /* 16 */ Op->Asl.Column, 289 /* 17 */ Op->Asl.LineNumber, 290 /* 18 */ Op->Asl.EndLine, 291 /* 19 */ Op->Asl.LogicalLineNumber, 292 /* 20 */ Op->Asl.EndLogicalLine); 293 294 TrPrintOpFlags (Op->Asl.CompileFlags, ASL_TREE_OUTPUT); 295 DbgPrint (ASL_TREE_OUTPUT, "\n"); 296 return (AE_OK); 297 } 298 299 300 /******************************************************************************* 301 * 302 * FUNCTION: CgLocalWriteAmlData 303 * 304 * PARAMETERS: Op - Current parse op 305 * Buffer - Buffer to write 306 * Length - Size of data in buffer 307 * 308 * RETURN: None 309 * 310 * DESCRIPTION: Write a buffer of AML data to the AML output file. 311 * 312 ******************************************************************************/ 313 314 void 315 CgLocalWriteAmlData ( 316 ACPI_PARSE_OBJECT *Op, 317 void *Buffer, 318 UINT32 Length) 319 { 320 321 /* Write the raw data to the AML file */ 322 323 FlWriteFile (ASL_FILE_AML_OUTPUT, Buffer, Length); 324 325 /* Update the final AML length for this node (used for listings) */ 326 327 if (Op) 328 { 329 Op->Asl.FinalAmlLength += Length; 330 } 331 } 332 333 334 /******************************************************************************* 335 * 336 * FUNCTION: CgWriteAmlOpcode 337 * 338 * PARAMETERS: Op - Parse node with an AML opcode 339 * 340 * RETURN: None. 341 * 342 * DESCRIPTION: Write the AML opcode corresponding to a parse node. 343 * 344 ******************************************************************************/ 345 346 static void 347 CgWriteAmlOpcode ( 348 ACPI_PARSE_OBJECT *Op) 349 { 350 UINT8 PkgLenFirstByte; 351 UINT32 i; 352 union { 353 UINT16 Opcode; 354 UINT8 OpcodeBytes[2]; 355 } Aml; 356 union { 357 UINT32 Len; 358 UINT8 LenBytes[4]; 359 } PkgLen; 360 361 362 /* We expect some DEFAULT_ARGs, just ignore them */ 363 364 if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 365 { 366 return; 367 } 368 369 /* 370 * Before printing the bytecode, generate comment byte codes 371 * associated with this node. 372 */ 373 if (AcpiGbl_CaptureComments) 374 { 375 CgWriteAmlComment(Op); 376 } 377 378 switch (Op->Asl.AmlOpcode) 379 { 380 case AML_UNASSIGNED_OPCODE: 381 382 /* These opcodes should not get here */ 383 384 printf ("Found a node with an unassigned AML opcode\n"); 385 FlPrintFile (ASL_FILE_STDERR, 386 "Found a node with an unassigned AML opcode\n"); 387 return; 388 389 case AML_INT_RESERVEDFIELD_OP: 390 391 /* Special opcodes for within a field definition */ 392 393 Aml.Opcode = AML_FIELD_OFFSET_OP; 394 break; 395 396 case AML_INT_ACCESSFIELD_OP: 397 398 Aml.Opcode = AML_FIELD_ACCESS_OP; 399 break; 400 401 case AML_INT_CONNECTION_OP: 402 403 Aml.Opcode = AML_FIELD_CONNECTION_OP; 404 break; 405 406 default: 407 408 Aml.Opcode = Op->Asl.AmlOpcode; 409 break; 410 } 411 412 413 switch (Aml.Opcode) 414 { 415 case AML_PACKAGE_LENGTH: 416 417 /* Value is the length to be encoded (Used in field definitions) */ 418 419 PkgLen.Len = (UINT32) Op->Asl.Value.Integer; 420 break; 421 422 default: 423 424 /* Check for two-byte opcode */ 425 426 if (Aml.Opcode > 0x00FF) 427 { 428 /* Write the high byte first */ 429 430 CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1); 431 } 432 433 CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1); 434 435 /* Subtreelength doesn't include length of package length bytes */ 436 437 PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes; 438 break; 439 } 440 441 /* Does this opcode have an associated "PackageLength" field? */ 442 443 if (Op->Asl.CompileFlags & OP_AML_PACKAGE) 444 { 445 if (Op->Asl.AmlPkgLenBytes == 1) 446 { 447 /* Simplest case -- no bytes to follow, just write the count */ 448 449 CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1); 450 } 451 else if (Op->Asl.AmlPkgLenBytes != 0) 452 { 453 /* 454 * Encode the "bytes to follow" in the first byte, top two bits. 455 * The low-order nybble of the length is in the bottom 4 bits 456 */ 457 PkgLenFirstByte = (UINT8) 458 (((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) | 459 (PkgLen.LenBytes[0] & 0x0F)); 460 461 CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1); 462 463 /* 464 * Shift the length over by the 4 bits we just stuffed 465 * in the first byte 466 */ 467 PkgLen.Len >>= 4; 468 469 /* 470 * Now we can write the remaining bytes - 471 * either 1, 2, or 3 bytes 472 */ 473 for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++) 474 { 475 CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1); 476 } 477 } 478 } 479 480 switch (Aml.Opcode) 481 { 482 case AML_BYTE_OP: 483 484 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 1); 485 break; 486 487 case AML_WORD_OP: 488 489 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 2); 490 break; 491 492 case AML_DWORD_OP: 493 494 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 4); 495 break; 496 497 case AML_QWORD_OP: 498 499 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 8); 500 break; 501 502 case AML_STRING_OP: 503 504 CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength); 505 break; 506 507 default: 508 509 /* All data opcodes must appear above */ 510 511 break; 512 } 513 } 514 515 516 /******************************************************************************* 517 * 518 * FUNCTION: CgWriteTableHeader 519 * 520 * PARAMETERS: Op - The DEFINITIONBLOCK node 521 * 522 * RETURN: None 523 * 524 * DESCRIPTION: Write a table header corresponding to the DEFINITIONBLOCK 525 * 526 ******************************************************************************/ 527 528 static void 529 CgWriteTableHeader ( 530 ACPI_PARSE_OBJECT *Op) 531 { 532 ACPI_PARSE_OBJECT *Child; 533 UINT32 CommentLength; 534 ACPI_COMMENT_NODE *Current; 535 536 537 /* AML filename */ 538 539 Child = Op->Asl.Child; 540 541 /* Signature */ 542 543 Child = Child->Asl.Next; 544 545 /* 546 * For ASL-/ASL+ converter: replace the table signature with 547 * "XXXX" and save the original table signature. This results in an AML 548 * file with the signature "XXXX". The converter should remove this AML 549 * file. In the event where this AML file does not get deleted, the 550 * "XXXX" table signature prevents this AML file from running on the AML 551 * interpreter. 552 */ 553 if (AcpiGbl_CaptureComments) 554 { 555 strncpy(AcpiGbl_TableSig, Child->Asl.Value.String, ACPI_NAME_SIZE); 556 Child->Asl.Value.String = ACPI_SIG_XXXX; 557 } 558 559 strncpy (TableHeader.Signature, Child->Asl.Value.String, ACPI_NAME_SIZE); 560 561 /* Revision */ 562 563 Child = Child->Asl.Next; 564 TableHeader.Revision = (UINT8) Child->Asl.Value.Integer; 565 566 /* Command-line Revision override */ 567 568 if (Gbl_RevisionOverride) 569 { 570 TableHeader.Revision = Gbl_RevisionOverride; 571 } 572 573 /* OEMID */ 574 575 Child = Child->Asl.Next; 576 strncpy (TableHeader.OemId, Child->Asl.Value.String, ACPI_OEM_ID_SIZE); 577 578 /* OEM TableID */ 579 580 Child = Child->Asl.Next; 581 strncpy (TableHeader.OemTableId, Child->Asl.Value.String, ACPI_OEM_TABLE_ID_SIZE); 582 583 /* OEM Revision */ 584 585 Child = Child->Asl.Next; 586 TableHeader.OemRevision = (UINT32) Child->Asl.Value.Integer; 587 588 /* Compiler ID */ 589 590 ACPI_MOVE_NAME (TableHeader.AslCompilerId, ASL_CREATOR_ID); 591 592 /* Compiler version */ 593 594 TableHeader.AslCompilerRevision = ACPI_CA_VERSION; 595 596 /* Table length. Checksum zero for now, will rewrite later */ 597 598 TableHeader.Length = sizeof (ACPI_TABLE_HEADER) + 599 Op->Asl.AmlSubtreeLength; 600 601 /* Calculate the comment lengths for this definition block parseOp */ 602 603 if (AcpiGbl_CaptureComments) 604 { 605 CvDbgPrint ("Calculating comment lengths for %s in write header\n", 606 Op->Asl.ParseOpName); 607 608 /* 609 * Take the filename without extensions, add 3 for the new extension 610 * and another 3 for the a908 bytecode and null terminator. 611 */ 612 TableHeader.Length += strrchr (Gbl_ParseTreeRoot->Asl.Filename, '.') 613 - Gbl_ParseTreeRoot->Asl.Filename + 1 + 3 + 3; 614 Op->Asl.AmlSubtreeLength += 615 strlen (Gbl_ParseTreeRoot->Asl.Filename) + 3; 616 CvDbgPrint (" Length: %lu\n", 617 strlen (Gbl_ParseTreeRoot->Asl.Filename) + 3); 618 619 if (Op->Asl.CommentList) 620 { 621 Current = Op->Asl.CommentList; 622 while (Current) 623 { 624 CommentLength = strlen (Current->Comment)+3; 625 CvDbgPrint ("Length of standard comment): %d\n", CommentLength); 626 CvDbgPrint (" Comment string: %s\n\n", Current->Comment); 627 TableHeader.Length += CommentLength; 628 Op->Asl.AmlSubtreeLength += CommentLength; 629 Current = Current->Next; 630 CvDbgPrint (" Length: %u\n", CommentLength); 631 } 632 } 633 if (Op->Asl.CloseBraceComment) 634 { 635 CommentLength = strlen (Op->Asl.CloseBraceComment)+3; 636 CvDbgPrint ("Length of inline comment +3: %d\n", CommentLength); 637 CvDbgPrint (" Comment string: %s\n\n", Op->Asl.CloseBraceComment); 638 TableHeader.Length += CommentLength; 639 Op->Asl.AmlSubtreeLength += CommentLength; 640 CvDbgPrint (" Length: %u\n", CommentLength); 641 } 642 } 643 644 TableHeader.Checksum = 0; 645 646 Op->Asl.FinalAmlOffset = ftell (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle); 647 648 /* Write entire header and clear the table header global */ 649 650 CgLocalWriteAmlData (Op, &TableHeader, sizeof (ACPI_TABLE_HEADER)); 651 memset (&TableHeader, 0, sizeof (ACPI_TABLE_HEADER)); 652 } 653 654 655 /******************************************************************************* 656 * 657 * FUNCTION: CgUpdateHeader 658 * 659 * PARAMETERS: Op - Op for the Definition Block 660 * 661 * RETURN: None. 662 * 663 * DESCRIPTION: Complete the ACPI table by calculating the checksum and 664 * re-writing the header for the input definition block 665 * 666 ******************************************************************************/ 667 668 static void 669 CgUpdateHeader ( 670 ACPI_PARSE_OBJECT *Op) 671 { 672 signed char Sum; 673 UINT32 i; 674 UINT32 Length; 675 UINT8 FileByte; 676 UINT8 Checksum; 677 678 679 /* Calculate the checksum over the entire definition block */ 680 681 Sum = 0; 682 Length = sizeof (ACPI_TABLE_HEADER) + Op->Asl.AmlSubtreeLength; 683 FlSeekFile (ASL_FILE_AML_OUTPUT, Op->Asl.FinalAmlOffset); 684 685 for (i = 0; i < Length; i++) 686 { 687 if (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1) != AE_OK) 688 { 689 printf ("EOF while reading checksum bytes\n"); 690 return; 691 } 692 693 Sum = (signed char) (Sum + FileByte); 694 } 695 696 Checksum = (UINT8) (0 - Sum); 697 698 /* Re-write the the checksum byte */ 699 700 FlSeekFile (ASL_FILE_AML_OUTPUT, Op->Asl.FinalAmlOffset + 701 ACPI_OFFSET (ACPI_TABLE_HEADER, Checksum)); 702 703 FlWriteFile (ASL_FILE_AML_OUTPUT, &Checksum, 1); 704 } 705 706 707 /******************************************************************************* 708 * 709 * FUNCTION: CgCloseTable 710 * 711 * PARAMETERS: None. 712 * 713 * RETURN: None. 714 * 715 * DESCRIPTION: Complete the ACPI table by calculating the checksum and 716 * re-writing each table header. This allows support for 717 * multiple definition blocks in a single source file. 718 * 719 ******************************************************************************/ 720 721 static void 722 CgCloseTable ( 723 void) 724 { 725 ACPI_PARSE_OBJECT *Op; 726 727 728 /* Process all definition blocks */ 729 730 Op = Gbl_ParseTreeRoot->Asl.Child; 731 while (Op) 732 { 733 CgUpdateHeader (Op); 734 Op = Op->Asl.Next; 735 } 736 } 737 738 739 /******************************************************************************* 740 * 741 * FUNCTION: CgWriteNode 742 * 743 * PARAMETERS: Op - Parse node to write. 744 * 745 * RETURN: None. 746 * 747 * DESCRIPTION: Write the AML that corresponds to a parse node. 748 * 749 ******************************************************************************/ 750 751 static void 752 CgWriteNode ( 753 ACPI_PARSE_OBJECT *Op) 754 { 755 ASL_RESOURCE_NODE *Rnode; 756 757 758 /* Write all comments here. */ 759 760 if (AcpiGbl_CaptureComments) 761 { 762 CgWriteAmlComment(Op); 763 } 764 765 /* Always check for DEFAULT_ARG and other "Noop" nodes */ 766 /* TBD: this may not be the best place for this check */ 767 768 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) || 769 (Op->Asl.ParseOpcode == PARSEOP_INCLUDE) || 770 (Op->Asl.ParseOpcode == PARSEOP_INCLUDE_END)) 771 { 772 return; 773 } 774 775 if ((Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) && 776 Gbl_DoExternals == FALSE) 777 { 778 return; 779 } 780 781 Op->Asl.FinalAmlLength = 0; 782 783 switch (Op->Asl.AmlOpcode) 784 { 785 case AML_RAW_DATA_BYTE: 786 case AML_RAW_DATA_WORD: 787 case AML_RAW_DATA_DWORD: 788 case AML_RAW_DATA_QWORD: 789 790 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, Op->Asl.AmlLength); 791 return; 792 793 794 case AML_RAW_DATA_BUFFER: 795 796 CgLocalWriteAmlData (Op, Op->Asl.Value.Buffer, Op->Asl.AmlLength); 797 return; 798 799 800 case AML_RAW_DATA_CHAIN: 801 802 Rnode = ACPI_CAST_PTR (ASL_RESOURCE_NODE, Op->Asl.Value.Buffer); 803 while (Rnode) 804 { 805 CgLocalWriteAmlData (Op, Rnode->Buffer, Rnode->BufferLength); 806 Rnode = Rnode->Next; 807 } 808 return; 809 810 default: 811 812 /* Internal data opcodes must all appear above */ 813 814 break; 815 } 816 817 switch (Op->Asl.ParseOpcode) 818 { 819 case PARSEOP_DEFAULT_ARG: 820 821 break; 822 823 case PARSEOP_DEFINITION_BLOCK: 824 825 CgWriteTableHeader (Op); 826 if (AcpiGbl_CaptureComments) 827 { 828 CgWriteAmlDefBlockComment (Op); 829 } 830 break; 831 832 case PARSEOP_NAMESEG: 833 case PARSEOP_NAMESTRING: 834 case PARSEOP_METHODCALL: 835 836 CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength); 837 break; 838 839 default: 840 841 CgWriteAmlOpcode (Op); 842 break; 843 } 844 } 845