aslcompiler.h revision 246849 
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
353LsDumpAsciiInComment (
354    UINT32                  FileId,
355    UINT32                  Count,
356    UINT8                   *Buffer);
357
358void
359LsWriteNodeToAsmListing (
360    ACPI_PARSE_OBJECT       *Op);
361
362void
363LsWriteNode (
364    ACPI_PARSE_OBJECT       *Op,
365    UINT32                  FileId);
366
367void
368LsDumpParseTree (
369    void);
370
371
372/*
373 * aslhex - generate all "hex" output files (C, ASM, ASL)
374 */
375void
376HxDoHexOutput (
377    void);
378
379
380/*
381 * aslfold - constant folding
382 */
383ACPI_STATUS
384OpcAmlConstantWalk (
385    ACPI_PARSE_OBJECT       *Op,
386    UINT32                  Level,
387    void                    *Context);
388
389
390/*
391 * aslopcodes - generate AML opcodes
392 */
393ACPI_STATUS
394OpcAmlOpcodeWalk (
395    ACPI_PARSE_OBJECT       *Op,
396    UINT32                  Level,
397    void                    *Context);
398
399ACPI_STATUS
400OpcAmlOpcodeUpdateWalk (
401    ACPI_PARSE_OBJECT       *Op,
402    UINT32                  Level,
403    void                    *Context);
404
405void
406OpcGenerateAmlOpcode (
407    ACPI_PARSE_OBJECT       *Op);
408
409UINT32
410OpcSetOptimalIntegerSize (
411    ACPI_PARSE_OBJECT       *Op);
412
413void
414OpcGetIntegerWidth (
415    ACPI_PARSE_OBJECT       *Op);
416
417
418/*
419 * asloperands - generate AML operands for the AML opcodes
420 */
421ACPI_PARSE_OBJECT  *
422UtGetArg (
423    ACPI_PARSE_OBJECT       *Op,
424    UINT32                  Argn);
425
426void
427OpnGenerateAmlOperands (
428    ACPI_PARSE_OBJECT       *Op);
429
430void
431OpnDoPackage (
432    ACPI_PARSE_OBJECT       *Op);
433
434
435/*
436 * aslopt - optmization
437 */
438void
439OptOptimizeNamePath (
440    ACPI_PARSE_OBJECT       *Op,
441    UINT32                  Flags,
442    ACPI_WALK_STATE         *WalkState,
443    char                    *AmlNameString,
444    ACPI_NAMESPACE_NODE     *TargetNode);
445
446
447/*
448 * aslcodegen - code generation
449 */
450void
451CgGenerateAmlOutput (
452    void);
453
454
455/*
456 * aslfile
457 */
458void
459FlOpenFile (
460    UINT32                  FileId,
461    char                    *Filename,
462    char                    *Mode);
463
464
465/*
466 * asllength - calculate/adjust AML package lengths
467 */
468ACPI_STATUS
469LnPackageLengthWalk (
470    ACPI_PARSE_OBJECT       *Op,
471    UINT32                  Level,
472    void                    *Context);
473
474ACPI_STATUS
475LnInitLengthsWalk (
476    ACPI_PARSE_OBJECT       *Op,
477    UINT32                  Level,
478    void                    *Context);
479
480void
481CgGenerateAmlLengths (
482    ACPI_PARSE_OBJECT       *Op);
483
484
485/*
486 * aslmap - opcode mappings and reserved method names
487 */
488ACPI_OBJECT_TYPE
489AslMapNamedOpcodeToDataType (
490    UINT16                  Opcode);
491
492
493/*
494 * aslpredef - ACPI predefined names support
495 */
496BOOLEAN
497ApCheckForPredefinedMethod (
498    ACPI_PARSE_OBJECT       *Op,
499    ASL_METHOD_INFO         *MethodInfo);
500
501void
502ApCheckPredefinedReturnValue (
503    ACPI_PARSE_OBJECT       *Op,
504    ASL_METHOD_INFO         *MethodInfo);
505
506UINT32
507ApCheckForPredefinedName (
508    ACPI_PARSE_OBJECT       *Op,
509    char                    *Name);
510
511void
512ApCheckForPredefinedObject (
513    ACPI_PARSE_OBJECT       *Op,
514    char                    *Name);
515
516ACPI_STATUS
517ApCheckObjectType (
518    const char              *PredefinedName,
519    ACPI_PARSE_OBJECT       *Op,
520    UINT32                  ExpectedBtypes,
521    UINT32                  PackageIndex);
522
523void
524ApDisplayReservedNames (
525    void);
526
527
528/*
529 * aslprepkg - ACPI predefined names support for packages
530 */
531void
532ApCheckPackage (
533    ACPI_PARSE_OBJECT           *ParentOp,
534    const ACPI_PREDEFINED_INFO  *Predefined);
535
536
537/*
538 * asltransform - parse tree transformations
539 */
540ACPI_STATUS
541TrAmlTransformWalk (
542    ACPI_PARSE_OBJECT       *Op,
543    UINT32                  Level,
544    void                    *Context);
545
546
547/*
548 * asltree - parse tree support
549 */
550ACPI_STATUS
551TrWalkParseTree (
552    ACPI_PARSE_OBJECT       *Op,
553    UINT32                  Visitation,
554    ASL_WALK_CALLBACK       DescendingCallback,
555    ASL_WALK_CALLBACK       AscendingCallback,
556    void                    *Context);
557
558/* Values for "Visitation" parameter above */
559
560#define ASL_WALK_VISIT_DOWNWARD     0x01
561#define ASL_WALK_VISIT_UPWARD       0x02
562#define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
563
564
565ACPI_PARSE_OBJECT *
566TrAllocateNode (
567    UINT32                  ParseOpcode);
568
569void
570TrReleaseNode (
571    ACPI_PARSE_OBJECT       *Op);
572
573ACPI_PARSE_OBJECT *
574TrUpdateNode (
575    UINT32                  ParseOpcode,
576    ACPI_PARSE_OBJECT       *Op);
577
578ACPI_PARSE_OBJECT *
579TrCreateNode (
580    UINT32                  ParseOpcode,
581    UINT32                  NumChildren,
582    ...);
583
584ACPI_PARSE_OBJECT *
585TrCreateLeafNode (
586    UINT32                  ParseOpcode);
587
588ACPI_PARSE_OBJECT *
589TrCreateValuedLeafNode (
590    UINT32                  ParseOpcode,
591    UINT64                  Value);
592
593ACPI_PARSE_OBJECT *
594TrCreateConstantLeafNode (
595    UINT32                  ParseOpcode);
596
597ACPI_PARSE_OBJECT *
598TrLinkChildren (
599    ACPI_PARSE_OBJECT       *Op,
600    UINT32                  NumChildren,
601    ...);
602
603void
604TrSetEndLineNumber (
605    ACPI_PARSE_OBJECT       *Op);
606
607void
608TrWalkTree (
609    void);
610
611ACPI_PARSE_OBJECT *
612TrLinkPeerNode (
613    ACPI_PARSE_OBJECT       *Op1,
614    ACPI_PARSE_OBJECT       *Op2);
615
616ACPI_PARSE_OBJECT *
617TrLinkChildNode (
618    ACPI_PARSE_OBJECT       *Op1,
619    ACPI_PARSE_OBJECT       *Op2);
620
621ACPI_PARSE_OBJECT *
622TrSetNodeFlags (
623    ACPI_PARSE_OBJECT       *Op,
624    UINT32                  Flags);
625
626ACPI_PARSE_OBJECT *
627TrSetNodeAmlLength (
628    ACPI_PARSE_OBJECT       *Op,
629    UINT32                  Length);
630
631ACPI_PARSE_OBJECT *
632TrLinkPeerNodes (
633    UINT32                  NumPeers,
634    ...);
635
636
637/*
638 * aslfiles - File I/O support
639 */
640void
641AslAbort (
642    void);
643
644void
645FlAddIncludeDirectory (
646    char                    *Dir);
647
648char *
649FlMergePathnames (
650    char                    *PrefixDir,
651    char                    *FilePathname);
652
653void
654FlOpenIncludeFile (
655    ACPI_PARSE_OBJECT       *Op);
656
657void
658FlFileError (
659    UINT32                  FileId,
660    UINT8                   ErrorId);
661
662UINT32
663FlGetFileSize (
664    UINT32                  FileId);
665
666ACPI_STATUS
667FlReadFile (
668    UINT32                  FileId,
669    void                    *Buffer,
670    UINT32                  Length);
671
672void
673FlWriteFile (
674    UINT32                  FileId,
675    void                    *Buffer,
676    UINT32                  Length);
677
678void
679FlSeekFile (
680    UINT32                  FileId,
681    long                    Offset);
682
683void
684FlCloseFile (
685    UINT32                  FileId);
686
687void
688FlPrintFile (
689    UINT32                  FileId,
690    char                    *Format,
691    ...);
692
693void
694FlDeleteFile (
695    UINT32                  FileId);
696
697void
698FlSetLineNumber (
699    UINT32                  LineNumber);
700
701void
702FlSetFilename (
703    char                    *Filename);
704
705ACPI_STATUS
706FlOpenInputFile (
707    char                    *InputFilename);
708
709ACPI_STATUS
710FlOpenAmlOutputFile (
711    char                    *InputFilename);
712
713ACPI_STATUS
714FlOpenMiscOutputFiles (
715    char                    *InputFilename);
716
717
718/*
719 * asload - load namespace in prep for cross reference
720 */
721ACPI_STATUS
722LdLoadNamespace (
723    ACPI_PARSE_OBJECT       *RootOp);
724
725
726/*
727 * asllookup - namespace lookup functions
728 */
729void
730LkFindUnreferencedObjects (
731    void);
732
733
734/*
735 * aslnamesp - namespace output file generation
736 */
737ACPI_STATUS
738NsDisplayNamespace (
739    void);
740
741void
742NsSetupNamespaceListing (
743    void                    *Handle);
744
745
746/*
747 * aslxref - namespace cross reference
748 */
749ACPI_STATUS
750XfCrossReferenceNamespace (
751    void);
752
753
754/*
755 * aslutils - common compiler utilites
756 */
757void
758DbgPrint (
759    UINT32                  Type,
760    char                    *Format,
761    ...);
762
763/* Type values for above */
764
765#define ASL_DEBUG_OUTPUT    0
766#define ASL_PARSE_OUTPUT    1
767#define ASL_TREE_OUTPUT     2
768
769void
770UtDisplaySupportedTables (
771    void);
772
773void
774UtDisplayConstantOpcodes (
775    void);
776
777UINT8
778UtBeginEvent (
779    char                    *Name);
780
781void
782UtEndEvent (
783    UINT8                   Event);
784
785void *
786UtLocalCalloc (
787    UINT32                  Size);
788
789void
790UtPrintFormattedName (
791    UINT16                  ParseOpcode,
792    UINT32                  Level);
793
794void
795UtDisplaySummary (
796    UINT32                  FileId);
797
798UINT8
799UtHexCharToValue (
800    int                     HexChar);
801
802void
803UtConvertByteToHex (
804    UINT8                   RawByte,
805    UINT8                   *Buffer);
806
807void
808UtConvertByteToAsmHex (
809    UINT8                   RawByte,
810    UINT8                   *Buffer);
811
812char *
813UtGetOpName (
814    UINT32                  ParseOpcode);
815
816void
817UtSetParseOpName (
818    ACPI_PARSE_OBJECT       *Op);
819
820char *
821UtGetStringBuffer (
822    UINT32                  Length);
823
824void
825UtExpandLineBuffers (
826    void);
827
828ACPI_STATUS
829UtInternalizeName (
830    char                    *ExternalName,
831    char                    **ConvertedName);
832
833void
834UtAttachNamepathToOwner (
835    ACPI_PARSE_OBJECT       *Op,
836    ACPI_PARSE_OBJECT       *NameNode);
837
838ACPI_PARSE_OBJECT *
839UtCheckIntegerRange (
840    ACPI_PARSE_OBJECT       *Op,
841    UINT32                  LowValue,
842    UINT32                  HighValue);
843
844UINT64
845UtDoConstant (
846    char                    *String);
847
848ACPI_STATUS
849UtStrtoul64 (
850    char                    *String,
851    UINT32                  Base,
852    UINT64                  *RetInteger);
853
854
855/*
856 * asluuid - UUID support
857 */
858ACPI_STATUS
859AuValidateUuid (
860    char                    *InString);
861
862ACPI_STATUS
863AuConvertStringToUuid (
864    char                    *InString,
865    char                    *UuIdBuffer);
866
867ACPI_STATUS
868AuConvertUuidToString (
869    char                    *UuIdBuffer,
870    char                    *OutString);
871
872/*
873 * aslresource - Resource template generation utilities
874 */
875void
876RsSmallAddressCheck (
877    UINT8                   Type,
878    UINT32                  Minimum,
879    UINT32                  Maximum,
880    UINT32                  Length,
881    UINT32                  Alignment,
882    ACPI_PARSE_OBJECT       *MinOp,
883    ACPI_PARSE_OBJECT       *MaxOp,
884    ACPI_PARSE_OBJECT       *LengthOp,
885    ACPI_PARSE_OBJECT       *AlignOp,
886    ACPI_PARSE_OBJECT       *Op);
887
888void
889RsLargeAddressCheck (
890    UINT64                  Minimum,
891    UINT64                  Maximum,
892    UINT64                  Length,
893    UINT64                  Granularity,
894    UINT8                   Flags,
895    ACPI_PARSE_OBJECT       *MinOp,
896    ACPI_PARSE_OBJECT       *MaxOp,
897    ACPI_PARSE_OBJECT       *LengthOp,
898    ACPI_PARSE_OBJECT       *GranOp,
899    ACPI_PARSE_OBJECT       *Op);
900
901UINT16
902RsGetStringDataLength (
903    ACPI_PARSE_OBJECT       *InitializerOp);
904
905ASL_RESOURCE_NODE *
906RsAllocateResourceNode (
907    UINT32                  Size);
908
909void
910RsCreateResourceField (
911    ACPI_PARSE_OBJECT       *Op,
912    char                    *Name,
913    UINT32                  ByteOffset,
914    UINT32                  BitOffset,
915    UINT32                  BitLength);
916
917void
918RsSetFlagBits (
919    UINT8                   *Flags,
920    ACPI_PARSE_OBJECT       *Op,
921    UINT8                   Position,
922    UINT8                   DefaultBit);
923
924void
925RsSetFlagBits16 (
926    UINT16                  *Flags,
927    ACPI_PARSE_OBJECT       *Op,
928    UINT8                   Position,
929    UINT8                   DefaultBit);
930
931ACPI_PARSE_OBJECT *
932RsCompleteNodeAndGetNext (
933    ACPI_PARSE_OBJECT       *Op);
934
935void
936RsCheckListForDuplicates (
937    ACPI_PARSE_OBJECT       *Op);
938
939ASL_RESOURCE_NODE *
940RsDoOneResourceDescriptor (
941    ACPI_PARSE_OBJECT       *DescriptorTypeOp,
942    UINT32                  CurrentByteOffset,
943    UINT8                   *State);
944
945/* Values for State above */
946
947#define ACPI_RSTATE_NORMAL              0
948#define ACPI_RSTATE_START_DEPENDENT     1
949#define ACPI_RSTATE_DEPENDENT_LIST      2
950
951UINT32
952RsLinkDescriptorChain (
953    ASL_RESOURCE_NODE       **PreviousRnode,
954    ASL_RESOURCE_NODE       *Rnode);
955
956void
957RsDoResourceTemplate (
958    ACPI_PARSE_OBJECT       *Op);
959
960
961/*
962 * aslrestype1 - Miscellaneous Small descriptors
963 */
964ASL_RESOURCE_NODE *
965RsDoEndTagDescriptor (
966    ACPI_PARSE_OBJECT       *Op,
967    UINT32                  CurrentByteOffset);
968
969ASL_RESOURCE_NODE *
970RsDoEndDependentDescriptor (
971    ACPI_PARSE_OBJECT       *Op,
972    UINT32                  CurrentByteOffset);
973
974ASL_RESOURCE_NODE *
975RsDoMemory24Descriptor (
976    ACPI_PARSE_OBJECT       *Op,
977    UINT32                  CurrentByteOffset);
978
979ASL_RESOURCE_NODE *
980RsDoMemory32Descriptor (
981    ACPI_PARSE_OBJECT       *Op,
982    UINT32                  CurrentByteOffset);
983
984ASL_RESOURCE_NODE *
985RsDoMemory32FixedDescriptor (
986    ACPI_PARSE_OBJECT       *Op,
987    UINT32                  CurrentByteOffset);
988
989ASL_RESOURCE_NODE *
990RsDoStartDependentDescriptor (
991    ACPI_PARSE_OBJECT       *Op,
992    UINT32                  CurrentByteOffset);
993
994ASL_RESOURCE_NODE *
995RsDoStartDependentNoPriDescriptor (
996    ACPI_PARSE_OBJECT       *Op,
997    UINT32                  CurrentByteOffset);
998
999ASL_RESOURCE_NODE *
1000RsDoVendorSmallDescriptor (
1001    ACPI_PARSE_OBJECT       *Op,
1002    UINT32                  CurrentByteOffset);
1003
1004
1005/*
1006 * aslrestype1i - I/O-related Small descriptors
1007 */
1008ASL_RESOURCE_NODE *
1009RsDoDmaDescriptor (
1010    ACPI_PARSE_OBJECT       *Op,
1011    UINT32                  CurrentByteOffset);
1012
1013ASL_RESOURCE_NODE *
1014RsDoFixedDmaDescriptor (
1015    ACPI_PARSE_OBJECT       *Op,
1016    UINT32                  CurrentByteOffset);
1017
1018ASL_RESOURCE_NODE *
1019RsDoFixedIoDescriptor (
1020    ACPI_PARSE_OBJECT       *Op,
1021    UINT32                  CurrentByteOffset);
1022
1023ASL_RESOURCE_NODE *
1024RsDoIoDescriptor (
1025    ACPI_PARSE_OBJECT       *Op,
1026    UINT32                  CurrentByteOffset);
1027
1028ASL_RESOURCE_NODE *
1029RsDoIrqDescriptor (
1030    ACPI_PARSE_OBJECT       *Op,
1031    UINT32                  CurrentByteOffset);
1032
1033ASL_RESOURCE_NODE *
1034RsDoIrqNoFlagsDescriptor (
1035    ACPI_PARSE_OBJECT       *Op,
1036    UINT32                  CurrentByteOffset);
1037
1038
1039/*
1040 * aslrestype2 - Large resource descriptors
1041 */
1042ASL_RESOURCE_NODE *
1043RsDoInterruptDescriptor (
1044    ACPI_PARSE_OBJECT       *Op,
1045    UINT32                  CurrentByteOffset);
1046
1047ASL_RESOURCE_NODE *
1048RsDoVendorLargeDescriptor (
1049    ACPI_PARSE_OBJECT       *Op,
1050    UINT32                  CurrentByteOffset);
1051
1052ASL_RESOURCE_NODE *
1053RsDoGeneralRegisterDescriptor (
1054    ACPI_PARSE_OBJECT       *Op,
1055    UINT32                  CurrentByteOffset);
1056
1057ASL_RESOURCE_NODE *
1058RsDoGpioIntDescriptor (
1059    ACPI_PARSE_OBJECT       *Op,
1060    UINT32                  CurrentByteOffset);
1061
1062ASL_RESOURCE_NODE *
1063RsDoGpioIoDescriptor (
1064    ACPI_PARSE_OBJECT       *Op,
1065    UINT32                  CurrentByteOffset);
1066
1067ASL_RESOURCE_NODE *
1068RsDoI2cSerialBusDescriptor (
1069    ACPI_PARSE_OBJECT       *Op,
1070    UINT32                  CurrentByteOffset);
1071
1072ASL_RESOURCE_NODE *
1073RsDoSpiSerialBusDescriptor (
1074    ACPI_PARSE_OBJECT       *Op,
1075    UINT32                  CurrentByteOffset);
1076
1077ASL_RESOURCE_NODE *
1078RsDoUartSerialBusDescriptor (
1079    ACPI_PARSE_OBJECT       *Op,
1080    UINT32                  CurrentByteOffset);
1081
1082/*
1083 * aslrestype2d - DWord address descriptors
1084 */
1085ASL_RESOURCE_NODE *
1086RsDoDwordIoDescriptor (
1087    ACPI_PARSE_OBJECT       *Op,
1088    UINT32                  CurrentByteOffset);
1089
1090ASL_RESOURCE_NODE *
1091RsDoDwordMemoryDescriptor (
1092    ACPI_PARSE_OBJECT       *Op,
1093    UINT32                  CurrentByteOffset);
1094
1095ASL_RESOURCE_NODE *
1096RsDoDwordSpaceDescriptor (
1097    ACPI_PARSE_OBJECT       *Op,
1098    UINT32                  CurrentByteOffset);
1099
1100
1101/*
1102 * aslrestype2e - Extended address descriptors
1103 */
1104ASL_RESOURCE_NODE *
1105RsDoExtendedIoDescriptor (
1106    ACPI_PARSE_OBJECT       *Op,
1107    UINT32                  CurrentByteOffset);
1108
1109ASL_RESOURCE_NODE *
1110RsDoExtendedMemoryDescriptor (
1111    ACPI_PARSE_OBJECT       *Op,
1112    UINT32                  CurrentByteOffset);
1113
1114ASL_RESOURCE_NODE *
1115RsDoExtendedSpaceDescriptor (
1116    ACPI_PARSE_OBJECT       *Op,
1117    UINT32                  CurrentByteOffset);
1118
1119
1120/*
1121 * aslrestype2q - QWord address descriptors
1122 */
1123ASL_RESOURCE_NODE *
1124RsDoQwordIoDescriptor (
1125    ACPI_PARSE_OBJECT       *Op,
1126    UINT32                  CurrentByteOffset);
1127
1128ASL_RESOURCE_NODE *
1129RsDoQwordMemoryDescriptor (
1130    ACPI_PARSE_OBJECT       *Op,
1131    UINT32                  CurrentByteOffset);
1132
1133ASL_RESOURCE_NODE *
1134RsDoQwordSpaceDescriptor (
1135    ACPI_PARSE_OBJECT       *Op,
1136    UINT32                  CurrentByteOffset);
1137
1138
1139/*
1140 * aslrestype2w - Word address descriptors
1141 */
1142ASL_RESOURCE_NODE *
1143RsDoWordIoDescriptor (
1144    ACPI_PARSE_OBJECT       *Op,
1145    UINT32                  CurrentByteOffset);
1146
1147ASL_RESOURCE_NODE *
1148RsDoWordSpaceDescriptor (
1149    ACPI_PARSE_OBJECT       *Op,
1150    UINT32                  CurrentByteOffset);
1151
1152ASL_RESOURCE_NODE *
1153RsDoWordBusNumberDescriptor (
1154    ACPI_PARSE_OBJECT       *Op,
1155    UINT32                  CurrentByteOffset);
1156
1157/*
1158 * Entry to data table compiler subsystem
1159 */
1160ACPI_STATUS
1161DtDoCompile(
1162    void);
1163
1164ACPI_STATUS
1165DtCreateTemplates (
1166    char                    *Signature);
1167
1168#endif /*  __ASLCOMPILER_H */
1169