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