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