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 - 2011, 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
  79
  80 /*******************************************************************************
  81  *
  82  * Compiler prototypes
  83  *
  84  ******************************************************************************/
  85
  86 /*
  87  * parser - generated from flex/bison, lex/yacc, etc.
  88  */
  89 int
  90 AslCompilerparse(
  91     void);
  92
  93 ACPI_PARSE_OBJECT *
  94 AslDoError (
  95     void);
  96
  97 int
  98 AslCompilerlex(
  99     void);
 100
 101 void
 102 ResetCurrentLineBuffer (
 103     void);
 104
 105 void
 106 InsertLineBuffer (
 107     int                     SourceChar);
 108
 109 int
 110 AslPopInputFileStack (
 111     void);
 112
 113 void
 114 AslPushInputFileStack (
 115     FILE                    *InputFile,
 116     char                    *Filename);
 117
 118 /*
 119  * aslstartup - entered from main()
 120  */
 121 void
 122 AslInitializeGlobals (
 123     void);
 124
 125 typedef
 126 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) (
 127     char *);
 128
 129 ACPI_STATUS
 130 AslDoOnePathname (
 131     char                    *Pathname,
 132     ASL_PATHNAME_CALLBACK   Callback);
 133
 134 ACPI_STATUS
 135 AslDoOneFile (
 136     char                    *Filename);
 137
 138 /*
 139  * aslcompile - compile mainline
 140  */
 141 void
 142 AslCompilerSignon (
 143     UINT32                  FileId);
 144
 145 void
 146 AslCompilerFileHeader (
 147     UINT32                  FileId);
 148
 149 int
 150 CmDoCompile (
 151     void);
 152
 153 void
 154 CmDoOutputFiles (
 155     void);
 156
 157 void
 158 CmCleanupAndExit (
 159     void);
 160
 161 ACPI_STATUS
 162 FlCheckForAscii (
 163     ASL_FILE_INFO           *FileInfo);
 164
 165
 166 /*
 167  * aslwalks - semantic analysis and parse tree walks
 168  */
 169 ACPI_STATUS
 170 AnOtherSemanticAnalysisWalkBegin (
 171     ACPI_PARSE_OBJECT       *Op,
 172     UINT32                  Level,
 173     void                    *Context);
 174
 175 ACPI_STATUS
 176 AnOtherSemanticAnalysisWalkEnd (
 177     ACPI_PARSE_OBJECT       *Op,
 178     UINT32                  Level,
 179     void                    *Context);
 180
 181 ACPI_STATUS
 182 AnOperandTypecheckWalkEnd (
 183     ACPI_PARSE_OBJECT       *Op,
 184     UINT32                  Level,
 185     void                    *Context);
 186
 187 ACPI_STATUS
 188 AnMethodAnalysisWalkBegin (
 189     ACPI_PARSE_OBJECT       *Op,
 190     UINT32                  Level,
 191     void                    *Context);
 192
 193 ACPI_STATUS
 194 AnMethodAnalysisWalkEnd (
 195     ACPI_PARSE_OBJECT       *Op,
 196     UINT32                  Level,
 197     void                    *Context);
 198
 199 ACPI_STATUS
 200 AnMethodTypingWalkEnd (
 201     ACPI_PARSE_OBJECT       *Op,
 202     UINT32                  Level,
 203     void                    *Context);
 204
 205
 206 /*
 207  * aslbtypes - bitfield data types
 208  */
 209 UINT32
 210 AnMapObjTypeToBtype (
 211     ACPI_PARSE_OBJECT       *Op);
 212
 213 UINT32
 214 AnMapArgTypeToBtype (
 215     UINT32                  ArgType);
 216
 217 UINT32
 218 AnGetBtype (
 219     ACPI_PARSE_OBJECT       *Op);
 220
 221 void
 222 AnFormatBtype (
 223     char                    *Buffer,
 224     UINT32                  Btype);
 225
 226
 227 /*
 228  * aslanalyze - Support functions for parse tree walks
 229  */
 230 void
 231 AnCheckId (
 232     ACPI_PARSE_OBJECT       *Op,
 233     ACPI_NAME               Type);
 234
 235 /* Values for Type argument above */
 236
 237 #define ASL_TYPE_HID        0
 238 #define ASL_TYPE_CID        1
 239
 240 BOOLEAN
 241 AnIsInternalMethod (
 242     ACPI_PARSE_OBJECT       *Op);
 243
 244 UINT32
 245 AnGetInternalMethodReturnType (
 246     ACPI_PARSE_OBJECT       *Op);
 247
 248 BOOLEAN
 249 AnLastStatementIsReturn (
 250     ACPI_PARSE_OBJECT       *Op);
 251
 252 void
 253 AnCheckMethodReturnValue (
 254     ACPI_PARSE_OBJECT       *Op,
 255     const ACPI_OPCODE_INFO  *OpInfo,
 256     ACPI_PARSE_OBJECT       *ArgOp,
 257     UINT32                  RequiredBtypes,
 258     UINT32                  ThisNodeBtype);
 259
 260 BOOLEAN
 261 AnIsResultUsed (
 262     ACPI_PARSE_OBJECT       *Op);
 263
 264 void
 265 ApCheckForGpeNameConflict (
 266     ACPI_PARSE_OBJECT       *Op);
 267
 268 void
 269 ApCheckRegMethod (
 270     ACPI_PARSE_OBJECT       *Op);
 271
 272
 273 /*
 274  * aslerror - error handling/reporting
 275  */
 276 void
 277 AslError (
 278     UINT8                   Level,
 279     UINT8                   MessageId,
 280     ACPI_PARSE_OBJECT       *Op,
 281     char                    *ExtraMessage);
 282
 283 void
 284 AslCoreSubsystemError (
 285     ACPI_PARSE_OBJECT       *Op,
 286     ACPI_STATUS             Status,
 287     char                    *ExtraMessage,
 288     BOOLEAN                 Abort);
 289
 290 int
 291 AslCompilererror(
 292     char                    *s);
 293
 294 void
 295 AslCommonError (
 296     UINT8                   Level,
 297     UINT8                   MessageId,
 298     UINT32                  CurrentLineNumber,
 299     UINT32                  LogicalLineNumber,
 300     UINT32                  LogicalByteOffset,
 301     UINT32                  Column,
 302     char                    *Filename,
 303     char                    *ExtraMessage);
 304
 305 void
 306 AePrintException (
 307     UINT32                  FileId,
 308     ASL_ERROR_MSG           *Enode,
 309     char                    *Header);
 310
 311 void
 312 AePrintErrorLog (
 313     UINT32                  FileId);
 314
 315 void
 316 AeClearErrorLog (
 317     void);
 318
 319 ACPI_PHYSICAL_ADDRESS
 320 AeLocalGetRootPointer (
 321     void);
 322
 323
 324 /*
 325  * asllisting - generate all "listing" type files
 326  */
 327 void
 328 LsDoListings (
 329     void);
 330
 331 void
 332 LsWriteNodeToAsmListing (
 333     ACPI_PARSE_OBJECT       *Op);
 334
 335 void
 336 LsWriteNode (
 337     ACPI_PARSE_OBJECT       *Op,
 338     UINT32                  FileId);
 339
 340 void
 341 LsDoHexOutput (
 342     void);
 343
 344 void
 345 LsDumpParseTree (
 346     void);
 347
 348 /*
 349  * aslfold - constant folding
 350  */
 351 ACPI_STATUS
 352 OpcAmlConstantWalk (
 353     ACPI_PARSE_OBJECT       *Op,
 354     UINT32                  Level,
 355     void                    *Context);
 356
 357
 358 /*
 359  * aslopcodes - generate AML opcodes
 360  */
 361 ACPI_STATUS
 362 OpcAmlOpcodeWalk (
 363     ACPI_PARSE_OBJECT       *Op,
 364     UINT32                  Level,
 365     void                    *Context);
 366
 367 ACPI_STATUS
 368 OpcAmlOpcodeUpdateWalk (
 369     ACPI_PARSE_OBJECT       *Op,
 370     UINT32                  Level,
 371     void                    *Context);
 372
 373 void
 374 OpcGenerateAmlOpcode (
 375     ACPI_PARSE_OBJECT       *Op);
 376
 377 UINT32
 378 OpcSetOptimalIntegerSize (
 379     ACPI_PARSE_OBJECT       *Op);
 380
 381 void
 382 OpcGetIntegerWidth (
 383     ACPI_PARSE_OBJECT       *Op);
 384
 385
 386 /*
 387  * asloperands - generate AML operands for the AML opcodes
 388  */
 389 ACPI_PARSE_OBJECT  *
 390 UtGetArg (
 391     ACPI_PARSE_OBJECT       *Op,
 392     UINT32                  Argn);
 393
 394 void
 395 OpnGenerateAmlOperands (
 396     ACPI_PARSE_OBJECT       *Op);
 397
 398 void
 399 OpnDoPackage (
 400     ACPI_PARSE_OBJECT       *Op);
 401
 402
 403 /*
 404  * aslopt - optmization
 405  */
 406 void
 407 OptOptimizeNamePath (
 408     ACPI_PARSE_OBJECT       *Op,
 409     UINT32                  Flags,
 410     ACPI_WALK_STATE         *WalkState,
 411     char                    *AmlNameString,
 412     ACPI_NAMESPACE_NODE     *TargetNode);
 413
 414
 415 /*
 416  * aslcodegen - code generation
 417  */
 418 void
 419 CgGenerateAmlOutput (
 420     void);
 421
 422
 423 /*
 424  * aslfile
 425  */
 426 void
 427 FlOpenFile (
 428     UINT32                  FileId,
 429     char                    *Filename,
 430     char                    *Mode);
 431
 432
 433 /*
 434  * asllength - calculate/adjust AML package lengths
 435  */
 436 ACPI_STATUS
 437 LnPackageLengthWalk (
 438     ACPI_PARSE_OBJECT       *Op,
 439     UINT32                  Level,
 440     void                    *Context);
 441
 442 ACPI_STATUS
 443 LnInitLengthsWalk (
 444     ACPI_PARSE_OBJECT       *Op,
 445     UINT32                  Level,
 446     void                    *Context);
 447
 448 void
 449 CgGenerateAmlLengths (
 450     ACPI_PARSE_OBJECT       *Op);
 451
 452
 453 /*
 454  * aslmap - opcode mappings and reserved method names
 455  */
 456 ACPI_OBJECT_TYPE
 457 AslMapNamedOpcodeToDataType (
 458     UINT16                  Opcode);
 459
 460
 461 /*
 462  * aslpredef - ACPI predefined names support
 463  */
 464 BOOLEAN
 465 ApCheckForPredefinedMethod (
 466     ACPI_PARSE_OBJECT       *Op,
 467     ASL_METHOD_INFO         *MethodInfo);
 468
 469 void
 470 ApCheckPredefinedReturnValue (
 471     ACPI_PARSE_OBJECT       *Op,
 472     ASL_METHOD_INFO         *MethodInfo);
 473
 474 UINT32
 475 ApCheckForPredefinedName (
 476     ACPI_PARSE_OBJECT       *Op,
 477     char                    *Name);
 478
 479 void
 480 ApCheckForPredefinedObject (
 481     ACPI_PARSE_OBJECT       *Op,
 482     char                    *Name);
 483
 484 void
 485 ApDisplayReservedNames (
 486     void);
 487
 488
 489 /*
 490  * asltransform - parse tree transformations
 491  */
 492 ACPI_STATUS
 493 TrAmlTransformWalk (
 494     ACPI_PARSE_OBJECT       *Op,
 495     UINT32                  Level,
 496     void                    *Context);
 497
 498
 499 /*
 500  * asltree - parse tree support
 501  */
 502 ACPI_STATUS
 503 TrWalkParseTree (
 504     ACPI_PARSE_OBJECT       *Op,
 505     UINT32                  Visitation,
 506     ASL_WALK_CALLBACK       DescendingCallback,
 507     ASL_WALK_CALLBACK       AscendingCallback,
 508     void                    *Context);
 509
 510 /* Values for "Visitation" parameter above */
 511
 512 #define ASL_WALK_VISIT_DOWNWARD     0x01
 513 #define ASL_WALK_VISIT_UPWARD       0x02
 514 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 515
 516
 517 ACPI_PARSE_OBJECT *
 518 TrAllocateNode (
 519     UINT32                  ParseOpcode);
 520
 521 void
 522 TrReleaseNode (
 523     ACPI_PARSE_OBJECT       *Op);
 524
 525 ACPI_PARSE_OBJECT *
 526 TrUpdateNode (
 527     UINT32                  ParseOpcode,
 528     ACPI_PARSE_OBJECT       *Op);
 529
 530 ACPI_PARSE_OBJECT *
 531 TrCreateNode (
 532     UINT32                  ParseOpcode,
 533     UINT32                  NumChildren,
 534     ...);
 535
 536 ACPI_PARSE_OBJECT *
 537 TrCreateLeafNode (
 538     UINT32                  ParseOpcode);
 539
 540 ACPI_PARSE_OBJECT *
 541 TrCreateValuedLeafNode (
 542     UINT32                  ParseOpcode,
 543     UINT64                  Value);
 544
 545 ACPI_PARSE_OBJECT *
 546 TrCreateConstantLeafNode (
 547     UINT32                  ParseOpcode);
 548
 549 ACPI_PARSE_OBJECT *
 550 TrLinkChildren (
 551     ACPI_PARSE_OBJECT       *Op,
 552     UINT32                  NumChildren,
 553     ...);
 554
 555 void
 556 TrSetEndLineNumber (
 557     ACPI_PARSE_OBJECT       *Op);
 558
 559 void
 560 TrWalkTree (
 561     void);
 562
 563 ACPI_PARSE_OBJECT *
 564 TrLinkPeerNode (
 565     ACPI_PARSE_OBJECT       *Op1,
 566     ACPI_PARSE_OBJECT       *Op2);
 567
 568 ACPI_PARSE_OBJECT *
 569 TrLinkChildNode (
 570     ACPI_PARSE_OBJECT       *Op1,
 571     ACPI_PARSE_OBJECT       *Op2);
 572
 573 ACPI_PARSE_OBJECT *
 574 TrSetNodeFlags (
 575     ACPI_PARSE_OBJECT       *Op,
 576     UINT32                  Flags);
 577
 578 ACPI_PARSE_OBJECT *
 579 TrLinkPeerNodes (
 580     UINT32                  NumPeers,
 581     ...);
 582
 583
 584 /*
 585  * aslfiles - File I/O support
 586  */
 587 void
 588 AslAbort (
 589     void);
 590
 591 void
 592 FlAddIncludeDirectory (
 593     char                    *Dir);
 594
 595 void
 596 FlOpenIncludeFile (
 597     ACPI_PARSE_OBJECT       *Op);
 598
 599 void
 600 FlFileError (
 601     UINT32                  FileId,
 602     UINT8                   ErrorId);
 603
 604 UINT32
 605 FlGetFileSize (
 606     UINT32                  FileId);
 607
 608 ACPI_STATUS
 609 FlReadFile (
 610     UINT32                  FileId,
 611     void                    *Buffer,
 612     UINT32                  Length);
 613
 614 void
 615 FlWriteFile (
 616     UINT32                  FileId,
 617     void                    *Buffer,
 618     UINT32                  Length);
 619
 620 void
 621 FlSeekFile (
 622     UINT32                  FileId,
 623     long                    Offset);
 624
 625 void
 626 FlCloseFile (
 627     UINT32                  FileId);
 628
 629 void
 630 FlPrintFile (
 631     UINT32                  FileId,
 632     char                    *Format,
 633     ...);
 634
 635 void
 636 FlSetLineNumber (
 637     ACPI_PARSE_OBJECT       *Op);
 638
 639 ACPI_STATUS
 640 FlOpenInputFile (
 641     char                    *InputFilename);
 642
 643 ACPI_STATUS
 644 FlOpenAmlOutputFile (
 645     char                    *InputFilename);
 646
 647 ACPI_STATUS
 648 FlOpenMiscOutputFiles (
 649     char                    *InputFilename);
 650
 651
 652 /*
 653  * asload - load namespace in prep for cross reference
 654  */
 655 ACPI_STATUS
 656 LdLoadNamespace (
 657     ACPI_PARSE_OBJECT       *RootOp);
 658
 659
 660 /*
 661  * asllookup - namespace cross reference
 662  */
 663 ACPI_STATUS
 664 LkCrossReferenceNamespace (
 665     void);
 666
 667 void
 668 LkFindUnreferencedObjects (
 669     void);
 670
 671 ACPI_STATUS
 672 LsDisplayNamespace (
 673     void);
 674
 675 void
 676 LsSetupNsList (
 677     void                    *Handle);
 678
 679
 680 /*
 681  * aslutils - common compiler utilites
 682  */
 683 void
 684 DbgPrint (
 685     UINT32                  Type,
 686     char                    *Format,
 687     ...);
 688
 689 /* Type values for above */
 690
 691 #define ASL_DEBUG_OUTPUT    0
 692 #define ASL_PARSE_OUTPUT    1
 693 #define ASL_TREE_OUTPUT     2
 694
 695 void
 696 UtDisplaySupportedTables (
 697     void);
 698
 699 void
 700 UtDisplayConstantOpcodes (
 701     void);
 702
 703 UINT8
 704 UtBeginEvent (
 705     char                    *Name);
 706
 707 void
 708 UtEndEvent (
 709     UINT8                   Event);
 710
 711 void *
 712 UtLocalCalloc (
 713     UINT32                  Size);
 714
 715 void
 716 UtPrintFormattedName (
 717     UINT16                  ParseOpcode,
 718     UINT32                  Level);
 719
 720 void
 721 UtDisplaySummary (
 722     UINT32                  FileId);
 723
 724 UINT8
 725 UtHexCharToValue (
 726     int                     HexChar);
 727
 728 void
 729 UtConvertByteToHex (
 730     UINT8                   RawByte,
 731     UINT8                   *Buffer);
 732
 733 void
 734 UtConvertByteToAsmHex (
 735     UINT8                   RawByte,
 736     UINT8                   *Buffer);
 737
 738 char *
 739 UtGetOpName (
 740     UINT32                  ParseOpcode);
 741
 742 void
 743 UtSetParseOpName (
 744     ACPI_PARSE_OBJECT       *Op);
 745
 746 char *
 747 UtGetStringBuffer (
 748     UINT32                  Length);
 749
 750 ACPI_STATUS
 751 UtInternalizeName (
 752     char                    *ExternalName,
 753     char                    **ConvertedName);
 754
 755 void
 756 UtAttachNamepathToOwner (
 757     ACPI_PARSE_OBJECT       *Op,
 758     ACPI_PARSE_OBJECT       *NameNode);
 759
 760 ACPI_PARSE_OBJECT *
 761 UtCheckIntegerRange (
 762     ACPI_PARSE_OBJECT       *Op,
 763     UINT32                  LowValue,
 764     UINT32                  HighValue);
 765
 766 UINT64
 767 UtDoConstant (
 768     char                    *String);
 769
 770 ACPI_STATUS
 771 UtStrtoul64 (
 772     char                    *String,
 773     UINT32                  Base,
 774     UINT64                  *RetInteger);
 775
 776
 777 /*
 778  * asluuid - UUID support
 779  */
 780 ACPI_STATUS
 781 AuValidateUuid (
 782     char                    *InString);
 783
 784 ACPI_STATUS
 785 AuConvertStringToUuid (
 786     char                    *InString,
 787     char                    *UuIdBuffer);
 788
 789 ACPI_STATUS
 790 AuConvertUuidToString (
 791     char                    *UuIdBuffer,
 792     char                    *OutString);
 793
 794 /*
 795  * aslresource - Resource template generation utilities
 796  */
 797 void
 798 RsSmallAddressCheck (
 799     UINT8                   Type,
 800     UINT32                  Minimum,
 801     UINT32                  Maximum,
 802     UINT32                  Length,
 803     UINT32                  Alignment,
 804     ACPI_PARSE_OBJECT       *MinOp,
 805     ACPI_PARSE_OBJECT       *MaxOp,
 806     ACPI_PARSE_OBJECT       *LengthOp,
 807     ACPI_PARSE_OBJECT       *AlignOp,
 808     ACPI_PARSE_OBJECT       *Op);
 809
 810 void
 811 RsLargeAddressCheck (
 812     UINT64                  Minimum,
 813     UINT64                  Maximum,
 814     UINT64                  Length,
 815     UINT64                  Granularity,
 816     UINT8                   Flags,
 817     ACPI_PARSE_OBJECT       *MinOp,
 818     ACPI_PARSE_OBJECT       *MaxOp,
 819     ACPI_PARSE_OBJECT       *LengthOp,
 820     ACPI_PARSE_OBJECT       *GranOp,
 821     ACPI_PARSE_OBJECT       *Op);
 822
 823 UINT16
 824 RsGetStringDataLength (
 825     ACPI_PARSE_OBJECT       *InitializerOp);
 826
 827 ASL_RESOURCE_NODE *
 828 RsAllocateResourceNode (
 829     UINT32                  Size);
 830
 831 void
 832 RsCreateBitField (
 833     ACPI_PARSE_OBJECT       *Op,
 834     char                    *Name,
 835     UINT32                  ByteOffset,
 836     UINT32                  BitOffset);
 837
 838 void
 839 RsCreateByteField (
 840     ACPI_PARSE_OBJECT       *Op,
 841     char                    *Name,
 842     UINT32                  ByteOffset);
 843
 844 void
 845 RsSetFlagBits (
 846     UINT8                   *Flags,
 847     ACPI_PARSE_OBJECT       *Op,
 848     UINT8                   Position,
 849     UINT8                   DefaultBit);
 850
 851 ACPI_PARSE_OBJECT *
 852 RsCompleteNodeAndGetNext (
 853     ACPI_PARSE_OBJECT       *Op);
 854
 855 void
 856 RsCheckListForDuplicates (
 857     ACPI_PARSE_OBJECT       *Op);
 858
 859 ASL_RESOURCE_NODE *
 860 RsDoOneResourceDescriptor (
 861     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
 862     UINT32                  CurrentByteOffset,
 863     UINT8                   *State);
 864
 865 /* Values for State above */
 866
 867 #define ACPI_RSTATE_NORMAL              0
 868 #define ACPI_RSTATE_START_DEPENDENT     1
 869 #define ACPI_RSTATE_DEPENDENT_LIST      2
 870
 871 UINT32
 872 RsLinkDescriptorChain (
 873     ASL_RESOURCE_NODE       **PreviousRnode,
 874     ASL_RESOURCE_NODE       *Rnode);
 875
 876 void
 877 RsDoResourceTemplate (
 878     ACPI_PARSE_OBJECT       *Op);
 879
 880
 881 /*
 882  * aslrestype1 - Miscellaneous Small descriptors
 883  */
 884 ASL_RESOURCE_NODE *
 885 RsDoEndTagDescriptor (
 886     ACPI_PARSE_OBJECT       *Op,
 887     UINT32                  CurrentByteOffset);
 888
 889 ASL_RESOURCE_NODE *
 890 RsDoEndDependentDescriptor (
 891     ACPI_PARSE_OBJECT       *Op,
 892     UINT32                  CurrentByteOffset);
 893
 894 ASL_RESOURCE_NODE *
 895 RsDoMemory24Descriptor (
 896     ACPI_PARSE_OBJECT       *Op,
 897     UINT32                  CurrentByteOffset);
 898
 899 ASL_RESOURCE_NODE *
 900 RsDoMemory32Descriptor (
 901     ACPI_PARSE_OBJECT       *Op,
 902     UINT32                  CurrentByteOffset);
 903
 904 ASL_RESOURCE_NODE *
 905 RsDoMemory32FixedDescriptor (
 906     ACPI_PARSE_OBJECT       *Op,
 907     UINT32                  CurrentByteOffset);
 908
 909 ASL_RESOURCE_NODE *
 910 RsDoStartDependentDescriptor (
 911     ACPI_PARSE_OBJECT       *Op,
 912     UINT32                  CurrentByteOffset);
 913
 914 ASL_RESOURCE_NODE *
 915 RsDoStartDependentNoPriDescriptor (
 916     ACPI_PARSE_OBJECT       *Op,
 917     UINT32                  CurrentByteOffset);
 918
 919 ASL_RESOURCE_NODE *
 920 RsDoVendorSmallDescriptor (
 921     ACPI_PARSE_OBJECT       *Op,
 922     UINT32                  CurrentByteOffset);
 923
 924
 925 /*
 926  * aslrestype1i - I/O-related Small descriptors
 927  */
 928 ASL_RESOURCE_NODE *
 929 RsDoDmaDescriptor (
 930     ACPI_PARSE_OBJECT       *Op,
 931     UINT32                  CurrentByteOffset);
 932
 933 ASL_RESOURCE_NODE *
 934 RsDoFixedIoDescriptor (
 935     ACPI_PARSE_OBJECT       *Op,
 936     UINT32                  CurrentByteOffset);
 937
 938 ASL_RESOURCE_NODE *
 939 RsDoIoDescriptor (
 940     ACPI_PARSE_OBJECT       *Op,
 941     UINT32                  CurrentByteOffset);
 942
 943 ASL_RESOURCE_NODE *
 944 RsDoIrqDescriptor (
 945     ACPI_PARSE_OBJECT       *Op,
 946     UINT32                  CurrentByteOffset);
 947
 948 ASL_RESOURCE_NODE *
 949 RsDoIrqNoFlagsDescriptor (
 950     ACPI_PARSE_OBJECT       *Op,
 951     UINT32                  CurrentByteOffset);
 952
 953
 954 /*
 955  * aslrestype2 - Large resource descriptors
 956  */
 957 ASL_RESOURCE_NODE *
 958 RsDoInterruptDescriptor (
 959     ACPI_PARSE_OBJECT       *Op,
 960     UINT32                  CurrentByteOffset);
 961
 962 ASL_RESOURCE_NODE *
 963 RsDoVendorLargeDescriptor (
 964     ACPI_PARSE_OBJECT       *Op,
 965     UINT32                  CurrentByteOffset);
 966
 967 ASL_RESOURCE_NODE *
 968 RsDoGeneralRegisterDescriptor (
 969     ACPI_PARSE_OBJECT       *Op,
 970     UINT32                  CurrentByteOffset);
 971
 972
 973 /*
 974  * aslrestype2d - DWord address descriptors
 975  */
 976 ASL_RESOURCE_NODE *
 977 RsDoDwordIoDescriptor (
 978     ACPI_PARSE_OBJECT       *Op,
 979     UINT32                  CurrentByteOffset);
 980
 981 ASL_RESOURCE_NODE *
 982 RsDoDwordMemoryDescriptor (
 983     ACPI_PARSE_OBJECT       *Op,
 984     UINT32                  CurrentByteOffset);
 985
 986 ASL_RESOURCE_NODE *
 987 RsDoDwordSpaceDescriptor (
 988     ACPI_PARSE_OBJECT       *Op,
 989     UINT32                  CurrentByteOffset);
 990
 991
 992 /*
 993  * aslrestype2e - Extended address descriptors
 994  */
 995 ASL_RESOURCE_NODE *
 996 RsDoExtendedIoDescriptor (
 997     ACPI_PARSE_OBJECT       *Op,
 998     UINT32                  CurrentByteOffset);
 999
