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