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