1
2/******************************************************************************
3 *
4 * Module Name: aslcompiler.h - common include file for iASL
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45
46#ifndef __ASLCOMPILER_H
47#define __ASLCOMPILER_H
48
49#include <contrib/dev/acpica/include/acpi.h>
50#include <contrib/dev/acpica/include/accommon.h>
51#include <contrib/dev/acpica/include/amlresrc.h>
52#include <contrib/dev/acpica/include/acdebug.h>
53
54/* Microsoft-specific */
55
56#if (defined WIN32 || defined WIN64)
57
58/* warn : used #pragma pack */
59#pragma warning(disable:4103)
60
61/* warn : named type definition in parentheses */
62#pragma warning(disable:4115)
63#endif
64
65#include <stdio.h>
66#include <stdlib.h>
67#include <stdarg.h>
68#include <string.h>
69#include <errno.h>
70#include <ctype.h>
71
72/* Compiler headers */
73
74#include <contrib/dev/acpica/compiler/asldefine.h>
75#include <contrib/dev/acpica/compiler/asltypes.h>
76#include <contrib/dev/acpica/compiler/aslmessages.h>
77#include <contrib/dev/acpica/compiler/aslglobal.h>
78
79
80/*******************************************************************************
81 *
82 * Compiler prototypes
83 *
84 ******************************************************************************/
85
86/*
87 * 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
102ResetCurrentLineBuffer (
103 void);
104
105void
106InsertLineBuffer (
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
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
161ACPI_STATUS
162FlCheckForAscii (
163 ASL_FILE_INFO *FileInfo);
164
165
166/*
| 1
2/******************************************************************************
3 *
4 * Module Name: aslcompiler.h - common include file for iASL
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45
46#ifndef __ASLCOMPILER_H
47#define __ASLCOMPILER_H
48
49#include <contrib/dev/acpica/include/acpi.h>
50#include <contrib/dev/acpica/include/accommon.h>
51#include <contrib/dev/acpica/include/amlresrc.h>
52#include <contrib/dev/acpica/include/acdebug.h>
53
54/* Microsoft-specific */
55
56#if (defined WIN32 || defined WIN64)
57
58/* warn : used #pragma pack */
59#pragma warning(disable:4103)
60
61/* warn : named type definition in parentheses */
62#pragma warning(disable:4115)
63#endif
64
65#include <stdio.h>
66#include <stdlib.h>
67#include <stdarg.h>
68#include <string.h>
69#include <errno.h>
70#include <ctype.h>
71
72/* Compiler headers */
73
74#include <contrib/dev/acpica/compiler/asldefine.h>
75#include <contrib/dev/acpica/compiler/asltypes.h>
76#include <contrib/dev/acpica/compiler/aslmessages.h>
77#include <contrib/dev/acpica/compiler/aslglobal.h>
78
79
80/*******************************************************************************
81 *
82 * Compiler prototypes
83 *
84 ******************************************************************************/
85
86/*
87 * 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
102ResetCurrentLineBuffer (
103 void);
104
105void
106InsertLineBuffer (
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
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
161ACPI_STATUS
162FlCheckForAscii (
163 ASL_FILE_INFO *FileInfo);
164
165
166/*
|
167 * aslanalyze - semantic analysis
| 167 * aslwalks - semantic analysis and parse tree walks
|
168 */
169ACPI_STATUS
170AnOtherSemanticAnalysisWalkBegin (
171 ACPI_PARSE_OBJECT *Op,
172 UINT32 Level,
173 void *Context);
174
175ACPI_STATUS
176AnOtherSemanticAnalysisWalkEnd (
177 ACPI_PARSE_OBJECT *Op,
178 UINT32 Level,
179 void *Context);
180
181ACPI_STATUS
| 168 */
169ACPI_STATUS
170AnOtherSemanticAnalysisWalkBegin (
171 ACPI_PARSE_OBJECT *Op,
172 UINT32 Level,
173 void *Context);
174
175ACPI_STATUS
176AnOtherSemanticAnalysisWalkEnd (
177 ACPI_PARSE_OBJECT *Op,
178 UINT32 Level,
179 void *Context);
180
181ACPI_STATUS
|
182AnOperandTypecheckWalkBegin (
183 ACPI_PARSE_OBJECT *Op,
184 UINT32 Level,
185 void *Context);
186
187ACPI_STATUS
| |
188AnOperandTypecheckWalkEnd (
189 ACPI_PARSE_OBJECT *Op,
190 UINT32 Level,
191 void *Context);
192
193ACPI_STATUS
194AnMethodAnalysisWalkBegin (
195 ACPI_PARSE_OBJECT *Op,
196 UINT32 Level,
197 void *Context);
198
199ACPI_STATUS
200AnMethodAnalysisWalkEnd (
201 ACPI_PARSE_OBJECT *Op,
202 UINT32 Level,
203 void *Context);
204
205ACPI_STATUS
| 182AnOperandTypecheckWalkEnd (
183 ACPI_PARSE_OBJECT *Op,
184 UINT32 Level,
185 void *Context);
186
187ACPI_STATUS
188AnMethodAnalysisWalkBegin (
189 ACPI_PARSE_OBJECT *Op,
190 UINT32 Level,
191 void *Context);
192
193ACPI_STATUS
194AnMethodAnalysisWalkEnd (
195 ACPI_PARSE_OBJECT *Op,
196 UINT32 Level,
197 void *Context);
198
199ACPI_STATUS
|
206AnMethodTypingWalkBegin (
| 200AnMethodTypingWalkEnd (
|
207 ACPI_PARSE_OBJECT *Op,
208 UINT32 Level,
209 void *Context);
210
| 201 ACPI_PARSE_OBJECT *Op,
202 UINT32 Level,
203 void *Context);
204
|
211ACPI_STATUS
212AnMethodTypingWalkEnd (
| 205
206/*
207 * aslbtypes - bitfield data types
208 */
209UINT32
210AnMapObjTypeToBtype (
211 ACPI_PARSE_OBJECT *Op);
212
213UINT32
214AnMapArgTypeToBtype (
215 UINT32 ArgType);
216
217UINT32
218AnGetBtype (
219 ACPI_PARSE_OBJECT *Op);
220
221void
222AnFormatBtype (
223 char *Buffer,
224 UINT32 Btype);
225
226
227/*
228 * aslanalyze - Support functions for parse tree walks
229 */
230void
231AnCheckId (
|
213 ACPI_PARSE_OBJECT *Op,
| 232 ACPI_PARSE_OBJECT *Op,
|
214 UINT32 Level,
215 void *Context);
| 233 ACPI_NAME Type);
|
216
| 234
|
| 235/* Values for Type argument above */
|
217
| 236
|
| 237#define ASL_TYPE_HID 0
238#define ASL_TYPE_CID 1
239
240BOOLEAN
241AnIsInternalMethod (
242 ACPI_PARSE_OBJECT *Op);
243
244UINT32
245AnGetInternalMethodReturnType (
246 ACPI_PARSE_OBJECT *Op);
247
248BOOLEAN
249AnLastStatementIsReturn (
250 ACPI_PARSE_OBJECT *Op);
251
252void
253AnCheckMethodReturnValue (
254 ACPI_PARSE_OBJECT *Op,
255 const ACPI_OPCODE_INFO *OpInfo,
256 ACPI_PARSE_OBJECT *ArgOp,
257 UINT32 RequiredBtypes,
258 UINT32 ThisNodeBtype);
259
260BOOLEAN
261AnIsResultUsed (
262 ACPI_PARSE_OBJECT *Op);
263
264void
265ApCheckForGpeNameConflict (
266 ACPI_PARSE_OBJECT *Op);
267
268
|
218/*
219 * aslerror - error handling/reporting
220 */
221void
222AslError (
223 UINT8 Level,
224 UINT8 MessageId,
225 ACPI_PARSE_OBJECT *Op,
226 char *ExtraMessage);
227
228void
229AslCoreSubsystemError (
230 ACPI_PARSE_OBJECT *Op,
231 ACPI_STATUS Status,
232 char *ExtraMessage,
233 BOOLEAN Abort);
234
235int
236AslCompilererror(
237 char *s);
238
239void
240AslCommonError (
241 UINT8 Level,
242 UINT8 MessageId,
243 UINT32 CurrentLineNumber,
244 UINT32 LogicalLineNumber,
245 UINT32 LogicalByteOffset,
246 UINT32 Column,
247 char *Filename,
248 char *ExtraMessage);
249
250void
251AePrintException (
252 UINT32 FileId,
253 ASL_ERROR_MSG *Enode,
254 char *Header);
255
256void
257AePrintErrorLog (
258 UINT32 FileId);
259
260void
261AeClearErrorLog (
262 void);
263
264ACPI_PHYSICAL_ADDRESS
265AeLocalGetRootPointer (
266 void);
267
268
269/*
270 * asllisting - generate all "listing" type files
271 */
272void
273LsDoListings (
274 void);
275
276void
277LsWriteNodeToAsmListing (
278 ACPI_PARSE_OBJECT *Op);
279
280void
281LsWriteNode (
282 ACPI_PARSE_OBJECT *Op,
283 UINT32 FileId);
284
285void
286LsDoHexOutput (
287 void);
288
289void
290LsDumpParseTree (
291 void);
292
293/*
294 * aslfold - constant folding
295 */
296ACPI_STATUS
297OpcAmlConstantWalk (
298 ACPI_PARSE_OBJECT *Op,
299 UINT32 Level,
300 void *Context);
301
302
303/*
304 * aslopcodes - generate AML opcodes
305 */
306ACPI_STATUS
307OpcAmlOpcodeWalk (
308 ACPI_PARSE_OBJECT *Op,
309 UINT32 Level,
310 void *Context);
311
312ACPI_STATUS
313OpcAmlOpcodeUpdateWalk (
314 ACPI_PARSE_OBJECT *Op,
315 UINT32 Level,
316 void *Context);
317
318void
319OpcGenerateAmlOpcode (
320 ACPI_PARSE_OBJECT *Op);
321
322UINT32
323OpcSetOptimalIntegerSize (
324 ACPI_PARSE_OBJECT *Op);
325
326void
327OpcGetIntegerWidth (
328 ACPI_PARSE_OBJECT *Op);
329
330
331/*
332 * asloperands - generate AML operands for the AML opcodes
333 */
334ACPI_PARSE_OBJECT *
335UtGetArg (
336 ACPI_PARSE_OBJECT *Op,
337 UINT32 Argn);
338
339void
340OpnGenerateAmlOperands (
341 ACPI_PARSE_OBJECT *Op);
342
343void
344OpnDoPackage (
345 ACPI_PARSE_OBJECT *Op);
346
347
348/*
349 * aslopt - optmization
350 */
351void
352OptOptimizeNamePath (
353 ACPI_PARSE_OBJECT *Op,
354 UINT32 Flags,
355 ACPI_WALK_STATE *WalkState,
356 char *AmlNameString,
357 ACPI_NAMESPACE_NODE *TargetNode);
358
359
360/*
361 * aslcodegen - code generation
362 */
363void
364CgGenerateAmlOutput (
365 void);
366
367
368/*
369 * aslfile
370 */
371void
372FlOpenFile (
373 UINT32 FileId,
374 char *Filename,
375 char *Mode);
376
377
378/*
379 * asllength - calculate/adjust AML package lengths
380 */
381ACPI_STATUS
382LnPackageLengthWalk (
383 ACPI_PARSE_OBJECT *Op,
384 UINT32 Level,
385 void *Context);
386
387ACPI_STATUS
388LnInitLengthsWalk (
389 ACPI_PARSE_OBJECT *Op,
390 UINT32 Level,
391 void *Context);
392
393void
394CgGenerateAmlLengths (
395 ACPI_PARSE_OBJECT *Op);
396
397
398/*
399 * aslmap - opcode mappings and reserved method names
400 */
401ACPI_OBJECT_TYPE
402AslMapNamedOpcodeToDataType (
403 UINT16 Opcode);
404
405
406/*
407 * aslpredef - ACPI predefined names support
408 */
409void
410ApCheckForPredefinedMethod (
411 ACPI_PARSE_OBJECT *Op,
412 ASL_METHOD_INFO *MethodInfo);
413
414void
415ApCheckPredefinedReturnValue (
416 ACPI_PARSE_OBJECT *Op,
417 ASL_METHOD_INFO *MethodInfo);
418
419UINT32
420ApCheckForPredefinedName (
421 ACPI_PARSE_OBJECT *Op,
422 char *Name);
423
424void
425ApCheckForPredefinedObject (
426 ACPI_PARSE_OBJECT *Op,
427 char *Name);
428
429void
430ApDisplayReservedNames (
431 void);
432
433
434/*
435 * asltransform - parse tree transformations
436 */
437ACPI_STATUS
438TrAmlTransformWalk (
439 ACPI_PARSE_OBJECT *Op,
440 UINT32 Level,
441 void *Context);
442
443
444/*
445 * asltree - parse tree support
446 */
447ACPI_STATUS
448TrWalkParseTree (
449 ACPI_PARSE_OBJECT *Op,
450 UINT32 Visitation,
451 ASL_WALK_CALLBACK DescendingCallback,
452 ASL_WALK_CALLBACK AscendingCallback,
453 void *Context);
454
455/* Values for "Visitation" parameter above */
456
457#define ASL_WALK_VISIT_DOWNWARD 0x01
458#define ASL_WALK_VISIT_UPWARD 0x02
459#define ASL_WALK_VISIT_TWICE (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
460
461
462ACPI_PARSE_OBJECT *
463TrAllocateNode (
464 UINT32 ParseOpcode);
465
466void
467TrReleaseNode (
468 ACPI_PARSE_OBJECT *Op);
469
470ACPI_PARSE_OBJECT *
471TrUpdateNode (
472 UINT32 ParseOpcode,
473 ACPI_PARSE_OBJECT *Op);
474
475ACPI_PARSE_OBJECT *
476TrCreateNode (
477 UINT32 ParseOpcode,
478 UINT32 NumChildren,
479 ...);
480
481ACPI_PARSE_OBJECT *
482TrCreateLeafNode (
483 UINT32 ParseOpcode);
484
485ACPI_PARSE_OBJECT *
486TrCreateValuedLeafNode (
487 UINT32 ParseOpcode,
488 UINT64 Value);
489
490ACPI_PARSE_OBJECT *
| 269/*
270 * aslerror - error handling/reporting
271 */
272void
273AslError (
274 UINT8 Level,
275 UINT8 MessageId,
276 ACPI_PARSE_OBJECT *Op,
277 char *ExtraMessage);
278
279void
280AslCoreSubsystemError (
281 ACPI_PARSE_OBJECT *Op,
282 ACPI_STATUS Status,
283 char *ExtraMessage,
284 BOOLEAN Abort);
285
286int
287AslCompilererror(
288 char *s);
289
290void
291AslCommonError (
292 UINT8 Level,
293 UINT8 MessageId,
294 UINT32 CurrentLineNumber,
295 UINT32 LogicalLineNumber,
296 UINT32 LogicalByteOffset,
297 UINT32 Column,
298 char *Filename,
299 char *ExtraMessage);
300
301void
302AePrintException (
303 UINT32 FileId,
304 ASL_ERROR_MSG *Enode,
305 char *Header);
306
307void
308AePrintErrorLog (
309 UINT32 FileId);
310
311void
312AeClearErrorLog (
313 void);
314
315ACPI_PHYSICAL_ADDRESS
316AeLocalGetRootPointer (
317 void);
318
319
320/*
321 * asllisting - generate all "listing" type files
322 */
323void
324LsDoListings (
325 void);
326
327void
328LsWriteNodeToAsmListing (
329 ACPI_PARSE_OBJECT *Op);
330
331void
332LsWriteNode (
333 ACPI_PARSE_OBJECT *Op,
334 UINT32 FileId);
335
336void
337LsDoHexOutput (
338 void);
339
340void
341LsDumpParseTree (
342 void);
343
344/*
345 * aslfold - constant folding
346 */
347ACPI_STATUS
348OpcAmlConstantWalk (
349 ACPI_PARSE_OBJECT *Op,
350 UINT32 Level,
351 void *Context);
352
353
354/*
355 * aslopcodes - generate AML opcodes
356 */
357ACPI_STATUS
358OpcAmlOpcodeWalk (
359 ACPI_PARSE_OBJECT *Op,
360 UINT32 Level,
361 void *Context);
362
363ACPI_STATUS
364OpcAmlOpcodeUpdateWalk (
365 ACPI_PARSE_OBJECT *Op,
366 UINT32 Level,
367 void *Context);
368
369void
370OpcGenerateAmlOpcode (
371 ACPI_PARSE_OBJECT *Op);
372
373UINT32
374OpcSetOptimalIntegerSize (
375 ACPI_PARSE_OBJECT *Op);
376
377void
378OpcGetIntegerWidth (
379 ACPI_PARSE_OBJECT *Op);
380
381
382/*
383 * asloperands - generate AML operands for the AML opcodes
384 */
385ACPI_PARSE_OBJECT *
386UtGetArg (
387 ACPI_PARSE_OBJECT *Op,
388 UINT32 Argn);
389
390void
391OpnGenerateAmlOperands (
392 ACPI_PARSE_OBJECT *Op);
393
394void
395OpnDoPackage (
396 ACPI_PARSE_OBJECT *Op);
397
398
399/*
400 * aslopt - optmization
401 */
402void
403OptOptimizeNamePath (
404 ACPI_PARSE_OBJECT *Op,
405 UINT32 Flags,
406 ACPI_WALK_STATE *WalkState,
407 char *AmlNameString,
408 ACPI_NAMESPACE_NODE *TargetNode);
409
410
411/*
412 * aslcodegen - code generation
413 */
414void
415CgGenerateAmlOutput (
416 void);
417
418
419/*
420 * aslfile
421 */
422void
423FlOpenFile (
424 UINT32 FileId,
425 char *Filename,
426 char *Mode);
427
428
429/*
430 * asllength - calculate/adjust AML package lengths
431 */
432ACPI_STATUS
433LnPackageLengthWalk (
434 ACPI_PARSE_OBJECT *Op,
435 UINT32 Level,
436 void *Context);
437
438ACPI_STATUS
439LnInitLengthsWalk (
440 ACPI_PARSE_OBJECT *Op,
441 UINT32 Level,
442 void *Context);
443
444void
445CgGenerateAmlLengths (
446 ACPI_PARSE_OBJECT *Op);
447
448
449/*
450 * aslmap - opcode mappings and reserved method names
451 */
452ACPI_OBJECT_TYPE
453AslMapNamedOpcodeToDataType (
454 UINT16 Opcode);
455
456
457/*
458 * aslpredef - ACPI predefined names support
459 */
460void
461ApCheckForPredefinedMethod (
462 ACPI_PARSE_OBJECT *Op,
463 ASL_METHOD_INFO *MethodInfo);
464
465void
466ApCheckPredefinedReturnValue (
467 ACPI_PARSE_OBJECT *Op,
468 ASL_METHOD_INFO *MethodInfo);
469
470UINT32
471ApCheckForPredefinedName (
472 ACPI_PARSE_OBJECT *Op,
473 char *Name);
474
475void
476ApCheckForPredefinedObject (
477 ACPI_PARSE_OBJECT *Op,
478 char *Name);
479
480void
481ApDisplayReservedNames (
482 void);
483
484
485/*
486 * asltransform - parse tree transformations
487 */
488ACPI_STATUS
489TrAmlTransformWalk (
490 ACPI_PARSE_OBJECT *Op,
491 UINT32 Level,
492 void *Context);
493
494
495/*
496 * asltree - parse tree support
497 */
498ACPI_STATUS
499TrWalkParseTree (
500 ACPI_PARSE_OBJECT *Op,
501 UINT32 Visitation,
502 ASL_WALK_CALLBACK DescendingCallback,
503 ASL_WALK_CALLBACK AscendingCallback,
504 void *Context);
505
506/* Values for "Visitation" parameter above */
507
508#define ASL_WALK_VISIT_DOWNWARD 0x01
509#define ASL_WALK_VISIT_UPWARD 0x02
510#define ASL_WALK_VISIT_TWICE (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
511
512
513ACPI_PARSE_OBJECT *
514TrAllocateNode (
515 UINT32 ParseOpcode);
516
517void
518TrReleaseNode (
519 ACPI_PARSE_OBJECT *Op);
520
521ACPI_PARSE_OBJECT *
522TrUpdateNode (
523 UINT32 ParseOpcode,
524 ACPI_PARSE_OBJECT *Op);
525
526ACPI_PARSE_OBJECT *
527TrCreateNode (
528 UINT32 ParseOpcode,
529 UINT32 NumChildren,
530 ...);
531
532ACPI_PARSE_OBJECT *
533TrCreateLeafNode (
534 UINT32 ParseOpcode);
535
536ACPI_PARSE_OBJECT *
537TrCreateValuedLeafNode (
538 UINT32 ParseOpcode,
539 UINT64 Value);
540
541ACPI_PARSE_OBJECT *
|
| 542TrCreateConstantLeafNode (
543 UINT32 ParseOpcode);
544
545ACPI_PARSE_OBJECT *
|
491TrLinkChildren (
492 ACPI_PARSE_OBJECT *Op,
493 UINT32 NumChildren,
494 ...);
495
496void
497TrSetEndLineNumber (
498 ACPI_PARSE_OBJECT *Op);
499
500void
501TrWalkTree (
502 void);
503
504ACPI_PARSE_OBJECT *
505TrLinkPeerNode (
506 ACPI_PARSE_OBJECT *Op1,
507 ACPI_PARSE_OBJECT *Op2);
508
509ACPI_PARSE_OBJECT *
510TrLinkChildNode (
511 ACPI_PARSE_OBJECT *Op1,
512 ACPI_PARSE_OBJECT *Op2);
513
514ACPI_PARSE_OBJECT *
515TrSetNodeFlags (
516 ACPI_PARSE_OBJECT *Op,
517 UINT32 Flags);
518
519ACPI_PARSE_OBJECT *
520TrLinkPeerNodes (
521 UINT32 NumPeers,
522 ...);
523
524
525/*
526 * aslfiles - File I/O support
527 */
528void
529AslAbort (
530 void);
531
532void
533FlAddIncludeDirectory (
534 char *Dir);
535
536void
537FlOpenIncludeFile (
538 ACPI_PARSE_OBJECT *Op);
539
540void
541FlFileError (
542 UINT32 FileId,
543 UINT8 ErrorId);
544
545UINT32
546FlGetFileSize (
547 UINT32 FileId);
548
549ACPI_STATUS
550FlReadFile (
551 UINT32 FileId,
552 void *Buffer,
553 UINT32 Length);
554
555void
556FlWriteFile (
557 UINT32 FileId,
558 void *Buffer,
559 UINT32 Length);
560
561void
562FlSeekFile (
563 UINT32 FileId,
564 long Offset);
565
566void
567FlCloseFile (
568 UINT32 FileId);
569
570void
571FlPrintFile (
572 UINT32 FileId,
573 char *Format,
574 ...);
575
576void
577FlSetLineNumber (
578 ACPI_PARSE_OBJECT *Op);
579
580ACPI_STATUS
581FlOpenInputFile (
582 char *InputFilename);
583
584ACPI_STATUS
585FlOpenAmlOutputFile (
586 char *InputFilename);
587
588ACPI_STATUS
589FlOpenMiscOutputFiles (
590 char *InputFilename);
591
592
593/*
594 * asload - load namespace in prep for cross reference
595 */
596ACPI_STATUS
597LdLoadNamespace (
598 ACPI_PARSE_OBJECT *RootOp);
599
600
601/*
602 * asllookup - namespace cross reference
603 */
604ACPI_STATUS
605LkCrossReferenceNamespace (
606 void);
607
608void
609LkFindUnreferencedObjects (
610 void);
611
612ACPI_STATUS
613LsDisplayNamespace (
614 void);
615
616void
617LsSetupNsList (
618 void *Handle);
619
620
621/*
622 * aslutils - common compiler utilites
623 */
624void
625DbgPrint (
626 UINT32 Type,
627 char *Format,
628 ...);
629
630/* Type values for above */
631
632#define ASL_DEBUG_OUTPUT 0
633#define ASL_PARSE_OUTPUT 1
634#define ASL_TREE_OUTPUT 2
635
636void
637UtDisplaySupportedTables (
638 void);
639
640void
641UtDisplayConstantOpcodes (
642 void);
643
644UINT8
645UtBeginEvent (
646 char *Name);
647
648void
649UtEndEvent (
650 UINT8 Event);
651
652void *
653UtLocalCalloc (
654 UINT32 Size);
655
656void
657UtPrintFormattedName (
658 UINT16 ParseOpcode,
659 UINT32 Level);
660
661void
662UtDisplaySummary (
663 UINT32 FileId);
664
665UINT8
666UtHexCharToValue (
667 int HexChar);
668
669void
670UtConvertByteToHex (
671 UINT8 RawByte,
672 UINT8 *Buffer);
673
674void
675UtConvertByteToAsmHex (
676 UINT8 RawByte,
677 UINT8 *Buffer);
678
679char *
680UtGetOpName (
681 UINT32 ParseOpcode);
682
683void
684UtSetParseOpName (
685 ACPI_PARSE_OBJECT *Op);
686
687char *
688UtGetStringBuffer (
689 UINT32 Length);
690
691ACPI_STATUS
692UtInternalizeName (
693 char *ExternalName,
694 char **ConvertedName);
695
696void
697UtAttachNamepathToOwner (
698 ACPI_PARSE_OBJECT *Op,
699 ACPI_PARSE_OBJECT *NameNode);
700
701ACPI_PARSE_OBJECT *
702UtCheckIntegerRange (
703 ACPI_PARSE_OBJECT *Op,
704 UINT32 LowValue,
705 UINT32 HighValue);
706
707UINT64
708UtDoConstant (
709 char *String);
710
711/*
712 * asluuid - UUID support
713 */
714ACPI_STATUS
715AuValidateUuid (
716 char *InString);
717
718ACPI_STATUS
719AuConvertStringToUuid (
720 char *InString,
721 char *UuIdBuffer);
722
723ACPI_STATUS
724AuConvertUuidToString (
725 char *UuIdBuffer,
726 char *OutString);
727
728/*
729 * aslresource - Resource template generation utilities
730 */
731void
732RsSmallAddressCheck (
733 UINT8 Type,
734 UINT32 Minimum,
735 UINT32 Maximum,
736 UINT32 Length,
737 UINT32 Alignment,
738 ACPI_PARSE_OBJECT *MinOp,
739 ACPI_PARSE_OBJECT *MaxOp,
740 ACPI_PARSE_OBJECT *LengthOp,
741 ACPI_PARSE_OBJECT *AlignOp,
742 ACPI_PARSE_OBJECT *Op);
743
744void
745RsLargeAddressCheck (
746 UINT64 Minimum,
747 UINT64 Maximum,
748 UINT64 Length,
749 UINT64 Granularity,
750 UINT8 Flags,
751 ACPI_PARSE_OBJECT *MinOp,
752 ACPI_PARSE_OBJECT *MaxOp,
753 ACPI_PARSE_OBJECT *LengthOp,
754 ACPI_PARSE_OBJECT *GranOp,
755 ACPI_PARSE_OBJECT *Op);
756
757UINT16
758RsGetStringDataLength (
759 ACPI_PARSE_OBJECT *InitializerOp);
760
761ASL_RESOURCE_NODE *
762RsAllocateResourceNode (
763 UINT32 Size);
764
765void
766RsCreateBitField (
767 ACPI_PARSE_OBJECT *Op,
768 char *Name,
769 UINT32 ByteOffset,
770 UINT32 BitOffset);
771
772void
773RsCreateByteField (
774 ACPI_PARSE_OBJECT *Op,
775 char *Name,
776 UINT32 ByteOffset);
777
778void
779RsSetFlagBits (
780 UINT8 *Flags,
781 ACPI_PARSE_OBJECT *Op,
782 UINT8 Position,
783 UINT8 DefaultBit);
784
785ACPI_PARSE_OBJECT *
786RsCompleteNodeAndGetNext (
787 ACPI_PARSE_OBJECT *Op);
788
789void
790RsCheckListForDuplicates (
791 ACPI_PARSE_OBJECT *Op);
792
793ASL_RESOURCE_NODE *
794RsDoOneResourceDescriptor (
795 ACPI_PARSE_OBJECT *DescriptorTypeOp,
796 UINT32 CurrentByteOffset,
797 UINT8 *State);
798
799/* Values for State above */
800
801#define ACPI_RSTATE_NORMAL 0
802#define ACPI_RSTATE_START_DEPENDENT 1
803#define ACPI_RSTATE_DEPENDENT_LIST 2
804
805UINT32
806RsLinkDescriptorChain (
807 ASL_RESOURCE_NODE **PreviousRnode,
808 ASL_RESOURCE_NODE *Rnode);
809
810void
811RsDoResourceTemplate (
812 ACPI_PARSE_OBJECT *Op);
813
814
815/*
816 * aslrestype1 - Miscellaneous Small descriptors
817 */
818ASL_RESOURCE_NODE *
819RsDoEndTagDescriptor (
820 ACPI_PARSE_OBJECT *Op,
821 UINT32 CurrentByteOffset);
822
823ASL_RESOURCE_NODE *
824RsDoEndDependentDescriptor (
825 ACPI_PARSE_OBJECT *Op,
826 UINT32 CurrentByteOffset);
827
828ASL_RESOURCE_NODE *
829RsDoMemory24Descriptor (
830 ACPI_PARSE_OBJECT *Op,
831 UINT32 CurrentByteOffset);
832
833ASL_RESOURCE_NODE *
834RsDoMemory32Descriptor (
835 ACPI_PARSE_OBJECT *Op,
836 UINT32 CurrentByteOffset);
837
838ASL_RESOURCE_NODE *
839RsDoMemory32FixedDescriptor (
840 ACPI_PARSE_OBJECT *Op,
841 UINT32 CurrentByteOffset);
842
843ASL_RESOURCE_NODE *
844RsDoStartDependentDescriptor (
845 ACPI_PARSE_OBJECT *Op,
846 UINT32 CurrentByteOffset);
847
848ASL_RESOURCE_NODE *
849RsDoStartDependentNoPriDescriptor (
850 ACPI_PARSE_OBJECT *Op,
851 UINT32 CurrentByteOffset);
852
853ASL_RESOURCE_NODE *
854RsDoVendorSmallDescriptor (
855 ACPI_PARSE_OBJECT *Op,
856 UINT32 CurrentByteOffset);
857
858
859/*
860 * aslrestype1i - I/O-related Small descriptors
861 */
862ASL_RESOURCE_NODE *
863RsDoDmaDescriptor (
864 ACPI_PARSE_OBJECT *Op,
865 UINT32 CurrentByteOffset);
866
867ASL_RESOURCE_NODE *
868RsDoFixedIoDescriptor (
869 ACPI_PARSE_OBJECT *Op,
870 UINT32 CurrentByteOffset);
871
872ASL_RESOURCE_NODE *
873RsDoIoDescriptor (
874 ACPI_PARSE_OBJECT *Op,
875 UINT32 CurrentByteOffset);
876
877ASL_RESOURCE_NODE *
878RsDoIrqDescriptor (
879 ACPI_PARSE_OBJECT *Op,
880 UINT32 CurrentByteOffset);
881
882ASL_RESOURCE_NODE *
883RsDoIrqNoFlagsDescriptor (
884 ACPI_PARSE_OBJECT *Op,
885 UINT32 CurrentByteOffset);
886
887
888/*
889 * aslrestype2 - Large resource descriptors
890 */
891ASL_RESOURCE_NODE *
892RsDoInterruptDescriptor (
893 ACPI_PARSE_OBJECT *Op,
894 UINT32 CurrentByteOffset);
895
896ASL_RESOURCE_NODE *
897RsDoVendorLargeDescriptor (
898 ACPI_PARSE_OBJECT *Op,
899 UINT32 CurrentByteOffset);
900
901ASL_RESOURCE_NODE *
902RsDoGeneralRegisterDescriptor (
903 ACPI_PARSE_OBJECT *Op,
904 UINT32 CurrentByteOffset);
905
906
907/*
908 * aslrestype2d - DWord address descriptors
909 */
910ASL_RESOURCE_NODE *
911RsDoDwordIoDescriptor (
912 ACPI_PARSE_OBJECT *Op,
913 UINT32 CurrentByteOffset);
914
915ASL_RESOURCE_NODE *
916RsDoDwordMemoryDescriptor (
917 ACPI_PARSE_OBJECT *Op,
918 UINT32 CurrentByteOffset);
919
920ASL_RESOURCE_NODE *
921RsDoDwordSpaceDescriptor (
922 ACPI_PARSE_OBJECT *Op,
923 UINT32 CurrentByteOffset);
924
925
926/*
927 * aslrestype2e - Extended address descriptors
928 */
929ASL_RESOURCE_NODE *
930RsDoExtendedIoDescriptor (
931 ACPI_PARSE_OBJECT *Op,
932 UINT32 CurrentByteOffset);
933
934ASL_RESOURCE_NODE *
935RsDoExtendedMemoryDescriptor (
936 ACPI_PARSE_OBJECT *Op,
937 UINT32 CurrentByteOffset);
938
939ASL_RESOURCE_NODE *
940RsDoExtendedSpaceDescriptor (
941 ACPI_PARSE_OBJECT *Op,
942 UINT32 CurrentByteOffset);
943
944
945/*
946 * aslrestype2q - QWord address descriptors
947 */
948ASL_RESOURCE_NODE *
949RsDoQwordIoDescriptor (
950 ACPI_PARSE_OBJECT *Op,
951 UINT32 CurrentByteOffset);
952
953ASL_RESOURCE_NODE *
954RsDoQwordMemoryDescriptor (
955 ACPI_PARSE_OBJECT *Op,
956 UINT32 CurrentByteOffset);
957
958ASL_RESOURCE_NODE *
959RsDoQwordSpaceDescriptor (
960 ACPI_PARSE_OBJECT *Op,
961 UINT32 CurrentByteOffset);
962
963
964/*
965 * aslrestype2w - Word address descriptors
966 */
967ASL_RESOURCE_NODE *
968RsDoWordIoDescriptor (
969 ACPI_PARSE_OBJECT *Op,
970 UINT32 CurrentByteOffset);
971
972ASL_RESOURCE_NODE *
973RsDoWordSpaceDescriptor (
974 ACPI_PARSE_OBJECT *Op,
975 UINT32 CurrentByteOffset);
976
977ASL_RESOURCE_NODE *
978RsDoWordBusNumberDescriptor (
979 ACPI_PARSE_OBJECT *Op,
980 UINT32 CurrentByteOffset);
981
982/*
983 * Entry to data table compiler subsystem
984 */
985ACPI_STATUS
986DtDoCompile(
987 void);
988
989ACPI_STATUS
990DtCreateTemplates (
991 char *Signature);
992
993#endif /* __ASLCOMPILER_H */
994
| 546TrLinkChildren (
547 ACPI_PARSE_OBJECT *Op,
548 UINT32 NumChildren,
549 ...);
550
551void
552TrSetEndLineNumber (
553 ACPI_PARSE_OBJECT *Op);
554
555void
556TrWalkTree (
557 void);
558
559ACPI_PARSE_OBJECT *
560TrLinkPeerNode (
561 ACPI_PARSE_OBJECT *Op1,
562 ACPI_PARSE_OBJECT *Op2);
563
564ACPI_PARSE_OBJECT *
565TrLinkChildNode (
566 ACPI_PARSE_OBJECT *Op1,
567 ACPI_PARSE_OBJECT *Op2);
568
569ACPI_PARSE_OBJECT *
570TrSetNodeFlags (
571 ACPI_PARSE_OBJECT *Op,
572 UINT32 Flags);
573
574ACPI_PARSE_OBJECT *
575TrLinkPeerNodes (
576 UINT32 NumPeers,
577 ...);
578
579
580/*
581 * aslfiles - File I/O support
582 */
583void
584AslAbort (
585 void);
586
587void
588FlAddIncludeDirectory (
589 char *Dir);
590
591void
592FlOpenIncludeFile (
593 ACPI_PARSE_OBJECT *Op);
594
595void
596FlFileError (
597 UINT32 FileId,
598 UINT8 ErrorId);
599
600UINT32
601FlGetFileSize (
602 UINT32 FileId);
603
604ACPI_STATUS
605FlReadFile (
606 UINT32 FileId,
607 void *Buffer,
608 UINT32 Length);
609
610void
611FlWriteFile (
612 UINT32 FileId,
613 void *Buffer,
614 UINT32 Length);
615
616void
617FlSeekFile (
618 UINT32 FileId,
619 long Offset);
620
621void
622FlCloseFile (
623 UINT32 FileId);
624
625void
626FlPrintFile (
627 UINT32 FileId,
628 char *Format,
629 ...);
630
631void
632FlSetLineNumber (
633 ACPI_PARSE_OBJECT *Op);
634
635ACPI_STATUS
636FlOpenInputFile (
637 char *InputFilename);
638
639ACPI_STATUS
640FlOpenAmlOutputFile (
641 char *InputFilename);
642
643ACPI_STATUS
644FlOpenMiscOutputFiles (
645 char *InputFilename);
646
647
648/*
649 * asload - load namespace in prep for cross reference
650 */
651ACPI_STATUS
652LdLoadNamespace (
653 ACPI_PARSE_OBJECT *RootOp);
654
655
656/*
657 * asllookup - namespace cross reference
658 */
659ACPI_STATUS
660LkCrossReferenceNamespace (
661 void);
662
663void
664LkFindUnreferencedObjects (
665 void);
666
667ACPI_STATUS
668LsDisplayNamespace (
669 void);
670
671void
672LsSetupNsList (
673 void *Handle);
674
675
676/*
677 * aslutils - common compiler utilites
678 */
679void
680DbgPrint (
681 UINT32 Type,
682 char *Format,
683 ...);
684
685/* Type values for above */
686
687#define ASL_DEBUG_OUTPUT 0
688#define ASL_PARSE_OUTPUT 1
689#define ASL_TREE_OUTPUT 2
690
691void
692UtDisplaySupportedTables (
693 void);
694
695void
696UtDisplayConstantOpcodes (
697 void);
698
699UINT8
700UtBeginEvent (
701 char *Name);
702
703void
704UtEndEvent (
705 UINT8 Event);
706
707void *
708UtLocalCalloc (
709 UINT32 Size);
710
711void
712UtPrintFormattedName (
713 UINT16 ParseOpcode,
714 UINT32 Level);
715
716void
717UtDisplaySummary (
718 UINT32 FileId);
719
720UINT8
721UtHexCharToValue (
722 int HexChar);
723
724void
725UtConvertByteToHex (
726 UINT8 RawByte,
727 UINT8 *Buffer);
728
729void
730UtConvertByteToAsmHex (
731 UINT8 RawByte,
732 UINT8 *Buffer);
733
734char *
735UtGetOpName (
736 UINT32 ParseOpcode);
737
738void
739UtSetParseOpName (
740 ACPI_PARSE_OBJECT *Op);
741
742char *
743UtGetStringBuffer (
744 UINT32 Length);
745
746ACPI_STATUS
747UtInternalizeName (
748 char *ExternalName,
749 char **ConvertedName);
750
751void
752UtAttachNamepathToOwner (
753 ACPI_PARSE_OBJECT *Op,
754 ACPI_PARSE_OBJECT *NameNode);
755
756ACPI_PARSE_OBJECT *
757UtCheckIntegerRange (
758 ACPI_PARSE_OBJECT *Op,
759 UINT32 LowValue,
760 UINT32 HighValue);
761
762UINT64
763UtDoConstant (
764 char *String);
765
766/*
767 * asluuid - UUID support
768 */
769ACPI_STATUS
770AuValidateUuid (
771 char *InString);
772
773ACPI_STATUS
774AuConvertStringToUuid (
775 char *InString,
776 char *UuIdBuffer);
777
778ACPI_STATUS
779AuConvertUuidToString (
780 char *UuIdBuffer,
781 char *OutString);
782
783/*
784 * aslresource - Resource template generation utilities
785 */
786void
787RsSmallAddressCheck (
788 UINT8 Type,
789 UINT32 Minimum,
790 UINT32 Maximum,
791 UINT32 Length,
792 UINT32 Alignment,
793 ACPI_PARSE_OBJECT *MinOp,
794 ACPI_PARSE_OBJECT *MaxOp,
795 ACPI_PARSE_OBJECT *LengthOp,
796 ACPI_PARSE_OBJECT *AlignOp,
797 ACPI_PARSE_OBJECT *Op);
798
799void
800RsLargeAddressCheck (
801 UINT64 Minimum,
802 UINT64 Maximum,
803 UINT64 Length,
804 UINT64 Granularity,
805 UINT8 Flags,
806 ACPI_PARSE_OBJECT *MinOp,
807 ACPI_PARSE_OBJECT *MaxOp,
808 ACPI_PARSE_OBJECT *LengthOp,
809 ACPI_PARSE_OBJECT *GranOp,
810 ACPI_PARSE_OBJECT *Op);
811
812UINT16
813RsGetStringDataLength (
814 ACPI_PARSE_OBJECT *InitializerOp);
815
816ASL_RESOURCE_NODE *
817RsAllocateResourceNode (
818 UINT32 Size);
819
820void
821RsCreateBitField (
822 ACPI_PARSE_OBJECT *Op,
823 char *Name,
824 UINT32 ByteOffset,
825 UINT32 BitOffset);
826
827void
828RsCreateByteField (
829 ACPI_PARSE_OBJECT *Op,
830 char *Name,
831 UINT32 ByteOffset);
832
833void
834RsSetFlagBits (
835 UINT8 *Flags,
836 ACPI_PARSE_OBJECT *Op,
837 UINT8 Position,
838 UINT8 DefaultBit);
839
840ACPI_PARSE_OBJECT *
841RsCompleteNodeAndGetNext (
842 ACPI_PARSE_OBJECT *Op);
843
844void
845RsCheckListForDuplicates (
846 ACPI_PARSE_OBJECT *Op);
847
848ASL_RESOURCE_NODE *
849RsDoOneResourceDescriptor (
850 ACPI_PARSE_OBJECT *DescriptorTypeOp,
851 UINT32 CurrentByteOffset,
852 UINT8 *State);
853
854/* Values for State above */
855
856#define ACPI_RSTATE_NORMAL 0
857#define ACPI_RSTATE_START_DEPENDENT 1
858#define ACPI_RSTATE_DEPENDENT_LIST 2
859
860UINT32
861RsLinkDescriptorChain (
862 ASL_RESOURCE_NODE **PreviousRnode,
863 ASL_RESOURCE_NODE *Rnode);
864
865void
866RsDoResourceTemplate (
867 ACPI_PARSE_OBJECT *Op);
868
869
870/*
871 * aslrestype1 - Miscellaneous Small descriptors
872 */
873ASL_RESOURCE_NODE *
874RsDoEndTagDescriptor (
875 ACPI_PARSE_OBJECT *Op,
876 UINT32 CurrentByteOffset);
877
878ASL_RESOURCE_NODE *
879RsDoEndDependentDescriptor (
880 ACPI_PARSE_OBJECT *Op,
881 UINT32 CurrentByteOffset);
882
883ASL_RESOURCE_NODE *
884RsDoMemory24Descriptor (
885 ACPI_PARSE_OBJECT *Op,
886 UINT32 CurrentByteOffset);
887
888ASL_RESOURCE_NODE *
889RsDoMemory32Descriptor (
890 ACPI_PARSE_OBJECT *Op,
891 UINT32 CurrentByteOffset);
892
893ASL_RESOURCE_NODE *
894RsDoMemory32FixedDescriptor (
895 ACPI_PARSE_OBJECT *Op,
896 UINT32 CurrentByteOffset);
897
898ASL_RESOURCE_NODE *
899RsDoStartDependentDescriptor (
900 ACPI_PARSE_OBJECT *Op,
901 UINT32 CurrentByteOffset);
902
903ASL_RESOURCE_NODE *
904RsDoStartDependentNoPriDescriptor (
905 ACPI_PARSE_OBJECT *Op,
906 UINT32 CurrentByteOffset);
907
908ASL_RESOURCE_NODE *
909RsDoVendorSmallDescriptor (
910 ACPI_PARSE_OBJECT *Op,
911 UINT32 CurrentByteOffset);
912
913
914/*
915 * aslrestype1i - I/O-related Small descriptors
916 */
917ASL_RESOURCE_NODE *
918RsDoDmaDescriptor (
919 ACPI_PARSE_OBJECT *Op,
920 UINT32 CurrentByteOffset);
921
922ASL_RESOURCE_NODE *
923RsDoFixedIoDescriptor (
924 ACPI_PARSE_OBJECT *Op,
925 UINT32 CurrentByteOffset);
926
927ASL_RESOURCE_NODE *
928RsDoIoDescriptor (
929 ACPI_PARSE_OBJECT *Op,
930 UINT32 CurrentByteOffset);
931
932ASL_RESOURCE_NODE *
933RsDoIrqDescriptor (
934 ACPI_PARSE_OBJECT *Op,
935 UINT32 CurrentByteOffset);
936
937ASL_RESOURCE_NODE *
938RsDoIrqNoFlagsDescriptor (
939 ACPI_PARSE_OBJECT *Op,
940 UINT32 CurrentByteOffset);
941
942
943/*
944 * aslrestype2 - Large resource descriptors
945 */
946ASL_RESOURCE_NODE *
947RsDoInterruptDescriptor (
948 ACPI_PARSE_OBJECT *Op,
949 UINT32 CurrentByteOffset);
950
951ASL_RESOURCE_NODE *
952RsDoVendorLargeDescriptor (
953 ACPI_PARSE_OBJECT *Op,
954 UINT32 CurrentByteOffset);
955
956ASL_RESOURCE_NODE *
957RsDoGeneralRegisterDescriptor (
958 ACPI_PARSE_OBJECT *Op,
959 UINT32 CurrentByteOffset);
960
961
962/*
963 * aslrestype2d - DWord address descriptors
964 */
965ASL_RESOURCE_NODE *
966RsDoDwordIoDescriptor (
967 ACPI_PARSE_OBJECT *Op,
968 UINT32 CurrentByteOffset);
969
970ASL_RESOURCE_NODE *
971RsDoDwordMemoryDescriptor (
972 ACPI_PARSE_OBJECT *Op,
973 UINT32 CurrentByteOffset);
974
975ASL_RESOURCE_NODE *
976RsDoDwordSpaceDescriptor (
977 ACPI_PARSE_OBJECT *Op,
978 UINT32 CurrentByteOffset);
979
980
981/*
982 * aslrestype2e - Extended address descriptors
983 */
984ASL_RESOURCE_NODE *
985RsDoExtendedIoDescriptor (
986 ACPI_PARSE_OBJECT *Op,
987 UINT32 CurrentByteOffset);
988
989ASL_RESOURCE_NODE *
990RsDoExtendedMemoryDescriptor (
991 ACPI_PARSE_OBJECT *Op,
992 UINT32 CurrentByteOffset);
993
994ASL_RESOURCE_NODE *
995RsDoExtendedSpaceDescriptor (
996 ACPI_PARSE_OBJECT *Op,
997 UINT32 CurrentByteOffset);
998
999
1000/*
1001 * aslrestype2q - QWord address descriptors
1002 */
1003ASL_RESOURCE_NODE *
1004RsDoQwordIoDescriptor (
1005 ACPI_PARSE_OBJECT *Op,
1006 UINT32 CurrentByteOffset);
1007
1008ASL_RESOURCE_NODE *
1009RsDoQwordMemoryDescriptor (
1010 ACPI_PARSE_OBJECT *Op,
1011 UINT32 CurrentByteOffset);
1012
1013ASL_RESOURCE_NODE *
1014RsDoQwordSpaceDescriptor (
1015 ACPI_PARSE_OBJECT *Op,
1016 UINT32 CurrentByteOffset);
1017
1018
1019/*
1020 * aslrestype2w - Word address descriptors
1021 */
1022ASL_RESOURCE_NODE *
1023RsDoWordIoDescriptor (
1024 ACPI_PARSE_OBJECT *Op,
1025 UINT32 CurrentByteOffset);
1026
1027ASL_RESOURCE_NODE *
1028RsDoWordSpaceDescriptor (
1029 ACPI_PARSE_OBJECT *Op,
1030 UINT32 CurrentByteOffset);
1031
1032ASL_RESOURCE_NODE *
1033RsDoWordBusNumberDescriptor (
1034 ACPI_PARSE_OBJECT *Op,
1035 UINT32 CurrentByteOffset);
1036
1037/*
1038 * Entry to data table compiler subsystem
1039 */
1040ACPI_STATUS
1041DtDoCompile(
1042 void);
1043
1044ACPI_STATUS
1045DtCreateTemplates (
1046 char *Signature);
1047
1048#endif /* __ASLCOMPILER_H */
1049
|