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

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