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