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