1 /****************************************************************************** 2 * 3 * Module Name: aslcompiler.h - common include file for iASL 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 45 #ifndef __ASLCOMPILER_H 46 #define __ASLCOMPILER_H 47 48 #include <contrib/dev/acpica/include/acpi.h> 49 #include <contrib/dev/acpica/include/accommon.h> 50 #include <contrib/dev/acpica/include/amlresrc.h> 51 #include <contrib/dev/acpica/include/acdebug.h> 52 53 /* Microsoft-specific */ 54 55 #if (defined WIN32 || defined WIN64) 56 57 /* warn : used #pragma pack */ 58 #pragma warning(disable:4103) 59 60 /* warn : named type definition in parentheses */ 61 #pragma warning(disable:4115) 62 #endif 63 64 #include <stdio.h> 65 #include <stdlib.h> 66 #include <stdarg.h> 67 #include <string.h> 68 #include <errno.h> 69 #include <ctype.h> 70 71 /* Compiler headers */ 72 73 #include <contrib/dev/acpica/compiler/asldefine.h> 74 #include <contrib/dev/acpica/compiler/asltypes.h> 75 #include <contrib/dev/acpica/compiler/aslmessages.h> 76 #include <contrib/dev/acpica/compiler/aslglobal.h> 77 #include <contrib/dev/acpica/compiler/preprocess.h> 78 79 80 /******************************************************************************* 81 * 82 * Compiler prototypes 83 * 84 ******************************************************************************/ 85 86 /* 87 * Main ASL parser - generated from flex/bison, lex/yacc, etc. 88 */ 89 ACPI_PARSE_OBJECT * 90 AslDoError ( 91 void); 92 93 int 94 AslCompilerlex( 95 void); 96 97 void 98 AslResetCurrentLineBuffer ( 99 void); 100 101 void 102 AslInsertLineBuffer ( 103 int SourceChar); 104 105 int 106 AslPopInputFileStack ( 107 void); 108 109 void 110 AslPushInputFileStack ( 111 FILE *InputFile, 112 char *Filename); 113 114 /* 115 * aslstartup - entered from main() 116 */ 117 void 118 AslInitializeGlobals ( 119 void); 120 121 typedef 122 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) ( 123 char *); 124 125 ACPI_STATUS 126 AslDoOnePathname ( 127 char *Pathname, 128 ASL_PATHNAME_CALLBACK Callback); 129 130 ACPI_STATUS 131 AslDoOneFile ( 132 char *Filename); 133 134 ACPI_STATUS 135 AslCheckForErrorExit ( 136 void); 137 138 139 /* 140 * aslcompile - compile mainline 141 */ 142 void 143 AslCompilerSignon ( 144 UINT32 FileId); 145 146 void 147 AslCompilerFileHeader ( 148 UINT32 FileId); 149 150 int 151 CmDoCompile ( 152 void); 153 154 void 155 CmDoOutputFiles ( 156 void); 157 158 void 159 CmCleanupAndExit ( 160 void); 161 162 ACPI_STATUS 163 FlCheckForAcpiTable ( 164 FILE *Handle); 165 166 ACPI_STATUS 167 FlCheckForAscii ( 168 FILE *Handle, 169 char *Filename, 170 BOOLEAN DisplayErrors); 171 172 173 /* 174 * aslwalks - semantic analysis and parse tree walks 175 */ 176 ACPI_STATUS 177 AnOtherSemanticAnalysisWalkBegin ( 178 ACPI_PARSE_OBJECT *Op, 179 UINT32 Level, 180 void *Context); 181 182 ACPI_STATUS 183 AnOtherSemanticAnalysisWalkEnd ( 184 ACPI_PARSE_OBJECT *Op, 185 UINT32 Level, 186 void *Context); 187 188 ACPI_STATUS 189 AnOperandTypecheckWalkEnd ( 190 ACPI_PARSE_OBJECT *Op, 191 UINT32 Level, 192 void *Context); 193 194 ACPI_STATUS 195 AnMethodTypingWalkEnd ( 196 ACPI_PARSE_OBJECT *Op, 197 UINT32 Level, 198 void *Context); 199 200 201 /* 202 * aslmethod - Control method analysis walk 203 */ 204 ACPI_STATUS 205 MtMethodAnalysisWalkBegin ( 206 ACPI_PARSE_OBJECT *Op, 207 UINT32 Level, 208 void *Context); 209 210 ACPI_STATUS 211 MtMethodAnalysisWalkEnd ( 212 ACPI_PARSE_OBJECT *Op, 213 UINT32 Level, 214 void *Context); 215 216 217 /* 218 * aslbtypes - bitfield data types 219 */ 220 UINT32 221 AnMapObjTypeToBtype ( 222 ACPI_PARSE_OBJECT *Op); 223 224 UINT32 225 AnMapArgTypeToBtype ( 226 UINT32 ArgType); 227 228 UINT32 229 AnGetBtype ( 230 ACPI_PARSE_OBJECT *Op); 231 232 void 233 AnFormatBtype ( 234 char *Buffer, 235 UINT32 Btype); 236 237 238 /* 239 * aslanalyze - Support functions for parse tree walks 240 */ 241 void 242 AnCheckId ( 243 ACPI_PARSE_OBJECT *Op, 244 ACPI_NAME Type); 245 246 /* Values for Type argument above */ 247 248 #define ASL_TYPE_HID 0 249 #define ASL_TYPE_CID 1 250 251 BOOLEAN 252 AnIsInternalMethod ( 253 ACPI_PARSE_OBJECT *Op); 254 255 UINT32 256 AnGetInternalMethodReturnType ( 257 ACPI_PARSE_OBJECT *Op); 258 259 BOOLEAN 260 AnLastStatementIsReturn ( 261 ACPI_PARSE_OBJECT *Op); 262 263 void 264 AnCheckMethodReturnValue ( 265 ACPI_PARSE_OBJECT *Op, 266 const ACPI_OPCODE_INFO *OpInfo, 267 ACPI_PARSE_OBJECT *ArgOp, 268 UINT32 RequiredBtypes, 269 UINT32 ThisNodeBtype); 270 271 BOOLEAN 272 AnIsResultUsed ( 273 ACPI_PARSE_OBJECT *Op); 274 275 void 276 ApCheckForGpeNameConflict ( 277 ACPI_PARSE_OBJECT *Op); 278 279 void 280 ApCheckRegMethod ( 281 ACPI_PARSE_OBJECT *Op); 282 283 284 /* 285 * aslerror - error handling/reporting 286 */ 287 void 288 AslError ( 289 UINT8 Level, 290 UINT8 MessageId, 291 ACPI_PARSE_OBJECT *Op, 292 char *ExtraMessage); 293 294 void 295 AslCoreSubsystemError ( 296 ACPI_PARSE_OBJECT *Op, 297 ACPI_STATUS Status, 298 char *ExtraMessage, 299 BOOLEAN Abort); 300 301 int 302 AslCompilererror( 303 const char *s); 304 305 void 306 AslCommonError ( 307 UINT8 Level, 308 UINT8 MessageId, 309 UINT32 CurrentLineNumber, 310 UINT32 LogicalLineNumber, 311 UINT32 LogicalByteOffset, 312 UINT32 Column, 313 char *Filename, 314 char *ExtraMessage); 315 316 void 317 AslCommonError2 ( 318 UINT8 Level, 319 UINT8 MessageId, 320 UINT32 LineNumber, 321 UINT32 Column, 322 char *SourceLine, 323 char *Filename, 324 char *ExtraMessage); 325 326 void 327 AePrintException ( 328 UINT32 FileId, 329 ASL_ERROR_MSG *Enode, 330 char *Header); 331 332 void 333 AePrintErrorLog ( 334 UINT32 FileId); 335 336 void 337 AeClearErrorLog ( 338 void); 339 340 ACPI_PHYSICAL_ADDRESS 341 AeLocalGetRootPointer ( 342 void); 343 344 345 /* 346 * asllisting - generate all "listing" type files 347 */ 348 void 349 LsDoListings ( 350 void); 351 352 void 353 LsWriteNodeToAsmListing ( 354 ACPI_PARSE_OBJECT *Op); 355 356 void 357 LsWriteNode ( 358 ACPI_PARSE_OBJECT *Op, 359 UINT32 FileId); 360 361 void 362 LsDumpParseTree ( 363 void); 364 365 366 /* 367 * asllistsup - Listing file support utilities 368 */ 369 void 370 LsDumpAscii ( 371 UINT32 FileId, 372 UINT32 Count, 373 UINT8 *Buffer); 374 375 void 376 LsDumpAsciiInComment ( 377 UINT32 FileId, 378 UINT32 Count, 379 UINT8 *Buffer); 380 381 void 382 LsCheckException ( 383 UINT32 LineNumber, 384 UINT32 FileId); 385 386 void 387 LsFlushListingBuffer ( 388 UINT32 FileId); 389 390 void 391 LsWriteListingHexBytes ( 392 UINT8 *Buffer, 393 UINT32 Length, 394 UINT32 FileId); 395 396 void 397 LsWriteSourceLines ( 398 UINT32 ToLineNumber, 399 UINT32 ToLogicalLineNumber, 400 UINT32 FileId); 401 402 UINT32 403 LsWriteOneSourceLine ( 404 UINT32 FileId); 405 406 void 407 LsPushNode ( 408 char *Filename); 409 410 ASL_LISTING_NODE * 411 LsPopNode ( 412 void); 413 414 415 /* 416 * aslhex - generate all "hex" output files (C, ASM, ASL) 417 */ 418 void 419 HxDoHexOutput ( 420 void); 421 422 423 /* 424 * aslfold - constant folding 425 */ 426 ACPI_STATUS 427 OpcAmlConstantWalk ( 428 ACPI_PARSE_OBJECT *Op, 429 UINT32 Level, 430 void *Context); 431 432 433 /* 434 * asloffset - generate C offset file for BIOS support 435 */ 436 ACPI_STATUS 437 LsAmlOffsetWalk ( 438 ACPI_PARSE_OBJECT *Op, 439 UINT32 Level, 440 void *Context); 441 442 void 443 LsDoOffsetTableHeader ( 444 UINT32 FileId); 445 446 void 447 LsDoOffsetTableFooter ( 448 UINT32 FileId); 449 450 451 /* 452 * aslopcodes - generate AML opcodes 453 */ 454 ACPI_STATUS 455 OpcAmlOpcodeWalk ( 456 ACPI_PARSE_OBJECT *Op, 457 UINT32 Level, 458 void *Context); 459 460 ACPI_STATUS 461 OpcAmlOpcodeUpdateWalk ( 462 ACPI_PARSE_OBJECT *Op, 463 UINT32 Level, 464 void *Context); 465 466 void 467 OpcGenerateAmlOpcode ( 468 ACPI_PARSE_OBJECT *Op); 469 470 UINT32 471 OpcSetOptimalIntegerSize ( 472 ACPI_PARSE_OBJECT *Op); 473 474 void 475 OpcGetIntegerWidth ( 476 ACPI_PARSE_OBJECT *Op); 477 478 479 /* 480 * asloperands - generate AML operands for the AML opcodes 481 */ 482 ACPI_PARSE_OBJECT * 483 UtGetArg ( 484 ACPI_PARSE_OBJECT *Op, 485 UINT32 Argn); 486 487 void 488 OpnGenerateAmlOperands ( 489 ACPI_PARSE_OBJECT *Op); 490 491 void 492 OpnDoPackage ( 493 ACPI_PARSE_OBJECT *Op); 494 495 496 /* 497 * aslopt - optmization 498 */ 499 void 500 OptOptimizeNamePath ( 501 ACPI_PARSE_OBJECT *Op, 502 UINT32 Flags, 503 ACPI_WALK_STATE *WalkState, 504 char *AmlNameString, 505 ACPI_NAMESPACE_NODE *TargetNode); 506 507 508 /* 509 * aslcodegen - code generation 510 */ 511 void 512 CgGenerateAmlOutput ( 513 void); 514 515 516 /* 517 * aslfile 518 */ 519 void 520 FlOpenFile ( 521 UINT32 FileId, 522 char *Filename, 523 char *Mode); 524 525 526 /* 527 * asllength - calculate/adjust AML package lengths 528 */ 529 ACPI_STATUS 530 LnPackageLengthWalk ( 531 ACPI_PARSE_OBJECT *Op, 532 UINT32 Level, 533 void *Context); 534 535 ACPI_STATUS 536 LnInitLengthsWalk ( 537 ACPI_PARSE_OBJECT *Op, 538 UINT32 Level, 539 void *Context); 540 541 void 542 CgGenerateAmlLengths ( 543 ACPI_PARSE_OBJECT *Op); 544 545 546 /* 547 * aslmap - opcode mappings and reserved method names 548 */ 549 ACPI_OBJECT_TYPE 550 AslMapNamedOpcodeToDataType ( 551 UINT16 Opcode); 552 553 554 /* 555 * aslpredef - ACPI predefined names support 556 */ 557 BOOLEAN 558 ApCheckForPredefinedMethod ( 559 ACPI_PARSE_OBJECT *Op, 560 ASL_METHOD_INFO *MethodInfo); 561 562 void 563 ApCheckPredefinedReturnValue ( 564 ACPI_PARSE_OBJECT *Op, 565 ASL_METHOD_INFO *MethodInfo); 566 567 UINT32 568 ApCheckForPredefinedName ( 569 ACPI_PARSE_OBJECT *Op, 570 char *Name); 571 572 void 573 ApCheckForPredefinedObject ( 574 ACPI_PARSE_OBJECT *Op, 575 char *Name); 576 577 ACPI_STATUS 578 ApCheckObjectType ( 579 const char *PredefinedName, 580 ACPI_PARSE_OBJECT *Op, 581 UINT32 ExpectedBtypes, 582 UINT32 PackageIndex); 583 584 void 585 ApDisplayReservedNames ( 586 void); 587 588 589 /* 590 * aslprepkg - ACPI predefined names support for packages 591 */ 592 void 593 ApCheckPackage ( 594 ACPI_PARSE_OBJECT *ParentOp, 595 const ACPI_PREDEFINED_INFO *Predefined); 596 597 598 /* 599 * asltransform - parse tree transformations 600 */ 601 ACPI_STATUS 602 TrAmlTransformWalk ( 603 ACPI_PARSE_OBJECT *Op, 604 UINT32 Level, 605 void *Context); 606 607 608 /* 609 * asltree - parse tree support 610 */ 611 ACPI_STATUS 612 TrWalkParseTree ( 613 ACPI_PARSE_OBJECT *Op, 614 UINT32 Visitation, 615 ASL_WALK_CALLBACK DescendingCallback, 616 ASL_WALK_CALLBACK AscendingCallback, 617 void *Context); 618 619 /* Values for "Visitation" parameter above */ 620 621 #define ASL_WALK_VISIT_DOWNWARD 0x01 622 #define ASL_WALK_VISIT_UPWARD 0x02 623 #define ASL_WALK_VISIT_TWICE (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD) 624 625 626 ACPI_PARSE_OBJECT * 627 TrAllocateNode ( 628 UINT32 ParseOpcode); 629 630 void 631 TrReleaseNode ( 632 ACPI_PARSE_OBJECT *Op); 633 634 ACPI_PARSE_OBJECT * 635 TrUpdateNode ( 636 UINT32 ParseOpcode, 637 ACPI_PARSE_OBJECT *Op); 638 639 ACPI_PARSE_OBJECT * 640 TrCreateNode ( 641 UINT32 ParseOpcode, 642 UINT32 NumChildren, 643 ...); 644 645 ACPI_PARSE_OBJECT * 646 TrCreateLeafNode ( 647 UINT32 ParseOpcode); 648 649 ACPI_PARSE_OBJECT * 650 TrCreateValuedLeafNode ( 651 UINT32 ParseOpcode, 652 UINT64 Value); 653 654 ACPI_PARSE_OBJECT * 655 TrCreateConstantLeafNode ( 656 UINT32 ParseOpcode); 657 658 ACPI_PARSE_OBJECT * 659 TrLinkChildren ( 660 ACPI_PARSE_OBJECT *Op, 661 UINT32 NumChildren, 662 ...); 663 664 void 665 TrSetEndLineNumber ( 666 ACPI_PARSE_OBJECT *Op); 667 668 void 669 TrWalkTree ( 670 void); 671 672 ACPI_PARSE_OBJECT * 673 TrLinkPeerNode ( 674 ACPI_PARSE_OBJECT *Op1, 675 ACPI_PARSE_OBJECT *Op2); 676 677 ACPI_PARSE_OBJECT * 678 TrLinkChildNode ( 679 ACPI_PARSE_OBJECT *Op1, 680 ACPI_PARSE_OBJECT *Op2); 681 682 ACPI_PARSE_OBJECT * 683 TrSetNodeFlags ( 684 ACPI_PARSE_OBJECT *Op, 685 UINT32 Flags); 686 687 ACPI_PARSE_OBJECT * 688 TrSetNodeAmlLength ( 689 ACPI_PARSE_OBJECT *Op, 690 UINT32 Length); 691 692 ACPI_PARSE_OBJECT * 693 TrLinkPeerNodes ( 694 UINT32 NumPeers, 695 ...); 696 697 698 /* 699 * aslfiles - File I/O support 700 */ 701 void 702 AslAbort ( 703 void); 704 705 void 706 FlAddIncludeDirectory ( 707 char *Dir); 708 709 char * 710 FlMergePathnames ( 711 char *PrefixDir, 712 char *FilePathname); 713 714 void 715 FlOpenIncludeFile ( 716 ACPI_PARSE_OBJECT *Op); 717 718 void 719 FlFileError ( 720 UINT32 FileId, 721 UINT8 ErrorId); 722 723 UINT32 724 FlGetFileSize ( 725 UINT32 FileId); 726 727 ACPI_STATUS 728 FlReadFile ( 729 UINT32 FileId, 730 void *Buffer, 731 UINT32 Length); 732 733 void 734 FlWriteFile ( 735 UINT32 FileId, 736 void *Buffer, 737 UINT32 Length); 738 739 void 740 FlSeekFile ( 741 UINT32 FileId, 742 long Offset); 743 744 void 745 FlCloseFile ( 746 UINT32 FileId); 747 748 void 749 FlPrintFile ( 750 UINT32 FileId, 751 char *Format, 752 ...); 753 754 void 755 FlDeleteFile ( 756 UINT32 FileId); 757 758 void 759 FlSetLineNumber ( 760 UINT32 LineNumber); 761 762 void 763 FlSetFilename ( 764 char *Filename); 765 766 ACPI_STATUS 767 FlOpenInputFile ( 768 char *InputFilename); 769 770 ACPI_STATUS 771 FlOpenAmlOutputFile ( 772 char *InputFilename); 773 774 ACPI_STATUS 775 FlOpenMiscOutputFiles ( 776 char *InputFilename); 777 778 779 /* 780 * asload - load namespace in prep for cross reference 781 */ 782 ACPI_STATUS 783 LdLoadNamespace ( 784 ACPI_PARSE_OBJECT *RootOp); 785 786 787 /* 788 * asllookup - namespace lookup functions 789 */ 790 void 791 LkFindUnreferencedObjects ( 792 void); 793 794 795 /* 796 * aslnamesp - namespace output file generation 797 */ 798 ACPI_STATUS 799 NsDisplayNamespace ( 800 void); 801 802 void 803 NsSetupNamespaceListing ( 804 void *Handle); 805 806 807 /* 808 * aslxref - namespace cross reference 809 */ 810 ACPI_STATUS 811 XfCrossReferenceNamespace ( 812 void); 813 814 815 /* 816 * aslutils - common compiler utilites 817 */ 818 void 819 DbgPrint ( 820 UINT32 Type, 821 char *Format, 822 ...); 823 824 /* Type values for above */ 825 826 #define ASL_DEBUG_OUTPUT 0 827 #define ASL_PARSE_OUTPUT 1 828 #define ASL_TREE_OUTPUT 2 829 830 void 831 UtDisplaySupportedTables ( 832 void); 833 834 void 835 UtDisplayConstantOpcodes ( 836 void); 837 838 UINT8 839 UtBeginEvent ( 840 char *Name); 841 842 void 843 UtEndEvent ( 844 UINT8 Event); 845 846 void * 847 UtLocalCalloc ( 848 UINT32 Size); 849 850 void 851 UtPrintFormattedName ( 852 UINT16 ParseOpcode, 853 UINT32 Level); 854 855 void 856 UtDisplaySummary ( 857 UINT32 FileId); 858 859 UINT8 860 UtHexCharToValue ( 861 int HexChar); 862 863 void 864 UtConvertByteToHex ( 865 UINT8 RawByte, 866 UINT8 *Buffer); 867 868 void 869 UtConvertByteToAsmHex ( 870 UINT8 RawByte, 871 UINT8 *Buffer); 872 873 char * 874 UtGetOpName ( 875 UINT32 ParseOpcode); 876 877 void 878 UtSetParseOpName ( 879 ACPI_PARSE_OBJECT *Op); 880 881 char * 882 UtGetStringBuffer ( 883 UINT32 Length); 884 885 void 886 UtExpandLineBuffers ( 887 void); 888 889 ACPI_STATUS 890 UtInternalizeName ( 891 char *ExternalName, 892 char **ConvertedName); 893 894 void 895 UtAttachNamepathToOwner ( 896 ACPI_PARSE_OBJECT *Op, 897 ACPI_PARSE_OBJECT *NameNode); 898 899 ACPI_PARSE_OBJECT * 900 UtCheckIntegerRange ( 901 ACPI_PARSE_OBJECT *Op, 902 UINT32 LowValue, 903 UINT32 HighValue); 904 905 UINT64 906 UtDoConstant ( 907 char *String); 908 909 ACPI_STATUS 910 UtStrtoul64 ( 911 char *String, 912 UINT32 Base, 913 UINT64 *RetInteger); 914 915 916 /* 917 * asluuid - UUID support 918 */ 919 ACPI_STATUS 920 AuValidateUuid ( 921 char *InString); 922 923 ACPI_STATUS 924 AuConvertStringToUuid ( 925 char *InString, 926 char *UuIdBuffer); 927 928 ACPI_STATUS 929 AuConvertUuidToString ( 930 char *UuIdBuffer, 931 char *OutString); 932 933 /* 934 * aslresource - Resource template generation utilities 935 */ 936 void 937 RsSmallAddressCheck ( 938 UINT8 Type, 939 UINT32 Minimum, 940 UINT32 Maximum, 941 UINT32 Length, 942 UINT32 Alignment, 943 ACPI_PARSE_OBJECT *MinOp, 944 ACPI_PARSE_OBJECT *MaxOp, 945 ACPI_PARSE_OBJECT *LengthOp, 946 ACPI_PARSE_OBJECT *AlignOp, 947 ACPI_PARSE_OBJECT *Op); 948 949 void 950 RsLargeAddressCheck ( 951 UINT64 Minimum, 952 UINT64 Maximum, 953 UINT64 Length, 954 UINT64 Granularity, 955 UINT8 Flags, 956 ACPI_PARSE_OBJECT *MinOp, 957 ACPI_PARSE_OBJECT *MaxOp, 958 ACPI_PARSE_OBJECT *LengthOp, 959 ACPI_PARSE_OBJECT *GranOp, 960 ACPI_PARSE_OBJECT *Op); 961 962 UINT16 963 RsGetStringDataLength ( 964 ACPI_PARSE_OBJECT *InitializerOp); 965 966 ASL_RESOURCE_NODE * 967 RsAllocateResourceNode ( 968 UINT32 Size); 969 970 void 971 RsCreateResourceField ( 972 ACPI_PARSE_OBJECT *Op, 973 char *Name, 974 UINT32 ByteOffset, 975 UINT32 BitOffset, 976 UINT32 BitLength); 977 978 void 979 RsSetFlagBits ( 980 UINT8 *Flags, 981 ACPI_PARSE_OBJECT *Op, 982 UINT8 Position, 983 UINT8 DefaultBit); 984 985 void 986 RsSetFlagBits16 ( 987 UINT16 *Flags, 988 ACPI_PARSE_OBJECT *Op, 989 UINT8 Position, 990 UINT8 DefaultBit); 991 992 ACPI_PARSE_OBJECT * 993 RsCompleteNodeAndGetNext ( 994 ACPI_PARSE_OBJECT *Op); 995 996 void 997 RsCheckListForDuplicates ( 998 ACPI_PARSE_OBJECT *Op); 999 1000 ASL_RESOURCE_NODE * 1001 RsDoOneResourceDescriptor ( 1002 ACPI_PARSE_OBJECT *DescriptorTypeOp, 1003 UINT32 CurrentByteOffset, 1004 UINT8 *State); 1005 1006 /* Values for State above */ 1007 1008 #define ACPI_RSTATE_NORMAL 0 1009 #define ACPI_RSTATE_START_DEPENDENT 1 1010 #define ACPI_RSTATE_DEPENDENT_LIST 2 1011 1012 UINT32 1013 RsLinkDescriptorChain ( 1014 ASL_RESOURCE_NODE **PreviousRnode, 1015 ASL_RESOURCE_NODE *Rnode); 1016 1017 void 1018 RsDoResourceTemplate ( 1019 ACPI_PARSE_OBJECT *Op); 1020 1021 1022 /* 1023 * aslrestype1 - Miscellaneous Small descriptors 1024 */ 1025 ASL_RESOURCE_NODE * 1026 RsDoEndTagDescriptor ( 1027 ACPI_PARSE_OBJECT *Op, 1028 UINT32 CurrentByteOffset); 1029 1030 ASL_RESOURCE_NODE * 1031 RsDoEndDependentDescriptor ( 1032 ACPI_PARSE_OBJECT *Op, 1033 UINT32 CurrentByteOffset); 1034 1035 ASL_RESOURCE_NODE * 1036 RsDoMemory24Descriptor ( 1037 ACPI_PARSE_OBJECT *Op, 1038 UINT32 CurrentByteOffset); 1039 1040 ASL_RESOURCE_NODE * 1041 RsDoMemory32Descriptor ( 1042 ACPI_PARSE_OBJECT *Op, 1043 UINT32 CurrentByteOffset); 1044 1045 ASL_RESOURCE_NODE * 1046 RsDoMemory32FixedDescriptor ( 1047 ACPI_PARSE_OBJECT *Op, 1048 UINT32 CurrentByteOffset); 1049 1050 ASL_RESOURCE_NODE * 1051 RsDoStartDependentDescriptor ( 1052 ACPI_PARSE_OBJECT *Op, 1053 UINT32 CurrentByteOffset); 1054 1055 ASL_RESOURCE_NODE * 1056 RsDoStartDependentNoPriDescriptor ( 1057 ACPI_PARSE_OBJECT *Op, 1058 UINT32 CurrentByteOffset); 1059 1060 ASL_RESOURCE_NODE * 1061 RsDoVendorSmallDescriptor ( 1062 ACPI_PARSE_OBJECT *Op, 1063 UINT32 CurrentByteOffset); 1064 1065 1066 /* 1067 * aslrestype1i - I/O-related Small descriptors 1068 */ 1069 ASL_RESOURCE_NODE * 1070 RsDoDmaDescriptor ( 1071 ACPI_PARSE_OBJECT *Op, 1072 UINT32 CurrentByteOffset); 1073 1074 ASL_RESOURCE_NODE * 1075 RsDoFixedDmaDescriptor ( 1076 ACPI_PARSE_OBJECT *Op, 1077 UINT32 CurrentByteOffset); 1078 1079 ASL_RESOURCE_NODE * 1080 RsDoFixedIoDescriptor ( 1081 ACPI_PARSE_OBJECT *Op, 1082 UINT32 CurrentByteOffset); 1083 1084 ASL_RESOURCE_NODE * 1085 RsDoIoDescriptor ( 1086 ACPI_PARSE_OBJECT *Op, 1087 UINT32 CurrentByteOffset); 1088 1089 ASL_RESOURCE_NODE * 1090 RsDoIrqDescriptor ( 1091 ACPI_PARSE_OBJECT *Op, 1092 UINT32 CurrentByteOffset); 1093 1094 ASL_RESOURCE_NODE * 1095 RsDoIrqNoFlagsDescriptor ( 1096 ACPI_PARSE_OBJECT *Op, 1097 UINT32 CurrentByteOffset); 1098 1099 1100 /* 1101 * aslrestype2 - Large resource descriptors 1102 */ 1103 ASL_RESOURCE_NODE * 1104 RsDoInterruptDescriptor ( 1105 ACPI_PARSE_OBJECT *Op, 1106 UINT32 CurrentByteOffset); 1107 1108 ASL_RESOURCE_NODE * 1109 RsDoVendorLargeDescriptor ( 1110 ACPI_PARSE_OBJECT *Op, 1111 UINT32 CurrentByteOffset); 1112 1113 ASL_RESOURCE_NODE * 1114 RsDoGeneralRegisterDescriptor ( 1115 ACPI_PARSE_OBJECT *Op, 1116 UINT32 CurrentByteOffset); 1117 1118 ASL_RESOURCE_NODE * 1119 RsDoGpioIntDescriptor ( 1120 ACPI_PARSE_OBJECT *Op, 1121 UINT32 CurrentByteOffset); 1122 1123 ASL_RESOURCE_NODE * 1124 RsDoGpioIoDescriptor ( 1125 ACPI_PARSE_OBJECT *Op, 1126 UINT32 CurrentByteOffset); 1127 1128 ASL_RESOURCE_NODE * 1129 RsDoI2cSerialBusDescriptor ( 1130 ACPI_PARSE_OBJECT *Op, 1131 UINT32 CurrentByteOffset); 1132 1133 ASL_RESOURCE_NODE * 1134 RsDoSpiSerialBusDescriptor ( 1135 ACPI_PARSE_OBJECT *Op, 1136 UINT32 CurrentByteOffset); 1137 1138 ASL_RESOURCE_NODE * 1139 RsDoUartSerialBusDescriptor ( 1140 ACPI_PARSE_OBJECT *Op, 1141 UINT32 CurrentByteOffset); 1142 1143 /* 1144 * aslrestype2d - DWord address descriptors 1145 */ 1146 ASL_RESOURCE_NODE * 1147 RsDoDwordIoDescriptor ( 1148 ACPI_PARSE_OBJECT *Op, 1149 UINT32 CurrentByteOffset); 1150 1151 ASL_RESOURCE_NODE * 1152 RsDoDwordMemoryDescriptor ( 1153 ACPI_PARSE_OBJECT *Op, 1154 UINT32 CurrentByteOffset); 1155 1156 ASL_RESOURCE_NODE * 1157 RsDoDwordSpaceDescriptor ( 1158 ACPI_PARSE_OBJECT *Op, 1159 UINT32 CurrentByteOffset); 1160 1161 1162 /* 1163 * aslrestype2e - Extended address descriptors 1164 */ 1165 ASL_RESOURCE_NODE * 1166 RsDoExtendedIoDescriptor ( 1167 ACPI_PARSE_OBJECT *Op, 1168 UINT32 CurrentByteOffset); 1169 1170 ASL_RESOURCE_NODE * 1171 RsDoExtendedMemoryDescriptor ( 1172 ACPI_PARSE_OBJECT *Op, 1173 UINT32 CurrentByteOffset); 1174 1175 ASL_RESOURCE_NODE * 1176 RsDoExtendedSpaceDescriptor ( 1177 ACPI_PARSE_OBJECT *Op, 1178 UINT32 CurrentByteOffset); 1179 1180 1181 /* 1182 * aslrestype2q - QWord address descriptors 1183 */ 1184 ASL_RESOURCE_NODE * 1185 RsDoQwordIoDescriptor ( 1186 ACPI_PARSE_OBJECT *Op, 1187 UINT32 CurrentByteOffset); 1188 1189 ASL_RESOURCE_NODE * 1190 RsDoQwordMemoryDescriptor ( 1191 ACPI_PARSE_OBJECT *Op, 1192 UINT32 CurrentByteOffset); 1193 1194 ASL_RESOURCE_NODE * 1195 RsDoQwordSpaceDescriptor ( 1196 ACPI_PARSE_OBJECT *Op, 1197 UINT32 CurrentByteOffset); 1198 1199 1200 /* 1201 * aslrestype2w - Word address descriptors 1202 */ 1203 ASL_RESOURCE_NODE * 1204 RsDoWordIoDescriptor ( 1205 ACPI_PARSE_OBJECT *Op, 1206 UINT32 CurrentByteOffset); 1207 1208 ASL_RESOURCE_NODE * 1209 RsDoWordSpaceDescriptor ( 1210 ACPI_PARSE_OBJECT *Op, 1211 UINT32 CurrentByteOffset); 1212 1213 ASL_RESOURCE_NODE * 1214 RsDoWordBusNumberDescriptor ( 1215 ACPI_PARSE_OBJECT *Op, 1216 UINT32 CurrentByteOffset); 1217 1218 /* 1219 * Entry to data table compiler subsystem 1220 */ 1221 ACPI_STATUS 1222 DtDoCompile( 1223 void); 1224 1225 ACPI_STATUS 1226 DtCreateTemplates ( 1227 char *Signature); 1228 1229 #endif /* __ASLCOMPILER_H */ 1230