1000 ASL_RESOURCE_NODE *
1001 RsDoExtendedMemoryDescriptor (
1002     ACPI_PARSE_OBJECT       *Op,
1003     UINT32                  CurrentByteOffset);
1004
1005 ASL_RESOURCE_NODE *
1006 RsDoExtendedSpaceDescriptor (
1007     ACPI_PARSE_OBJECT       *Op,
1008     UINT32                  CurrentByteOffset);
1009
1010
1011 /*
1012  * aslrestype2q - QWord address descriptors
1013  */
1014 ASL_RESOURCE_NODE *
1015 RsDoQwordIoDescriptor (
1016     ACPI_PARSE_OBJECT       *Op,
1017     UINT32                  CurrentByteOffset);
1018
1019 ASL_RESOURCE_NODE *
1020 RsDoQwordMemoryDescriptor (
1021     ACPI_PARSE_OBJECT       *Op,
1022     UINT32                  CurrentByteOffset);
1023
1024 ASL_RESOURCE_NODE *
1025 RsDoQwordSpaceDescriptor (
1026     ACPI_PARSE_OBJECT       *Op,
1027     UINT32                  CurrentByteOffset);
1028
1029
1030 /*
1031  * aslrestype2w - Word address descriptors
1032  */
1033 ASL_RESOURCE_NODE *
1034 RsDoWordIoDescriptor (
1035     ACPI_PARSE_OBJECT       *Op,
1036     UINT32                  CurrentByteOffset);
1037
1038 ASL_RESOURCE_NODE *
1039 RsDoWordSpaceDescriptor (
1040     ACPI_PARSE_OBJECT       *Op,
1041     UINT32                  CurrentByteOffset);
1042
1043 ASL_RESOURCE_NODE *
1044 RsDoWordBusNumberDescriptor (
1045     ACPI_PARSE_OBJECT       *Op,
1046     UINT32                  CurrentByteOffset);
1047
1048 /*
1049  * Entry to data table compiler subsystem
1050  */
1051 ACPI_STATUS
1052 DtDoCompile(
1053     void);
1054
1055 ACPI_STATUS
1056 DtCreateTemplates (
1057     char                    *Signature);
1058
1059 #endif /*  __ASLCOMPILER_H */
1060