1 /****************************************************************************** 2 * 3 * Module Name: aslcompiler.h - common include file for iASL 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2017, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152 #ifndef __ASLCOMPILER_H 153 #define __ASLCOMPILER_H 154 155 #include <contrib/dev/acpica/include/acpi.h> 156 #include <contrib/dev/acpica/include/accommon.h> 157 #include <contrib/dev/acpica/include/amlresrc.h> 158 #include <contrib/dev/acpica/include/acdebug.h> 159 160 /* Microsoft-specific */ 161 162 #if (defined WIN32 || defined WIN64) 163 164 /* warn : used #pragma pack */ 165 #pragma warning(disable:4103) 166 167 /* warn : named type definition in parentheses */ 168 #pragma warning(disable:4115) 169 #endif 170 171 #include <stdio.h> 172 #include <stdlib.h> 173 #include <string.h> 174 #include <errno.h> 175 #include <ctype.h> 176 177 /* Compiler headers */ 178 179 #include <contrib/dev/acpica/compiler/asldefine.h> 180 #include <contrib/dev/acpica/compiler/asltypes.h> 181 #include <contrib/dev/acpica/compiler/aslmessages.h> 182 #include <contrib/dev/acpica/compiler/aslglobal.h> 183 #include <contrib/dev/acpica/compiler/preprocess.h> 184 185 186 /******************************************************************************* 187 * 188 * Compiler prototypes 189 * 190 ******************************************************************************/ 191 192 /* 193 * Main ASL parser - generated from flex/bison, lex/yacc, etc. 194 */ 195 ACPI_PARSE_OBJECT * 196 AslDoError ( 197 void); 198 199 int 200 AslCompilerlex( 201 void); 202 203 void 204 AslResetCurrentLineBuffer ( 205 void); 206 207 void 208 AslInsertLineBuffer ( 209 int SourceChar); 210 211 int 212 AslPopInputFileStack ( 213 void); 214 215 void 216 AslPushInputFileStack ( 217 FILE *InputFile, 218 char *Filename); 219 220 void 221 AslParserCleanup ( 222 void); 223 224 225 /* 226 * aslstartup - entered from main() 227 */ 228 void 229 AslInitializeGlobals ( 230 void); 231 232 typedef 233 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) ( 234 char *); 235 236 ACPI_STATUS 237 AslDoOneFile ( 238 char *Filename); 239 240 ACPI_STATUS 241 AslCheckForErrorExit ( 242 void); 243 244 245 /* 246 * aslcompile - compile mainline 247 */ 248 void 249 AslCompilerSignon ( 250 UINT32 FileId); 251 252 void 253 AslCompilerFileHeader ( 254 UINT32 FileId); 255 256 int 257 CmDoCompile ( 258 void); 259 260 void 261 CmDoOutputFiles ( 262 void); 263 264 void 265 CmCleanupAndExit ( 266 void); 267 268 void 269 CmDeleteCaches ( 270 void); 271 272 273 /* 274 * aslascii - ascii support 275 */ 276 ACPI_STATUS 277 FlIsFileAsciiSource ( 278 char *Filename, 279 BOOLEAN DisplayErrors); 280 281 282 /* 283 * aslwalks - semantic analysis and parse tree walks 284 */ 285 ACPI_STATUS 286 AnOtherSemanticAnalysisWalkBegin ( 287 ACPI_PARSE_OBJECT *Op, 288 UINT32 Level, 289 void *Context); 290 291 ACPI_STATUS 292 AnOtherSemanticAnalysisWalkEnd ( 293 ACPI_PARSE_OBJECT *Op, 294 UINT32 Level, 295 void *Context); 296 297 ACPI_STATUS 298 AnOperandTypecheckWalkEnd ( 299 ACPI_PARSE_OBJECT *Op, 300 UINT32 Level, 301 void *Context); 302 303 ACPI_STATUS 304 AnMethodTypingWalkEnd ( 305 ACPI_PARSE_OBJECT *Op, 306 UINT32 Level, 307 void *Context); 308 309 310 /* 311 * aslmethod - Control method analysis walk 312 */ 313 ACPI_STATUS 314 MtMethodAnalysisWalkBegin ( 315 ACPI_PARSE_OBJECT *Op, 316 UINT32 Level, 317 void *Context); 318 319 ACPI_STATUS 320 MtMethodAnalysisWalkEnd ( 321 ACPI_PARSE_OBJECT *Op, 322 UINT32 Level, 323 void *Context); 324 325 326 /* 327 * aslbtypes - bitfield data types 328 */ 329 UINT32 330 AnMapObjTypeToBtype ( 331 ACPI_PARSE_OBJECT *Op); 332 333 UINT32 334 AnMapArgTypeToBtype ( 335 UINT32 ArgType); 336 337 UINT32 338 AnGetBtype ( 339 ACPI_PARSE_OBJECT *Op); 340 341 void 342 AnFormatBtype ( 343 char *Buffer, 344 UINT32 Btype); 345 346 347 /* 348 * aslanalyze - Support functions for parse tree walks 349 */ 350 void 351 AnCheckId ( 352 ACPI_PARSE_OBJECT *Op, 353 ACPI_NAME Type); 354 355 /* Values for Type argument above */ 356 357 #define ASL_TYPE_HID 0 358 #define ASL_TYPE_CID 1 359 360 BOOLEAN 361 AnIsInternalMethod ( 362 ACPI_PARSE_OBJECT *Op); 363 364 UINT32 365 AnGetInternalMethodReturnType ( 366 ACPI_PARSE_OBJECT *Op); 367 368 BOOLEAN 369 AnLastStatementIsReturn ( 370 ACPI_PARSE_OBJECT *Op); 371 372 void 373 AnCheckMethodReturnValue ( 374 ACPI_PARSE_OBJECT *Op, 375 const ACPI_OPCODE_INFO *OpInfo, 376 ACPI_PARSE_OBJECT *ArgOp, 377 UINT32 RequiredBtypes, 378 UINT32 ThisNodeBtype); 379 380 BOOLEAN 381 AnIsResultUsed ( 382 ACPI_PARSE_OBJECT *Op); 383 384 void 385 ApCheckForGpeNameConflict ( 386 ACPI_PARSE_OBJECT *Op); 387 388 void 389 ApCheckRegMethod ( 390 ACPI_PARSE_OBJECT *Op); 391 392 BOOLEAN 393 ApFindNameInScope ( 394 char *Name, 395 ACPI_PARSE_OBJECT *Op); 396 397 BOOLEAN 398 ApFindNameInDeviceTree ( 399 char *Name, 400 ACPI_PARSE_OBJECT *Op); 401 402 /* 403 * aslerror - error handling/reporting 404 */ 405 void 406 AslAbort ( 407 void); 408 409 void 410 AslError ( 411 UINT8 Level, 412 UINT16 MessageId, 413 ACPI_PARSE_OBJECT *Op, 414 char *ExtraMessage); 415 416 ACPI_STATUS 417 AslDisableException ( 418 char *MessageIdString); 419 420 BOOLEAN 421 AslIsExceptionDisabled ( 422 UINT8 Level, 423 UINT16 MessageId); 424 425 void 426 AslCoreSubsystemError ( 427 ACPI_PARSE_OBJECT *Op, 428 ACPI_STATUS Status, 429 char *ExtraMessage, 430 BOOLEAN Abort); 431 432 int 433 AslCompilererror( 434 const char *s); 435 436 void 437 AslCommonError ( 438 UINT8 Level, 439 UINT16 MessageId, 440 UINT32 CurrentLineNumber, 441 UINT32 LogicalLineNumber, 442 UINT32 LogicalByteOffset, 443 UINT32 Column, 444 char *Filename, 445 char *ExtraMessage); 446 447 void 448 AslCommonError2 ( 449 UINT8 Level, 450 UINT16 MessageId, 451 UINT32 LineNumber, 452 UINT32 Column, 453 char *SourceLine, 454 char *Filename, 455 char *ExtraMessage); 456 457 void 458 AePrintException ( 459 UINT32 FileId, 460 ASL_ERROR_MSG *Enode, 461 char *Header); 462 463 void 464 AePrintErrorLog ( 465 UINT32 FileId); 466 467 void 468 AeClearErrorLog ( 469 void); 470 471 472 /* 473 * asllisting - generate all "listing" type files 474 */ 475 void 476 LsDoListings ( 477 void); 478 479 void 480 LsWriteNodeToAsmListing ( 481 ACPI_PARSE_OBJECT *Op); 482 483 void 484 LsWriteNode ( 485 ACPI_PARSE_OBJECT *Op, 486 UINT32 FileId); 487 488 void 489 LsDumpParseTree ( 490 void); 491 492 493 /* 494 * asllistsup - Listing file support utilities 495 */ 496 void 497 LsDumpAscii ( 498 UINT32 FileId, 499 UINT32 Count, 500 UINT8 *Buffer); 501 502 void 503 LsDumpAsciiInComment ( 504 UINT32 FileId, 505 UINT32 Count, 506 UINT8 *Buffer); 507 508 void 509 LsCheckException ( 510 UINT32 LineNumber, 511 UINT32 FileId); 512 513 void 514 LsFlushListingBuffer ( 515 UINT32 FileId); 516 517 void 518 LsWriteListingHexBytes ( 519 UINT8 *Buffer, 520 UINT32 Length, 521 UINT32 FileId); 522 523 void 524 LsWriteSourceLines ( 525 UINT32 ToLineNumber, 526 UINT32 ToLogicalLineNumber, 527 UINT32 FileId); 528 529 UINT32 530 LsWriteOneSourceLine ( 531 UINT32 FileId); 532 533 void 534 LsPushNode ( 535 char *Filename); 536 537 ASL_LISTING_NODE * 538 LsPopNode ( 539 void); 540 541 542 /* 543 * aslhex - generate all "hex" output files (C, ASM, ASL) 544 */ 545 void 546 HxDoHexOutput ( 547 void); 548 549 550 /* 551 * aslfold - constant folding 552 */ 553 ACPI_STATUS 554 OpcAmlConstantWalk ( 555 ACPI_PARSE_OBJECT *Op, 556 UINT32 Level, 557 void *Context); 558 559 560 /* 561 * aslmessages - exception strings 562 */ 563 const char * 564 AeDecodeMessageId ( 565 UINT16 MessageId); 566 567 const char * 568 AeDecodeExceptionLevel ( 569 UINT8 Level); 570 571 UINT16 572 AeBuildFullExceptionCode ( 573 UINT8 Level, 574 UINT16 MessageId); 575 576 /* 577 * asloffset - generate C offset file for BIOS support 578 */ 579 ACPI_STATUS 580 LsAmlOffsetWalk ( 581 ACPI_PARSE_OBJECT *Op, 582 UINT32 Level, 583 void *Context); 584 585 void 586 LsDoOffsetTableHeader ( 587 UINT32 FileId); 588 589 void 590 LsDoOffsetTableFooter ( 591 UINT32 FileId); 592 593 594 /* 595 * aslopcodes - generate AML opcodes 596 */ 597 ACPI_STATUS 598 OpcAmlOpcodeWalk ( 599 ACPI_PARSE_OBJECT *Op, 600 UINT32 Level, 601 void *Context); 602 603 ACPI_STATUS 604 OpcAmlOpcodeUpdateWalk ( 605 ACPI_PARSE_OBJECT *Op, 606 UINT32 Level, 607 void *Context); 608 609 void 610 OpcGenerateAmlOpcode ( 611 ACPI_PARSE_OBJECT *Op); 612 613 UINT32 614 OpcSetOptimalIntegerSize ( 615 ACPI_PARSE_OBJECT *Op); 616 617 void 618 OpcGetIntegerWidth ( 619 ACPI_PARSE_OBJECT *Op); 620 621 622 /* 623 * asloperands - generate AML operands for the AML opcodes 624 */ 625 ACPI_PARSE_OBJECT * 626 UtGetArg ( 627 ACPI_PARSE_OBJECT *Op, 628 UINT32 Argn); 629 630 void 631 OpnGenerateAmlOperands ( 632 ACPI_PARSE_OBJECT *Op); 633 634 void 635 OpnDoPackage ( 636 ACPI_PARSE_OBJECT *Op); 637 638 639 /* 640 * aslopt - optmization 641 */ 642 void 643 OptOptimizeNamePath ( 644 ACPI_PARSE_OBJECT *Op, 645 UINT32 Flags, 646 ACPI_WALK_STATE *WalkState, 647 char *AmlNameString, 648 ACPI_NAMESPACE_NODE *TargetNode); 649 650 651 /* 652 * aslpld - ToPLD macro support 653 */ 654 void 655 OpcDoPld ( 656 ACPI_PARSE_OBJECT *Op); 657 658 659 /* 660 * aslprintf - Printf/Fprintf macros 661 */ 662 void 663 OpcDoPrintf ( 664 ACPI_PARSE_OBJECT *Op); 665 666 void 667 OpcDoFprintf ( 668 ACPI_PARSE_OBJECT *Op); 669 670 671 /* 672 * aslprune - parse tree pruner 673 */ 674 void 675 AslPruneParseTree ( 676 UINT32 PruneDepth, 677 UINT32 Type); 678 679 680 /* 681 * aslcodegen - code generation 682 */ 683 void 684 CgGenerateAmlOutput ( 685 void); 686 687 void 688 CgLocalWriteAmlData ( 689 ACPI_PARSE_OBJECT *Op, 690 void *Buffer, 691 UINT32 Length); 692 693 694 /* 695 * aslfile 696 */ 697 void 698 FlOpenFile ( 699 UINT32 FileId, 700 char *Filename, 701 char *Mode); 702 703 704 /* 705 * asllength - calculate/adjust AML package lengths 706 */ 707 ACPI_STATUS 708 LnPackageLengthWalk ( 709 ACPI_PARSE_OBJECT *Op, 710 UINT32 Level, 711 void *Context); 712 713 ACPI_STATUS 714 LnInitLengthsWalk ( 715 ACPI_PARSE_OBJECT *Op, 716 UINT32 Level, 717 void *Context); 718 719 void 720 CgGenerateAmlLengths ( 721 ACPI_PARSE_OBJECT *Op); 722 723 724 /* 725 * aslmap - opcode mappings and reserved method names 726 */ 727 ACPI_OBJECT_TYPE 728 AslMapNamedOpcodeToDataType ( 729 UINT16 Opcode); 730 731 732 /* 733 * aslpredef - ACPI predefined names support 734 */ 735 BOOLEAN 736 ApCheckForPredefinedMethod ( 737 ACPI_PARSE_OBJECT *Op, 738 ASL_METHOD_INFO *MethodInfo); 739 740 void 741 ApCheckPredefinedReturnValue ( 742 ACPI_PARSE_OBJECT *Op, 743 ASL_METHOD_INFO *MethodInfo); 744 745 UINT32 746 ApCheckForPredefinedName ( 747 ACPI_PARSE_OBJECT *Op, 748 char *Name); 749 750 void 751 ApCheckForPredefinedObject ( 752 ACPI_PARSE_OBJECT *Op, 753 char *Name); 754 755 ACPI_STATUS 756 ApCheckObjectType ( 757 const char *PredefinedName, 758 ACPI_PARSE_OBJECT *Op, 759 UINT32 ExpectedBtypes, 760 UINT32 PackageIndex); 761 762 void 763 ApDisplayReservedNames ( 764 void); 765 766 767 /* 768 * aslprepkg - ACPI predefined names support for packages 769 */ 770 void 771 ApCheckPackage ( 772 ACPI_PARSE_OBJECT *ParentOp, 773 const ACPI_PREDEFINED_INFO *Predefined); 774 775 776 /* 777 * asltransform - parse tree transformations 778 */ 779 ACPI_STATUS 780 TrAmlTransformWalkBegin ( 781 ACPI_PARSE_OBJECT *Op, 782 UINT32 Level, 783 void *Context); 784 785 ACPI_STATUS 786 TrAmlTransformWalkEnd ( 787 ACPI_PARSE_OBJECT *Op, 788 UINT32 Level, 789 void *Context); 790 791 792 /* 793 * asltree - parse tree support 794 */ 795 ACPI_STATUS 796 TrWalkParseTree ( 797 ACPI_PARSE_OBJECT *Op, 798 UINT32 Visitation, 799 ASL_WALK_CALLBACK DescendingCallback, 800 ASL_WALK_CALLBACK AscendingCallback, 801 void *Context); 802 803 /* 804 * aslexternal - External opcode support 805 */ 806 ACPI_STATUS 807 ExAmlExternalWalkBegin ( 808 ACPI_PARSE_OBJECT *Op, 809 UINT32 Level, 810 void *Context); 811 812 ACPI_STATUS 813 ExAmlExternalWalkEnd ( 814 ACPI_PARSE_OBJECT *Op, 815 UINT32 Level, 816 void *Context); 817 818 void 819 ExDoExternal ( 820 ACPI_PARSE_OBJECT *Op); 821 822 /* Values for "Visitation" parameter above */ 823 824 #define ASL_WALK_VISIT_DOWNWARD 0x01 825 #define ASL_WALK_VISIT_UPWARD 0x02 826 #define ASL_WALK_VISIT_TWICE (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD) 827 828 829 void 830 TrSetParent ( 831 ACPI_PARSE_OBJECT *Op, 832 ACPI_PARSE_OBJECT *ParentOp); 833 834 ACPI_PARSE_OBJECT * 835 TrAllocateNode ( 836 UINT32 ParseOpcode); 837 838 void 839 TrPrintNodeCompileFlags ( 840 UINT32 Flags); 841 842 void 843 TrReleaseNode ( 844 ACPI_PARSE_OBJECT *Op); 845 846 ACPI_PARSE_OBJECT * 847 TrUpdateNode ( 848 UINT32 ParseOpcode, 849 ACPI_PARSE_OBJECT *Op); 850 851 ACPI_PARSE_OBJECT * 852 TrCreateNode ( 853 UINT32 ParseOpcode, 854 UINT32 NumChildren, 855 ...); 856 857 ACPI_PARSE_OBJECT * 858 TrCreateLeafNode ( 859 UINT32 ParseOpcode); 860 861 ACPI_PARSE_OBJECT * 862 TrCreateNullTarget ( 863 void); 864 865 ACPI_PARSE_OBJECT * 866 TrCreateAssignmentNode ( 867 ACPI_PARSE_OBJECT *Target, 868 ACPI_PARSE_OBJECT *Source); 869 870 ACPI_PARSE_OBJECT * 871 TrCreateTargetOperand ( 872 ACPI_PARSE_OBJECT *OriginalOp, 873 ACPI_PARSE_OBJECT *ParentOp); 874 875 ACPI_PARSE_OBJECT * 876 TrCreateValuedLeafNode ( 877 UINT32 ParseOpcode, 878 UINT64 Value); 879 880 ACPI_PARSE_OBJECT * 881 TrCreateConstantLeafNode ( 882 UINT32 ParseOpcode); 883 884 ACPI_PARSE_OBJECT * 885 TrLinkChildren ( 886 ACPI_PARSE_OBJECT *Op, 887 UINT32 NumChildren, 888 ...); 889 890 void 891 TrSetEndLineNumber ( 892 ACPI_PARSE_OBJECT *Op); 893 894 void 895 TrSetCurrentFilename ( 896 ACPI_PARSE_OBJECT *Op); 897 898 void 899 TrWalkTree ( 900 void); 901 902 ACPI_PARSE_OBJECT * 903 TrLinkPeerNode ( 904 ACPI_PARSE_OBJECT *Op1, 905 ACPI_PARSE_OBJECT *Op2); 906 907 ACPI_PARSE_OBJECT * 908 TrLinkChildNode ( 909 ACPI_PARSE_OBJECT *Op1, 910 ACPI_PARSE_OBJECT *Op2); 911 912 ACPI_PARSE_OBJECT * 913 TrSetNodeFlags ( 914 ACPI_PARSE_OBJECT *Op, 915 UINT32 Flags); 916 917 ACPI_PARSE_OBJECT * 918 TrSetNodeAmlLength ( 919 ACPI_PARSE_OBJECT *Op, 920 UINT32 Length); 921 922 ACPI_PARSE_OBJECT * 923 TrLinkPeerNodes ( 924 UINT32 NumPeers, 925 ...); 926 927 928 /* 929 * aslfiles - File I/O support 930 */ 931 void 932 FlAddIncludeDirectory ( 933 char *Dir); 934 935 char * 936 FlMergePathnames ( 937 char *PrefixDir, 938 char *FilePathname); 939 940 void 941 FlOpenIncludeFile ( 942 ACPI_PARSE_OBJECT *Op); 943 944 void 945 FlFileError ( 946 UINT32 FileId, 947 UINT8 ErrorId); 948 949 UINT32 950 FlGetFileSize ( 951 UINT32 FileId); 952 953 ACPI_STATUS 954 FlReadFile ( 955 UINT32 FileId, 956 void *Buffer, 957 UINT32 Length); 958 959 void 960 FlWriteFile ( 961 UINT32 FileId, 962 void *Buffer, 963 UINT32 Length); 964 965 void 966 FlSeekFile ( 967 UINT32 FileId, 968 long Offset); 969 970 void 971 FlCloseFile ( 972 UINT32 FileId); 973 974 void 975 FlPrintFile ( 976 UINT32 FileId, 977 char *Format, 978 ...); 979 980 void 981 FlDeleteFile ( 982 UINT32 FileId); 983 984 void 985 FlSetLineNumber ( 986 UINT32 LineNumber); 987 988 void 989 FlSetFilename ( 990 char *Filename); 991 992 ACPI_STATUS 993 FlOpenInputFile ( 994 char *InputFilename); 995 996 ACPI_STATUS 997 FlOpenAmlOutputFile ( 998 char *InputFilename); 999 1000 ACPI_STATUS 1001 FlOpenMiscOutputFiles ( 1002 char *InputFilename); 1003 1004 /* 1005 * aslhwmap - hardware map summary 1006 */ 1007 void 1008 MpEmitMappingInfo ( 1009 void); 1010 1011 1012 /* 1013 * asload - load namespace in prep for cross reference 1014 */ 1015 ACPI_STATUS 1016 LdLoadNamespace ( 1017 ACPI_PARSE_OBJECT *RootOp); 1018 1019 1020 /* 1021 * asllookup - namespace lookup functions 1022 */ 1023 void 1024 LkFindUnreferencedObjects ( 1025 void); 1026 1027 /* 1028 * aslhelp - help screens 1029 */ 1030 void 1031 Usage ( 1032 void); 1033 1034 void 1035 AslFilenameHelp ( 1036 void); 1037 1038 void 1039 AslDisassemblyHelp ( 1040 void); 1041 1042 1043 /* 1044 * aslnamesp - namespace output file generation 1045 */ 1046 ACPI_STATUS 1047 NsDisplayNamespace ( 1048 void); 1049 1050 void 1051 NsSetupNamespaceListing ( 1052 void *Handle); 1053 1054 /* 1055 * asloptions - command line processing 1056 */ 1057 int 1058 AslCommandLine ( 1059 int argc, 1060 char **argv); 1061 1062 /* 1063 * aslxref - namespace cross reference 1064 */ 1065 ACPI_STATUS 1066 XfCrossReferenceNamespace ( 1067 void); 1068 1069 1070 /* 1071 * aslxrefout 1072 */ 1073 void 1074 OtPrintHeaders ( 1075 char *Message); 1076 1077 void 1078 OtCreateXrefFile ( 1079 void); 1080 1081 void 1082 OtXrefWalkPart1 ( 1083 ACPI_PARSE_OBJECT *Op, 1084 UINT32 Level, 1085 ASL_METHOD_INFO *MethodInfo); 1086 1087 1088 /* 1089 * aslutils - common compiler utilites 1090 */ 1091 void 1092 DbgPrint ( 1093 UINT32 Type, 1094 char *Format, 1095 ...); 1096 1097 /* Type values for above */ 1098 1099 #define ASL_DEBUG_OUTPUT 0 1100 #define ASL_PARSE_OUTPUT 1 1101 #define ASL_TREE_OUTPUT 2 1102 1103 UINT8 1104 UtIsBigEndianMachine ( 1105 void); 1106 1107 BOOLEAN 1108 UtQueryForOverwrite ( 1109 char *Pathname); 1110 1111 void 1112 UtDumpStringOp ( 1113 ACPI_PARSE_OBJECT *Op, 1114 UINT32 Level); 1115 1116 void 1117 UtDumpIntegerOp ( 1118 ACPI_PARSE_OBJECT *Op, 1119 UINT32 Level, 1120 UINT32 IntegerLength); 1121 1122 void 1123 UtDumpBasicOp ( 1124 ACPI_PARSE_OBJECT *Op, 1125 UINT32 Level); 1126 1127 void 1128 UtDisplaySupportedTables ( 1129 void); 1130 1131 void 1132 UtDisplayConstantOpcodes ( 1133 void); 1134 1135 UINT8 1136 UtBeginEvent ( 1137 char *Name); 1138 1139 void 1140 UtEndEvent ( 1141 UINT8 Event); 1142 1143 void * 1144 UtLocalCalloc ( 1145 UINT32 Size); 1146 1147 void 1148 UtDisplaySummary ( 1149 UINT32 FileId); 1150 1151 void 1152 UtConvertByteToHex ( 1153 UINT8 RawByte, 1154 UINT8 *Buffer); 1155 1156 void 1157 UtConvertByteToAsmHex ( 1158 UINT8 RawByte, 1159 UINT8 *Buffer); 1160 1161 char * 1162 UtGetOpName ( 1163 UINT32 ParseOpcode); 1164 1165 void 1166 UtSetParseOpName ( 1167 ACPI_PARSE_OBJECT *Op); 1168 1169 char * 1170 UtStringCacheCalloc ( 1171 UINT32 Length); 1172 1173 void 1174 UtExpandLineBuffers ( 1175 void); 1176 1177 void 1178 UtFreeLineBuffers ( 1179 void); 1180 1181 ACPI_STATUS 1182 UtInternalizeName ( 1183 char *ExternalName, 1184 char **ConvertedName); 1185 1186 void 1187 UtAttachNamepathToOwner ( 1188 ACPI_PARSE_OBJECT *Op, 1189 ACPI_PARSE_OBJECT *NameNode); 1190 1191 ACPI_PARSE_OBJECT * 1192 UtCheckIntegerRange ( 1193 ACPI_PARSE_OBJECT *Op, 1194 UINT32 LowValue, 1195 UINT32 HighValue); 1196 1197 UINT64 1198 UtDoConstant ( 1199 char *String); 1200 1201 1202 /* 1203 * asluuid - UUID support 1204 */ 1205 ACPI_STATUS 1206 AuValidateUuid ( 1207 char *InString); 1208 1209 ACPI_STATUS 1210 AuConvertUuidToString ( 1211 char *UuIdBuffer, 1212 char *OutString); 1213 1214 /* 1215 * aslresource - Resource template generation utilities 1216 */ 1217 void 1218 RsSmallAddressCheck ( 1219 UINT8 Type, 1220 UINT32 Minimum, 1221 UINT32 Maximum, 1222 UINT32 Length, 1223 UINT32 Alignment, 1224 ACPI_PARSE_OBJECT *MinOp, 1225 ACPI_PARSE_OBJECT *MaxOp, 1226 ACPI_PARSE_OBJECT *LengthOp, 1227 ACPI_PARSE_OBJECT *AlignOp, 1228 ACPI_PARSE_OBJECT *Op); 1229 1230 void 1231 RsLargeAddressCheck ( 1232 UINT64 Minimum, 1233 UINT64 Maximum, 1234 UINT64 Length, 1235 UINT64 Granularity, 1236 UINT8 Flags, 1237 ACPI_PARSE_OBJECT *MinOp, 1238 ACPI_PARSE_OBJECT *MaxOp, 1239 ACPI_PARSE_OBJECT *LengthOp, 1240 ACPI_PARSE_OBJECT *GranOp, 1241 ACPI_PARSE_OBJECT *Op); 1242 1243 UINT16 1244 RsGetStringDataLength ( 1245 ACPI_PARSE_OBJECT *InitializerOp); 1246 1247 ASL_RESOURCE_NODE * 1248 RsAllocateResourceNode ( 1249 UINT32 Size); 1250 1251 void 1252 RsCreateResourceField ( 1253 ACPI_PARSE_OBJECT *Op, 1254 char *Name, 1255 UINT32 ByteOffset, 1256 UINT32 BitOffset, 1257 UINT32 BitLength); 1258 1259 void 1260 RsSetFlagBits ( 1261 UINT8 *Flags, 1262 ACPI_PARSE_OBJECT *Op, 1263 UINT8 Position, 1264 UINT8 DefaultBit); 1265 1266 void 1267 RsSetFlagBits16 ( 1268 UINT16 *Flags, 1269 ACPI_PARSE_OBJECT *Op, 1270 UINT8 Position, 1271 UINT8 DefaultBit); 1272 1273 ACPI_PARSE_OBJECT * 1274 RsCompleteNodeAndGetNext ( 1275 ACPI_PARSE_OBJECT *Op); 1276 1277 void 1278 RsCheckListForDuplicates ( 1279 ACPI_PARSE_OBJECT *Op); 1280 1281 ASL_RESOURCE_NODE * 1282 RsDoOneResourceDescriptor ( 1283 ASL_RESOURCE_INFO *Info, 1284 UINT8 *State); 1285 1286 /* Values for State above */ 1287 1288 #define ACPI_RSTATE_NORMAL 0 1289 #define ACPI_RSTATE_START_DEPENDENT 1 1290 #define ACPI_RSTATE_DEPENDENT_LIST 2 1291 1292 UINT32 1293 RsLinkDescriptorChain ( 1294 ASL_RESOURCE_NODE **PreviousRnode, 1295 ASL_RESOURCE_NODE *Rnode); 1296 1297 void 1298 RsDoResourceTemplate ( 1299 ACPI_PARSE_OBJECT *Op); 1300 1301 1302 /* 1303 * aslrestype1 - Miscellaneous Small descriptors 1304 */ 1305 ASL_RESOURCE_NODE * 1306 RsDoEndTagDescriptor ( 1307 ASL_RESOURCE_INFO *Info); 1308 1309 ASL_RESOURCE_NODE * 1310 RsDoEndDependentDescriptor ( 1311 ASL_RESOURCE_INFO *Info); 1312 1313 ASL_RESOURCE_NODE * 1314 RsDoMemory24Descriptor ( 1315 ASL_RESOURCE_INFO *Info); 1316 1317 ASL_RESOURCE_NODE * 1318 RsDoMemory32Descriptor ( 1319 ASL_RESOURCE_INFO *Info); 1320 1321 ASL_RESOURCE_NODE * 1322 RsDoMemory32FixedDescriptor ( 1323 ASL_RESOURCE_INFO *Info); 1324 1325 ASL_RESOURCE_NODE * 1326 RsDoStartDependentDescriptor ( 1327 ASL_RESOURCE_INFO *Info); 1328 1329 ASL_RESOURCE_NODE * 1330 RsDoStartDependentNoPriDescriptor ( 1331 ASL_RESOURCE_INFO *Info); 1332 1333 ASL_RESOURCE_NODE * 1334 RsDoVendorSmallDescriptor ( 1335 ASL_RESOURCE_INFO *Info); 1336 1337 1338 /* 1339 * aslrestype1i - I/O-related Small descriptors 1340 */ 1341 ASL_RESOURCE_NODE * 1342 RsDoDmaDescriptor ( 1343 ASL_RESOURCE_INFO *Info); 1344 1345 ASL_RESOURCE_NODE * 1346 RsDoFixedDmaDescriptor ( 1347 ASL_RESOURCE_INFO *Info); 1348 1349 ASL_RESOURCE_NODE * 1350 RsDoFixedIoDescriptor ( 1351 ASL_RESOURCE_INFO *Info); 1352 1353 ASL_RESOURCE_NODE * 1354 RsDoIoDescriptor ( 1355 ASL_RESOURCE_INFO *Info); 1356 1357 ASL_RESOURCE_NODE * 1358 RsDoIrqDescriptor ( 1359 ASL_RESOURCE_INFO *Info); 1360 1361 ASL_RESOURCE_NODE * 1362 RsDoIrqNoFlagsDescriptor ( 1363 ASL_RESOURCE_INFO *Info); 1364 1365 1366 /* 1367 * aslrestype2 - Large resource descriptors 1368 */ 1369 ASL_RESOURCE_NODE * 1370 RsDoInterruptDescriptor ( 1371 ASL_RESOURCE_INFO *Info); 1372 1373 ASL_RESOURCE_NODE * 1374 RsDoVendorLargeDescriptor ( 1375 ASL_RESOURCE_INFO *Info); 1376 1377 ASL_RESOURCE_NODE * 1378 RsDoGeneralRegisterDescriptor ( 1379 ASL_RESOURCE_INFO *Info); 1380 1381 ASL_RESOURCE_NODE * 1382 RsDoGpioIntDescriptor ( 1383 ASL_RESOURCE_INFO *Info); 1384 1385 ASL_RESOURCE_NODE * 1386 RsDoGpioIoDescriptor ( 1387 ASL_RESOURCE_INFO *Info); 1388 1389 ASL_RESOURCE_NODE * 1390 RsDoI2cSerialBusDescriptor ( 1391 ASL_RESOURCE_INFO *Info); 1392 1393 ASL_RESOURCE_NODE * 1394 RsDoSpiSerialBusDescriptor ( 1395 ASL_RESOURCE_INFO *Info); 1396 1397 ASL_RESOURCE_NODE * 1398 RsDoUartSerialBusDescriptor ( 1399 ASL_RESOURCE_INFO *Info); 1400 1401 /* 1402 * aslrestype2d - DWord address descriptors 1403 */ 1404 ASL_RESOURCE_NODE * 1405 RsDoDwordIoDescriptor ( 1406 ASL_RESOURCE_INFO *Info); 1407 1408 ASL_RESOURCE_NODE * 1409 RsDoDwordMemoryDescriptor ( 1410 ASL_RESOURCE_INFO *Info); 1411 1412 ASL_RESOURCE_NODE * 1413 RsDoDwordSpaceDescriptor ( 1414 ASL_RESOURCE_INFO *Info); 1415 1416 1417 /* 1418 * aslrestype2e - Extended address descriptors 1419 */ 1420 ASL_RESOURCE_NODE * 1421 RsDoExtendedIoDescriptor ( 1422 ASL_RESOURCE_INFO *Info); 1423 1424 ASL_RESOURCE_NODE * 1425 RsDoExtendedMemoryDescriptor ( 1426 ASL_RESOURCE_INFO *Info); 1427 1428 ASL_RESOURCE_NODE * 1429 RsDoExtendedSpaceDescriptor ( 1430 ASL_RESOURCE_INFO *Info); 1431 1432 1433 /* 1434 * aslrestype2q - QWord address descriptors 1435 */ 1436 ASL_RESOURCE_NODE * 1437 RsDoQwordIoDescriptor ( 1438 ASL_RESOURCE_INFO *Info); 1439 1440 ASL_RESOURCE_NODE * 1441 RsDoQwordMemoryDescriptor ( 1442 ASL_RESOURCE_INFO *Info); 1443 1444 ASL_RESOURCE_NODE * 1445 RsDoQwordSpaceDescriptor ( 1446 ASL_RESOURCE_INFO *Info); 1447 1448 1449 /* 1450 * aslrestype2w - Word address descriptors 1451 */ 1452 ASL_RESOURCE_NODE * 1453 RsDoWordIoDescriptor ( 1454 ASL_RESOURCE_INFO *Info); 1455 1456 ASL_RESOURCE_NODE * 1457 RsDoWordSpaceDescriptor ( 1458 ASL_RESOURCE_INFO *Info); 1459 1460 ASL_RESOURCE_NODE * 1461 RsDoWordBusNumberDescriptor ( 1462 ASL_RESOURCE_INFO *Info); 1463 1464 1465 /* 1466 * Entry to data table compiler subsystem 1467 */ 1468 ACPI_STATUS 1469 DtDoCompile( 1470 void); 1471 1472 ACPI_STATUS 1473 DtCreateTemplates ( 1474 char **argv); 1475 1476 1477 /* 1478 * ASL/ASL+ converter debug 1479 */ 1480 void 1481 CvDbgPrint ( 1482 char *Fmt, 1483 ...); 1484 1485 1486 #endif /* __ASLCOMPILER_H */ 1487