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