sys/contrib/dev/acpica/compiler/aslcompiler.h

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