asloperands.c revision 1.1.1.8 1 1.1 jruoho /******************************************************************************
2 1.1 jruoho *
3 1.1 jruoho * Module Name: asloperands - AML operand processing
4 1.1 jruoho *
5 1.1 jruoho *****************************************************************************/
6 1.1 jruoho
7 1.1.1.2 jruoho /*
8 1.1.1.7 christos * Copyright (C) 2000 - 2016, Intel Corp.
9 1.1 jruoho * All rights reserved.
10 1.1 jruoho *
11 1.1.1.2 jruoho * Redistribution and use in source and binary forms, with or without
12 1.1.1.2 jruoho * modification, are permitted provided that the following conditions
13 1.1.1.2 jruoho * are met:
14 1.1.1.2 jruoho * 1. Redistributions of source code must retain the above copyright
15 1.1.1.2 jruoho * notice, this list of conditions, and the following disclaimer,
16 1.1.1.2 jruoho * without modification.
17 1.1.1.2 jruoho * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 1.1.1.2 jruoho * substantially similar to the "NO WARRANTY" disclaimer below
19 1.1.1.2 jruoho * ("Disclaimer") and any redistribution must be conditioned upon
20 1.1.1.2 jruoho * including a substantially similar Disclaimer requirement for further
21 1.1.1.2 jruoho * binary redistribution.
22 1.1.1.2 jruoho * 3. Neither the names of the above-listed copyright holders nor the names
23 1.1.1.2 jruoho * of any contributors may be used to endorse or promote products derived
24 1.1.1.2 jruoho * from this software without specific prior written permission.
25 1.1.1.2 jruoho *
26 1.1.1.2 jruoho * Alternatively, this software may be distributed under the terms of the
27 1.1.1.2 jruoho * GNU General Public License ("GPL") version 2 as published by the Free
28 1.1.1.2 jruoho * Software Foundation.
29 1.1.1.2 jruoho *
30 1.1.1.2 jruoho * NO WARRANTY
31 1.1.1.2 jruoho * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 1.1.1.2 jruoho * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 1.1.1.2 jruoho * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 1.1.1.2 jruoho * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 1.1.1.2 jruoho * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 1.1.1.2 jruoho * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 1.1.1.2 jruoho * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 1.1.1.2 jruoho * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 1.1.1.2 jruoho * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 1.1.1.2 jruoho * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 1.1.1.2 jruoho * POSSIBILITY OF SUCH DAMAGES.
42 1.1.1.2 jruoho */
43 1.1 jruoho
44 1.1 jruoho #include "aslcompiler.h"
45 1.1 jruoho #include "aslcompiler.y.h"
46 1.1 jruoho #include "amlcode.h"
47 1.1 jruoho
48 1.1 jruoho #define _COMPONENT ACPI_COMPILER
49 1.1 jruoho ACPI_MODULE_NAME ("asloperands")
50 1.1 jruoho
51 1.1 jruoho /* Local prototypes */
52 1.1 jruoho
53 1.1 jruoho static void
54 1.1 jruoho OpnDoField (
55 1.1 jruoho ACPI_PARSE_OBJECT *Op);
56 1.1 jruoho
57 1.1 jruoho static void
58 1.1 jruoho OpnDoBankField (
59 1.1 jruoho ACPI_PARSE_OBJECT *Op);
60 1.1 jruoho
61 1.1 jruoho static void
62 1.1 jruoho OpnDoBuffer (
63 1.1 jruoho ACPI_PARSE_OBJECT *Op);
64 1.1 jruoho
65 1.1 jruoho static void
66 1.1 jruoho OpnDoDefinitionBlock (
67 1.1 jruoho ACPI_PARSE_OBJECT *Op);
68 1.1 jruoho
69 1.1 jruoho static void
70 1.1 jruoho OpnDoFieldCommon (
71 1.1 jruoho ACPI_PARSE_OBJECT *FieldOp,
72 1.1 jruoho ACPI_PARSE_OBJECT *Op);
73 1.1 jruoho
74 1.1 jruoho static void
75 1.1 jruoho OpnDoIndexField (
76 1.1 jruoho ACPI_PARSE_OBJECT *Op);
77 1.1 jruoho
78 1.1 jruoho static void
79 1.1 jruoho OpnDoLoadTable (
80 1.1 jruoho ACPI_PARSE_OBJECT *Op);
81 1.1 jruoho
82 1.1 jruoho static void
83 1.1 jruoho OpnDoMethod (
84 1.1 jruoho ACPI_PARSE_OBJECT *Op);
85 1.1 jruoho
86 1.1 jruoho static void
87 1.1 jruoho OpnDoMutex (
88 1.1 jruoho ACPI_PARSE_OBJECT *Op);
89 1.1 jruoho
90 1.1 jruoho static void
91 1.1 jruoho OpnDoRegion (
92 1.1 jruoho ACPI_PARSE_OBJECT *Op);
93 1.1 jruoho
94 1.1 jruoho static void
95 1.1 jruoho OpnAttachNameToNode (
96 1.1 jruoho ACPI_PARSE_OBJECT *Op);
97 1.1 jruoho
98 1.1 jruoho
99 1.1 jruoho /*******************************************************************************
100 1.1 jruoho *
101 1.1 jruoho * FUNCTION: OpnDoMutex
102 1.1 jruoho *
103 1.1 jruoho * PARAMETERS: Op - The parent parse node
104 1.1 jruoho *
105 1.1 jruoho * RETURN: None
106 1.1 jruoho *
107 1.1 jruoho * DESCRIPTION: Construct the operands for the MUTEX ASL keyword.
108 1.1 jruoho *
109 1.1 jruoho ******************************************************************************/
110 1.1 jruoho
111 1.1 jruoho static void
112 1.1 jruoho OpnDoMutex (
113 1.1 jruoho ACPI_PARSE_OBJECT *Op)
114 1.1 jruoho {
115 1.1 jruoho ACPI_PARSE_OBJECT *Next;
116 1.1 jruoho
117 1.1 jruoho
118 1.1 jruoho Next = Op->Asl.Child;
119 1.1 jruoho Next = Next->Asl.Next;
120 1.1 jruoho
121 1.1 jruoho if (Next->Asl.Value.Integer > 15)
122 1.1 jruoho {
123 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL);
124 1.1 jruoho }
125 1.1 jruoho return;
126 1.1 jruoho }
127 1.1 jruoho
128 1.1 jruoho
129 1.1 jruoho /*******************************************************************************
130 1.1 jruoho *
131 1.1 jruoho * FUNCTION: OpnDoMethod
132 1.1 jruoho *
133 1.1 jruoho * PARAMETERS: Op - The parent parse node
134 1.1 jruoho *
135 1.1 jruoho * RETURN: None
136 1.1 jruoho *
137 1.1 jruoho * DESCRIPTION: Construct the operands for the METHOD ASL keyword.
138 1.1 jruoho *
139 1.1 jruoho ******************************************************************************/
140 1.1 jruoho
141 1.1 jruoho static void
142 1.1 jruoho OpnDoMethod (
143 1.1 jruoho ACPI_PARSE_OBJECT *Op)
144 1.1 jruoho {
145 1.1 jruoho ACPI_PARSE_OBJECT *Next;
146 1.1 jruoho
147 1.1 jruoho /* Optional arguments for this opcode with defaults */
148 1.1 jruoho
149 1.1 jruoho UINT8 NumArgs = 0;
150 1.1 jruoho UINT8 Serialized = 0;
151 1.1 jruoho UINT8 Concurrency = 0;
152 1.1 jruoho UINT8 MethodFlags;
153 1.1 jruoho
154 1.1 jruoho
155 1.1 jruoho /* Opcode and package length first */
156 1.1 jruoho /* Method name */
157 1.1 jruoho
158 1.1 jruoho Next = Op->Asl.Child;
159 1.1 jruoho
160 1.1 jruoho /* Num args */
161 1.1 jruoho
162 1.1 jruoho Next = Next->Asl.Next;
163 1.1 jruoho if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
164 1.1 jruoho {
165 1.1 jruoho NumArgs = (UINT8) Next->Asl.Value.Integer;
166 1.1 jruoho Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
167 1.1 jruoho }
168 1.1 jruoho
169 1.1 jruoho /* Serialized Flag */
170 1.1 jruoho
171 1.1 jruoho Next = Next->Asl.Next;
172 1.1 jruoho if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
173 1.1 jruoho {
174 1.1 jruoho Serialized = (UINT8) Next->Asl.Value.Integer;
175 1.1 jruoho Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
176 1.1 jruoho }
177 1.1 jruoho
178 1.1 jruoho /* Concurrency value (valid values are 0-15) */
179 1.1 jruoho
180 1.1 jruoho Next = Next->Asl.Next;
181 1.1 jruoho if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
182 1.1 jruoho {
183 1.1.1.3 christos /* This is a ByteConstExpr, so eval the constant now */
184 1.1.1.3 christos
185 1.1.1.3 christos OpcAmlConstantWalk (Next, 0, NULL);
186 1.1.1.3 christos
187 1.1 jruoho if (Next->Asl.Value.Integer > 15)
188 1.1 jruoho {
189 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL);
190 1.1 jruoho }
191 1.1.1.7 christos
192 1.1 jruoho Concurrency = (UINT8) Next->Asl.Value.Integer;
193 1.1 jruoho }
194 1.1 jruoho
195 1.1 jruoho /* Put the bits in their proper places */
196 1.1 jruoho
197 1.1.1.7 christos MethodFlags = (UINT8)
198 1.1.1.7 christos ((NumArgs & 0x7) |
199 1.1.1.7 christos ((Serialized & 0x1) << 3) |
200 1.1.1.7 christos ((Concurrency & 0xF) << 4));
201 1.1 jruoho
202 1.1 jruoho /* Use the last node for the combined flags byte */
203 1.1 jruoho
204 1.1 jruoho Next->Asl.Value.Integer = MethodFlags;
205 1.1 jruoho Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
206 1.1 jruoho Next->Asl.AmlLength = 1;
207 1.1 jruoho Next->Asl.ParseOpcode = PARSEOP_RAW_DATA;
208 1.1 jruoho
209 1.1 jruoho /* Save the arg count in the first node */
210 1.1 jruoho
211 1.1 jruoho Op->Asl.Extra = NumArgs;
212 1.1 jruoho }
213 1.1 jruoho
214 1.1 jruoho
215 1.1 jruoho /*******************************************************************************
216 1.1 jruoho *
217 1.1 jruoho * FUNCTION: OpnDoFieldCommon
218 1.1 jruoho *
219 1.1 jruoho * PARAMETERS: FieldOp - Node for an ASL field
220 1.1 jruoho * Op - The parent parse node
221 1.1 jruoho *
222 1.1 jruoho * RETURN: None
223 1.1 jruoho *
224 1.1 jruoho * DESCRIPTION: Construct the AML operands for the various field keywords,
225 1.1 jruoho * FIELD, BANKFIELD, INDEXFIELD
226 1.1 jruoho *
227 1.1 jruoho ******************************************************************************/
228 1.1 jruoho
229 1.1 jruoho static void
230 1.1 jruoho OpnDoFieldCommon (
231 1.1 jruoho ACPI_PARSE_OBJECT *FieldOp,
232 1.1 jruoho ACPI_PARSE_OBJECT *Op)
233 1.1 jruoho {
234 1.1 jruoho ACPI_PARSE_OBJECT *Next;
235 1.1 jruoho ACPI_PARSE_OBJECT *PkgLengthNode;
236 1.1 jruoho UINT32 CurrentBitOffset;
237 1.1 jruoho UINT32 NewBitOffset;
238 1.1 jruoho UINT8 AccessType;
239 1.1 jruoho UINT8 LockRule;
240 1.1 jruoho UINT8 UpdateRule;
241 1.1 jruoho UINT8 FieldFlags;
242 1.1 jruoho UINT32 MinimumLength;
243 1.1 jruoho
244 1.1 jruoho
245 1.1 jruoho /* AccessType -- not optional, so no need to check for DEFAULT_ARG */
246 1.1 jruoho
247 1.1 jruoho AccessType = (UINT8) Op->Asl.Value.Integer;
248 1.1 jruoho Op->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
249 1.1 jruoho
250 1.1 jruoho /* Set the access type in the parent (field) node for use later */
251 1.1 jruoho
252 1.1 jruoho FieldOp->Asl.Value.Integer = AccessType;
253 1.1 jruoho
254 1.1 jruoho /* LockRule -- not optional, so no need to check for DEFAULT_ARG */
255 1.1 jruoho
256 1.1 jruoho Next = Op->Asl.Next;
257 1.1 jruoho LockRule = (UINT8) Next->Asl.Value.Integer;
258 1.1 jruoho Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
259 1.1 jruoho
260 1.1 jruoho /* UpdateRule -- not optional, so no need to check for DEFAULT_ARG */
261 1.1 jruoho
262 1.1 jruoho Next = Next->Asl.Next;
263 1.1 jruoho UpdateRule = (UINT8) Next->Asl.Value.Integer;
264 1.1 jruoho
265 1.1 jruoho /*
266 1.1.1.3 christos * Generate the flags byte. The various fields are already
267 1.1 jruoho * in the right bit position via translation from the
268 1.1 jruoho * keywords by the parser.
269 1.1 jruoho */
270 1.1 jruoho FieldFlags = (UINT8) (AccessType | LockRule | UpdateRule);
271 1.1 jruoho
272 1.1 jruoho /* Use the previous node to be the FieldFlags node */
273 1.1 jruoho
274 1.1 jruoho /* Set the node to RAW_DATA */
275 1.1 jruoho
276 1.1 jruoho Next->Asl.Value.Integer = FieldFlags;
277 1.1.1.7 christos Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
278 1.1.1.7 christos Next->Asl.AmlLength = 1;
279 1.1.1.7 christos Next->Asl.ParseOpcode = PARSEOP_RAW_DATA;
280 1.1 jruoho
281 1.1 jruoho /* Process the FieldUnitList */
282 1.1 jruoho
283 1.1 jruoho Next = Next->Asl.Next;
284 1.1 jruoho CurrentBitOffset = 0;
285 1.1 jruoho
286 1.1 jruoho while (Next)
287 1.1 jruoho {
288 1.1 jruoho /* Save the offset of this field unit */
289 1.1 jruoho
290 1.1 jruoho Next->Asl.ExtraValue = CurrentBitOffset;
291 1.1 jruoho
292 1.1 jruoho switch (Next->Asl.ParseOpcode)
293 1.1 jruoho {
294 1.1 jruoho case PARSEOP_ACCESSAS:
295 1.1 jruoho
296 1.1 jruoho PkgLengthNode = Next->Asl.Child;
297 1.1 jruoho AccessType = (UINT8) PkgLengthNode->Asl.Value.Integer;
298 1.1 jruoho
299 1.1 jruoho /* Nothing additional to do */
300 1.1 jruoho break;
301 1.1 jruoho
302 1.1 jruoho case PARSEOP_OFFSET:
303 1.1 jruoho
304 1.1 jruoho /* New offset into the field */
305 1.1 jruoho
306 1.1 jruoho PkgLengthNode = Next->Asl.Child;
307 1.1 jruoho NewBitOffset = ((UINT32) PkgLengthNode->Asl.Value.Integer) * 8;
308 1.1 jruoho
309 1.1 jruoho /*
310 1.1 jruoho * Examine the specified offset in relation to the
311 1.1 jruoho * current offset counter.
312 1.1 jruoho */
313 1.1 jruoho if (NewBitOffset < CurrentBitOffset)
314 1.1 jruoho {
315 1.1 jruoho /*
316 1.1 jruoho * Not allowed to specify a backwards offset!
317 1.1 jruoho * Issue error and ignore this node.
318 1.1 jruoho */
319 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_BACKWARDS_OFFSET, PkgLengthNode,
320 1.1 jruoho NULL);
321 1.1 jruoho Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
322 1.1 jruoho PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
323 1.1 jruoho }
324 1.1 jruoho else if (NewBitOffset == CurrentBitOffset)
325 1.1 jruoho {
326 1.1 jruoho /*
327 1.1 jruoho * Offset is redundant; we don't need to output an
328 1.1.1.3 christos * offset opcode. Just set these nodes to default
329 1.1 jruoho */
330 1.1 jruoho Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
331 1.1 jruoho PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
332 1.1 jruoho }
333 1.1 jruoho else
334 1.1 jruoho {
335 1.1 jruoho /*
336 1.1 jruoho * Valid new offset - set the value to be inserted into the AML
337 1.1 jruoho * and update the offset counter.
338 1.1 jruoho */
339 1.1 jruoho PkgLengthNode->Asl.Value.Integer =
340 1.1 jruoho NewBitOffset - CurrentBitOffset;
341 1.1 jruoho CurrentBitOffset = NewBitOffset;
342 1.1 jruoho }
343 1.1 jruoho break;
344 1.1 jruoho
345 1.1 jruoho case PARSEOP_NAMESEG:
346 1.1 jruoho case PARSEOP_RESERVED_BYTES:
347 1.1 jruoho
348 1.1 jruoho /* Named or reserved field entry */
349 1.1 jruoho
350 1.1.1.7 christos PkgLengthNode = Next->Asl.Child;
351 1.1.1.7 christos NewBitOffset = (UINT32) PkgLengthNode->Asl.Value.Integer;
352 1.1 jruoho CurrentBitOffset += NewBitOffset;
353 1.1 jruoho
354 1.1 jruoho /* Save the current AccessAs value for error checking later */
355 1.1 jruoho
356 1.1 jruoho switch (AccessType)
357 1.1 jruoho {
358 1.1 jruoho case AML_FIELD_ACCESS_ANY:
359 1.1 jruoho case AML_FIELD_ACCESS_BYTE:
360 1.1 jruoho case AML_FIELD_ACCESS_BUFFER:
361 1.1 jruoho default:
362 1.1.1.3 christos
363 1.1 jruoho MinimumLength = 8;
364 1.1 jruoho break;
365 1.1 jruoho
366 1.1 jruoho case AML_FIELD_ACCESS_WORD:
367 1.1 jruoho MinimumLength = 16;
368 1.1 jruoho break;
369 1.1 jruoho
370 1.1 jruoho case AML_FIELD_ACCESS_DWORD:
371 1.1 jruoho MinimumLength = 32;
372 1.1 jruoho break;
373 1.1 jruoho
374 1.1 jruoho case AML_FIELD_ACCESS_QWORD:
375 1.1 jruoho MinimumLength = 64;
376 1.1 jruoho break;
377 1.1 jruoho }
378 1.1 jruoho
379 1.1 jruoho PkgLengthNode->Asl.ExtraValue = MinimumLength;
380 1.1 jruoho break;
381 1.1 jruoho
382 1.1 jruoho default:
383 1.1.1.3 christos
384 1.1 jruoho /* All supported field opcodes must appear above */
385 1.1.1.3 christos
386 1.1 jruoho break;
387 1.1 jruoho }
388 1.1 jruoho
389 1.1 jruoho /* Move on to next entry in the field list */
390 1.1 jruoho
391 1.1 jruoho Next = Next->Asl.Next;
392 1.1 jruoho }
393 1.1 jruoho }
394 1.1 jruoho
395 1.1 jruoho
396 1.1 jruoho /*******************************************************************************
397 1.1 jruoho *
398 1.1 jruoho * FUNCTION: OpnDoField
399 1.1 jruoho *
400 1.1 jruoho * PARAMETERS: Op - The parent parse node
401 1.1 jruoho *
402 1.1 jruoho * RETURN: None
403 1.1 jruoho *
404 1.1 jruoho * DESCRIPTION: Construct the AML operands for the FIELD ASL keyword
405 1.1 jruoho *
406 1.1 jruoho ******************************************************************************/
407 1.1 jruoho
408 1.1 jruoho static void
409 1.1 jruoho OpnDoField (
410 1.1 jruoho ACPI_PARSE_OBJECT *Op)
411 1.1 jruoho {
412 1.1 jruoho ACPI_PARSE_OBJECT *Next;
413 1.1 jruoho
414 1.1 jruoho
415 1.1 jruoho /* Opcode is parent node */
416 1.1 jruoho /* First child is field name */
417 1.1 jruoho
418 1.1 jruoho Next = Op->Asl.Child;
419 1.1 jruoho
420 1.1 jruoho /* Second child is the AccessType */
421 1.1 jruoho
422 1.1 jruoho OpnDoFieldCommon (Op, Next->Asl.Next);
423 1.1 jruoho }
424 1.1 jruoho
425 1.1 jruoho
426 1.1 jruoho /*******************************************************************************
427 1.1 jruoho *
428 1.1 jruoho * FUNCTION: OpnDoIndexField
429 1.1 jruoho *
430 1.1 jruoho * PARAMETERS: Op - The parent parse node
431 1.1 jruoho *
432 1.1 jruoho * RETURN: None
433 1.1 jruoho *
434 1.1 jruoho * DESCRIPTION: Construct the AML operands for the INDEXFIELD ASL keyword
435 1.1 jruoho *
436 1.1 jruoho ******************************************************************************/
437 1.1 jruoho
438 1.1 jruoho static void
439 1.1 jruoho OpnDoIndexField (
440 1.1 jruoho ACPI_PARSE_OBJECT *Op)
441 1.1 jruoho {
442 1.1 jruoho ACPI_PARSE_OBJECT *Next;
443 1.1 jruoho
444 1.1 jruoho
445 1.1 jruoho /* Opcode is parent node */
446 1.1 jruoho /* First child is the index name */
447 1.1 jruoho
448 1.1 jruoho Next = Op->Asl.Child;
449 1.1 jruoho
450 1.1 jruoho /* Second child is the data name */
451 1.1 jruoho
452 1.1 jruoho Next = Next->Asl.Next;
453 1.1 jruoho
454 1.1 jruoho /* Third child is the AccessType */
455 1.1 jruoho
456 1.1 jruoho OpnDoFieldCommon (Op, Next->Asl.Next);
457 1.1 jruoho }
458 1.1 jruoho
459 1.1 jruoho
460 1.1 jruoho /*******************************************************************************
461 1.1 jruoho *
462 1.1 jruoho * FUNCTION: OpnDoBankField
463 1.1 jruoho *
464 1.1 jruoho * PARAMETERS: Op - The parent parse node
465 1.1 jruoho *
466 1.1 jruoho * RETURN: None
467 1.1 jruoho *
468 1.1 jruoho * DESCRIPTION: Construct the AML operands for the BANKFIELD ASL keyword
469 1.1 jruoho *
470 1.1 jruoho ******************************************************************************/
471 1.1 jruoho
472 1.1 jruoho static void
473 1.1 jruoho OpnDoBankField (
474 1.1 jruoho ACPI_PARSE_OBJECT *Op)
475 1.1 jruoho {
476 1.1 jruoho ACPI_PARSE_OBJECT *Next;
477 1.1 jruoho
478 1.1 jruoho
479 1.1 jruoho /* Opcode is parent node */
480 1.1 jruoho /* First child is the region name */
481 1.1 jruoho
482 1.1 jruoho Next = Op->Asl.Child;
483 1.1 jruoho
484 1.1 jruoho /* Second child is the bank name */
485 1.1 jruoho
486 1.1 jruoho Next = Next->Asl.Next;
487 1.1 jruoho
488 1.1 jruoho /* Third child is the bank value */
489 1.1 jruoho
490 1.1 jruoho Next = Next->Asl.Next;
491 1.1 jruoho
492 1.1 jruoho /* Fourth child is the AccessType */
493 1.1 jruoho
494 1.1 jruoho OpnDoFieldCommon (Op, Next->Asl.Next);
495 1.1 jruoho }
496 1.1 jruoho
497 1.1 jruoho
498 1.1 jruoho /*******************************************************************************
499 1.1 jruoho *
500 1.1 jruoho * FUNCTION: OpnDoRegion
501 1.1 jruoho *
502 1.1 jruoho * PARAMETERS: Op - The parent parse node
503 1.1 jruoho *
504 1.1 jruoho * RETURN: None
505 1.1 jruoho *
506 1.1.1.3 christos * DESCRIPTION: Tries to get the length of the region. Can only do this at
507 1.1 jruoho * compile time if the length is a constant.
508 1.1 jruoho *
509 1.1 jruoho ******************************************************************************/
510 1.1 jruoho
511 1.1 jruoho static void
512 1.1 jruoho OpnDoRegion (
513 1.1 jruoho ACPI_PARSE_OBJECT *Op)
514 1.1 jruoho {
515 1.1 jruoho ACPI_PARSE_OBJECT *Next;
516 1.1 jruoho
517 1.1 jruoho
518 1.1 jruoho /* Opcode is parent node */
519 1.1 jruoho /* First child is the region name */
520 1.1 jruoho
521 1.1 jruoho Next = Op->Asl.Child;
522 1.1 jruoho
523 1.1 jruoho /* Second child is the space ID*/
524 1.1 jruoho
525 1.1 jruoho Next = Next->Asl.Next;
526 1.1 jruoho
527 1.1 jruoho /* Third child is the region offset */
528 1.1 jruoho
529 1.1 jruoho Next = Next->Asl.Next;
530 1.1 jruoho
531 1.1 jruoho /* Fourth child is the region length */
532 1.1 jruoho
533 1.1 jruoho Next = Next->Asl.Next;
534 1.1 jruoho if (Next->Asl.ParseOpcode == PARSEOP_INTEGER)
535 1.1 jruoho {
536 1.1 jruoho Op->Asl.Value.Integer = Next->Asl.Value.Integer;
537 1.1 jruoho }
538 1.1 jruoho else
539 1.1 jruoho {
540 1.1 jruoho Op->Asl.Value.Integer = ACPI_UINT64_MAX;
541 1.1 jruoho }
542 1.1 jruoho }
543 1.1 jruoho
544 1.1 jruoho
545 1.1 jruoho /*******************************************************************************
546 1.1 jruoho *
547 1.1 jruoho * FUNCTION: OpnDoBuffer
548 1.1 jruoho *
549 1.1 jruoho * PARAMETERS: Op - The parent parse node
550 1.1 jruoho *
551 1.1 jruoho * RETURN: None
552 1.1 jruoho *
553 1.1.1.3 christos * DESCRIPTION: Construct the AML operands for the BUFFER ASL keyword. We
554 1.1 jruoho * build a single raw byte buffer from the initialization nodes,
555 1.1 jruoho * each parse node contains a buffer byte.
556 1.1 jruoho *
557 1.1 jruoho ******************************************************************************/
558 1.1 jruoho
559 1.1 jruoho static void
560 1.1 jruoho OpnDoBuffer (
561 1.1 jruoho ACPI_PARSE_OBJECT *Op)
562 1.1 jruoho {
563 1.1 jruoho ACPI_PARSE_OBJECT *InitializerOp;
564 1.1 jruoho ACPI_PARSE_OBJECT *BufferLengthOp;
565 1.1 jruoho
566 1.1 jruoho /* Optional arguments for this opcode with defaults */
567 1.1 jruoho
568 1.1 jruoho UINT32 BufferLength = 0;
569 1.1 jruoho
570 1.1 jruoho
571 1.1 jruoho /* Opcode and package length first */
572 1.1 jruoho /* Buffer Length is next, followed by the initializer list */
573 1.1 jruoho
574 1.1 jruoho BufferLengthOp = Op->Asl.Child;
575 1.1 jruoho InitializerOp = BufferLengthOp->Asl.Next;
576 1.1 jruoho
577 1.1 jruoho /*
578 1.1 jruoho * If the BufferLength is not an INTEGER or was not specified in the ASL
579 1.1 jruoho * (DEFAULT_ARG), it is a TermArg that is
580 1.1 jruoho * evaluated at run-time, and we are therefore finished.
581 1.1 jruoho */
582 1.1 jruoho if ((BufferLengthOp->Asl.ParseOpcode != PARSEOP_INTEGER) &&
583 1.1 jruoho (BufferLengthOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
584 1.1 jruoho {
585 1.1 jruoho return;
586 1.1 jruoho }
587 1.1 jruoho
588 1.1 jruoho /*
589 1.1 jruoho * We want to count the number of items in the initializer list, because if
590 1.1 jruoho * it is larger than the buffer length, we will define the buffer size
591 1.1 jruoho * to be the size of the initializer list (as per the ACPI Specification)
592 1.1 jruoho */
593 1.1 jruoho switch (InitializerOp->Asl.ParseOpcode)
594 1.1 jruoho {
595 1.1 jruoho case PARSEOP_INTEGER:
596 1.1 jruoho case PARSEOP_BYTECONST:
597 1.1 jruoho case PARSEOP_WORDCONST:
598 1.1 jruoho case PARSEOP_DWORDCONST:
599 1.1 jruoho
600 1.1 jruoho /* The peer list contains the byte list (if any...) */
601 1.1 jruoho
602 1.1 jruoho while (InitializerOp)
603 1.1 jruoho {
604 1.1 jruoho /* For buffers, this is a list of raw bytes */
605 1.1 jruoho
606 1.1.1.7 christos InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
607 1.1.1.7 christos InitializerOp->Asl.AmlLength = 1;
608 1.1.1.7 christos InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
609 1.1 jruoho
610 1.1 jruoho BufferLength++;
611 1.1 jruoho InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
612 1.1 jruoho }
613 1.1 jruoho break;
614 1.1 jruoho
615 1.1 jruoho case PARSEOP_STRING_LITERAL:
616 1.1 jruoho
617 1.1 jruoho /*
618 1.1.1.3 christos * Only one initializer, the string. Buffer must be big enough to hold
619 1.1 jruoho * the string plus the null termination byte
620 1.1 jruoho */
621 1.1 jruoho BufferLength = strlen (InitializerOp->Asl.Value.String) + 1;
622 1.1 jruoho
623 1.1.1.7 christos InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
624 1.1.1.7 christos InitializerOp->Asl.AmlLength = BufferLength;
625 1.1.1.7 christos InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
626 1.1 jruoho break;
627 1.1 jruoho
628 1.1 jruoho case PARSEOP_RAW_DATA:
629 1.1 jruoho
630 1.1 jruoho /* Buffer nodes are already initialized (e.g. Unicode operator) */
631 1.1 jruoho return;
632 1.1 jruoho
633 1.1 jruoho case PARSEOP_DEFAULT_ARG:
634 1.1 jruoho break;
635 1.1 jruoho
636 1.1 jruoho default:
637 1.1.1.3 christos
638 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_INVALID_OPERAND, InitializerOp,
639 1.1 jruoho "Unknown buffer initializer opcode");
640 1.1 jruoho printf ("Unknown buffer initializer opcode [%s]\n",
641 1.1.1.7 christos UtGetOpName (InitializerOp->Asl.ParseOpcode));
642 1.1 jruoho return;
643 1.1 jruoho }
644 1.1 jruoho
645 1.1 jruoho /* Check if initializer list is longer than the buffer length */
646 1.1 jruoho
647 1.1 jruoho if (BufferLengthOp->Asl.Value.Integer > BufferLength)
648 1.1 jruoho {
649 1.1 jruoho BufferLength = (UINT32) BufferLengthOp->Asl.Value.Integer;
650 1.1 jruoho }
651 1.1 jruoho
652 1.1 jruoho if (!BufferLength)
653 1.1 jruoho {
654 1.1 jruoho /* No length AND no items -- issue notice */
655 1.1 jruoho
656 1.1 jruoho AslError (ASL_REMARK, ASL_MSG_BUFFER_LENGTH, BufferLengthOp, NULL);
657 1.1 jruoho
658 1.1 jruoho /* But go ahead and put the buffer length of zero into the AML */
659 1.1 jruoho }
660 1.1 jruoho
661 1.1 jruoho /*
662 1.1 jruoho * Just set the buffer size node to be the buffer length, regardless
663 1.1 jruoho * of whether it was previously an integer or a default_arg placeholder
664 1.1 jruoho */
665 1.1.1.7 christos BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
666 1.1.1.7 christos BufferLengthOp->Asl.AmlOpcode = AML_DWORD_OP;
667 1.1 jruoho BufferLengthOp->Asl.Value.Integer = BufferLength;
668 1.1 jruoho
669 1.1 jruoho (void) OpcSetOptimalIntegerSize (BufferLengthOp);
670 1.1 jruoho
671 1.1 jruoho /* Remaining nodes are handled via the tree walk */
672 1.1 jruoho }
673 1.1 jruoho
674 1.1 jruoho
675 1.1 jruoho /*******************************************************************************
676 1.1 jruoho *
677 1.1 jruoho * FUNCTION: OpnDoPackage
678 1.1 jruoho *
679 1.1 jruoho * PARAMETERS: Op - The parent parse node
680 1.1 jruoho *
681 1.1 jruoho * RETURN: None
682 1.1 jruoho *
683 1.1.1.3 christos * DESCRIPTION: Construct the AML operands for the PACKAGE ASL keyword. NOTE:
684 1.1 jruoho * can only be called after constants have been folded, to ensure
685 1.1 jruoho * that the PackageLength operand has been fully reduced.
686 1.1 jruoho *
687 1.1 jruoho ******************************************************************************/
688 1.1 jruoho
689 1.1 jruoho void
690 1.1 jruoho OpnDoPackage (
691 1.1 jruoho ACPI_PARSE_OBJECT *Op)
692 1.1 jruoho {
693 1.1 jruoho ACPI_PARSE_OBJECT *InitializerOp;
694 1.1 jruoho ACPI_PARSE_OBJECT *PackageLengthOp;
695 1.1 jruoho UINT32 PackageLength = 0;
696 1.1 jruoho
697 1.1 jruoho
698 1.1 jruoho /* Opcode and package length first, followed by the initializer list */
699 1.1 jruoho
700 1.1 jruoho PackageLengthOp = Op->Asl.Child;
701 1.1 jruoho InitializerOp = PackageLengthOp->Asl.Next;
702 1.1 jruoho
703 1.1 jruoho /* Count the number of items in the initializer list */
704 1.1 jruoho
705 1.1 jruoho if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
706 1.1 jruoho {
707 1.1 jruoho /* The peer list contains the byte list (if any...) */
708 1.1 jruoho
709 1.1 jruoho while (InitializerOp)
710 1.1 jruoho {
711 1.1 jruoho PackageLength++;
712 1.1 jruoho InitializerOp = InitializerOp->Asl.Next;
713 1.1 jruoho }
714 1.1 jruoho }
715 1.1 jruoho
716 1.1 jruoho /* If package length is a constant, compare to the initializer list */
717 1.1 jruoho
718 1.1 jruoho if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) ||
719 1.1 jruoho (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST))
720 1.1 jruoho {
721 1.1 jruoho if (PackageLengthOp->Asl.Value.Integer > PackageLength)
722 1.1 jruoho {
723 1.1 jruoho /*
724 1.1 jruoho * Allow package length to be longer than the initializer
725 1.1 jruoho * list -- but if the length of initializer list is nonzero,
726 1.1 jruoho * issue a message since this is probably a coding error,
727 1.1 jruoho * even though technically legal.
728 1.1 jruoho */
729 1.1 jruoho if (PackageLength > 0)
730 1.1 jruoho {
731 1.1 jruoho AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT,
732 1.1 jruoho PackageLengthOp, NULL);
733 1.1 jruoho }
734 1.1 jruoho
735 1.1 jruoho PackageLength = (UINT32) PackageLengthOp->Asl.Value.Integer;
736 1.1 jruoho }
737 1.1 jruoho else if (PackageLengthOp->Asl.Value.Integer < PackageLength)
738 1.1 jruoho {
739 1.1 jruoho /*
740 1.1 jruoho * The package length is smaller than the length of the
741 1.1 jruoho * initializer list. This is an error as per the ACPI spec.
742 1.1 jruoho */
743 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG,
744 1.1 jruoho PackageLengthOp, NULL);
745 1.1 jruoho }
746 1.1 jruoho }
747 1.1 jruoho
748 1.1 jruoho if (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
749 1.1 jruoho {
750 1.1 jruoho /*
751 1.1 jruoho * This is the case if the PackageLength was left empty - Package()
752 1.1 jruoho * The package length becomes the length of the initializer list
753 1.1 jruoho */
754 1.1 jruoho Op->Asl.Child->Asl.ParseOpcode = PARSEOP_INTEGER;
755 1.1 jruoho Op->Asl.Child->Asl.Value.Integer = PackageLength;
756 1.1 jruoho
757 1.1 jruoho /* Set the AML opcode */
758 1.1 jruoho
759 1.1 jruoho (void) OpcSetOptimalIntegerSize (Op->Asl.Child);
760 1.1 jruoho }
761 1.1 jruoho
762 1.1 jruoho /* If not a variable-length package, check for a zero package length */
763 1.1 jruoho
764 1.1 jruoho if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) ||
765 1.1 jruoho (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST) ||
766 1.1.1.3 christos (PackageLengthOp->Asl.ParseOpcode == PARSEOP_ZERO) ||
767 1.1 jruoho (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG))
768 1.1 jruoho {
769 1.1 jruoho if (!PackageLength)
770 1.1 jruoho {
771 1.1 jruoho /* No length AND no initializer list -- issue a remark */
772 1.1 jruoho
773 1.1 jruoho AslError (ASL_REMARK, ASL_MSG_PACKAGE_LENGTH,
774 1.1 jruoho PackageLengthOp, NULL);
775 1.1 jruoho
776 1.1 jruoho /* But go ahead and put the buffer length of zero into the AML */
777 1.1 jruoho }
778 1.1 jruoho }
779 1.1 jruoho
780 1.1 jruoho /*
781 1.1 jruoho * If the PackageLength is a constant <= 255, we can change the
782 1.1 jruoho * AML opcode from VarPackage to a simple (ACPI 1.0) Package opcode.
783 1.1 jruoho */
784 1.1.1.3 christos if (((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
785 1.1.1.3 christos (Op->Asl.Child->Asl.Value.Integer <= 255)) ||
786 1.1.1.3 christos (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONE) ||
787 1.1.1.3 christos (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONES)||
788 1.1.1.3 christos (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ZERO))
789 1.1 jruoho {
790 1.1 jruoho Op->Asl.AmlOpcode = AML_PACKAGE_OP;
791 1.1 jruoho Op->Asl.ParseOpcode = PARSEOP_PACKAGE;
792 1.1 jruoho
793 1.1 jruoho /*
794 1.1 jruoho * Just set the package size node to be the package length, regardless
795 1.1 jruoho * of whether it was previously an integer or a default_arg placeholder
796 1.1 jruoho */
797 1.1 jruoho PackageLengthOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
798 1.1 jruoho PackageLengthOp->Asl.AmlLength = 1;
799 1.1 jruoho PackageLengthOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
800 1.1 jruoho PackageLengthOp->Asl.Value.Integer = PackageLength;
801 1.1 jruoho }
802 1.1 jruoho
803 1.1 jruoho /* Remaining nodes are handled via the tree walk */
804 1.1 jruoho }
805 1.1 jruoho
806 1.1 jruoho
807 1.1 jruoho /*******************************************************************************
808 1.1 jruoho *
809 1.1 jruoho * FUNCTION: OpnDoLoadTable
810 1.1 jruoho *
811 1.1 jruoho * PARAMETERS: Op - The parent parse node
812 1.1 jruoho *
813 1.1 jruoho * RETURN: None
814 1.1 jruoho *
815 1.1 jruoho * DESCRIPTION: Construct the AML operands for the LOADTABLE ASL keyword.
816 1.1 jruoho *
817 1.1 jruoho ******************************************************************************/
818 1.1 jruoho
819 1.1 jruoho static void
820 1.1 jruoho OpnDoLoadTable (
821 1.1 jruoho ACPI_PARSE_OBJECT *Op)
822 1.1 jruoho {
823 1.1 jruoho ACPI_PARSE_OBJECT *Next;
824 1.1 jruoho
825 1.1 jruoho
826 1.1 jruoho /* Opcode is parent node */
827 1.1 jruoho /* First child is the table signature */
828 1.1 jruoho
829 1.1 jruoho Next = Op->Asl.Child;
830 1.1 jruoho
831 1.1 jruoho /* Second child is the OEM ID*/
832 1.1 jruoho
833 1.1 jruoho Next = Next->Asl.Next;
834 1.1 jruoho
835 1.1 jruoho /* Third child is the OEM table ID */
836 1.1 jruoho
837 1.1 jruoho Next = Next->Asl.Next;
838 1.1 jruoho
839 1.1 jruoho /* Fourth child is the RootPath string */
840 1.1 jruoho
841 1.1 jruoho Next = Next->Asl.Next;
842 1.1 jruoho if (Next->Asl.ParseOpcode == PARSEOP_ZERO)
843 1.1 jruoho {
844 1.1.1.7 christos Next->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
845 1.1.1.7 christos Next->Asl.Value.String = "\\";
846 1.1.1.7 christos Next->Asl.AmlLength = 2;
847 1.1 jruoho OpcGenerateAmlOpcode (Next);
848 1.1 jruoho }
849 1.1 jruoho
850 1.1 jruoho #ifdef ASL_FUTURE_IMPLEMENTATION
851 1.1 jruoho
852 1.1 jruoho /* TBD: NOT IMPLEMENTED */
853 1.1 jruoho /* Fifth child is the [optional] ParameterPathString */
854 1.1 jruoho /* Sixth child is the [optional] ParameterData */
855 1.1 jruoho
856 1.1 jruoho Next = Next->Asl.Next;
857 1.1 jruoho if (Next->Asl.ParseOpcode == DEFAULT_ARG)
858 1.1 jruoho {
859 1.1 jruoho Next->Asl.AmlLength = 1;
860 1.1 jruoho Next->Asl.ParseOpcode = ZERO;
861 1.1 jruoho OpcGenerateAmlOpcode (Next);
862 1.1 jruoho }
863 1.1 jruoho
864 1.1 jruoho
865 1.1 jruoho Next = Next->Asl.Next;
866 1.1 jruoho if (Next->Asl.ParseOpcode == DEFAULT_ARG)
867 1.1 jruoho {
868 1.1 jruoho Next->Asl.AmlLength = 1;
869 1.1 jruoho Next->Asl.ParseOpcode = ZERO;
870 1.1 jruoho OpcGenerateAmlOpcode (Next);
871 1.1 jruoho }
872 1.1 jruoho #endif
873 1.1 jruoho }
874 1.1 jruoho
875 1.1 jruoho
876 1.1 jruoho /*******************************************************************************
877 1.1 jruoho *
878 1.1 jruoho * FUNCTION: OpnDoDefinitionBlock
879 1.1 jruoho *
880 1.1 jruoho * PARAMETERS: Op - The parent parse node
881 1.1 jruoho *
882 1.1 jruoho * RETURN: None
883 1.1 jruoho *
884 1.1 jruoho * DESCRIPTION: Construct the AML operands for the DEFINITIONBLOCK ASL keyword
885 1.1 jruoho *
886 1.1 jruoho ******************************************************************************/
887 1.1 jruoho
888 1.1 jruoho static void
889 1.1 jruoho OpnDoDefinitionBlock (
890 1.1 jruoho ACPI_PARSE_OBJECT *Op)
891 1.1 jruoho {
892 1.1 jruoho ACPI_PARSE_OBJECT *Child;
893 1.1 jruoho ACPI_SIZE Length;
894 1.1 jruoho UINT32 i;
895 1.1 jruoho char *Filename;
896 1.1 jruoho
897 1.1 jruoho
898 1.1 jruoho /*
899 1.1.1.3 christos * These nodes get stuffed into the table header. They are special
900 1.1 jruoho * cased when the table is written to the output file.
901 1.1 jruoho *
902 1.1 jruoho * Mark all of these nodes as non-usable so they won't get output
903 1.1 jruoho * as AML opcodes!
904 1.1 jruoho */
905 1.1 jruoho
906 1.1 jruoho /* Get AML filename. Use it if non-null */
907 1.1 jruoho
908 1.1 jruoho Child = Op->Asl.Child;
909 1.1 jruoho if (Child->Asl.Value.Buffer &&
910 1.1 jruoho *Child->Asl.Value.Buffer &&
911 1.1 jruoho (Gbl_UseDefaultAmlFilename))
912 1.1 jruoho {
913 1.1 jruoho /*
914 1.1 jruoho * We will use the AML filename that is embedded in the source file
915 1.1 jruoho * for the output filename.
916 1.1 jruoho */
917 1.1.1.4 christos Filename = UtStringCacheCalloc (strlen (Gbl_DirectoryPath) +
918 1.1.1.4 christos strlen ((char *) Child->Asl.Value.Buffer) + 1);
919 1.1 jruoho
920 1.1 jruoho /* Prepend the current directory path */
921 1.1 jruoho
922 1.1 jruoho strcpy (Filename, Gbl_DirectoryPath);
923 1.1 jruoho strcat (Filename, (char *) Child->Asl.Value.Buffer);
924 1.1 jruoho
925 1.1 jruoho Gbl_OutputFilenamePrefix = Filename;
926 1.1.1.3 christos UtConvertBackslashes (Gbl_OutputFilenamePrefix);
927 1.1 jruoho }
928 1.1.1.7 christos
929 1.1 jruoho Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
930 1.1 jruoho
931 1.1 jruoho /* Signature */
932 1.1 jruoho
933 1.1 jruoho Child = Child->Asl.Next;
934 1.1 jruoho Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
935 1.1 jruoho if (Child->Asl.Value.String)
936 1.1 jruoho {
937 1.1 jruoho Gbl_TableSignature = Child->Asl.Value.String;
938 1.1.1.7 christos if (strlen (Gbl_TableSignature) != ACPI_NAME_SIZE)
939 1.1 jruoho {
940 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
941 1.1.1.7 christos "Length is not exactly 4");
942 1.1 jruoho }
943 1.1 jruoho
944 1.1.1.7 christos for (i = 0; i < ACPI_NAME_SIZE; i++)
945 1.1 jruoho {
946 1.1 jruoho if (!isalnum ((int) Gbl_TableSignature[i]))
947 1.1 jruoho {
948 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
949 1.1 jruoho "Contains non-alphanumeric characters");
950 1.1 jruoho }
951 1.1 jruoho }
952 1.1 jruoho }
953 1.1 jruoho
954 1.1 jruoho /* Revision */
955 1.1 jruoho
956 1.1 jruoho Child = Child->Asl.Next;
957 1.1 jruoho Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
958 1.1 jruoho /*
959 1.1 jruoho * We used the revision to set the integer width earlier
960 1.1 jruoho */
961 1.1 jruoho
962 1.1 jruoho /* OEMID */
963 1.1 jruoho
964 1.1 jruoho Child = Child->Asl.Next;
965 1.1 jruoho Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
966 1.1 jruoho
967 1.1 jruoho /* OEM TableID */
968 1.1 jruoho
969 1.1 jruoho Child = Child->Asl.Next;
970 1.1 jruoho Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
971 1.1 jruoho if (Child->Asl.Value.String)
972 1.1 jruoho {
973 1.1.1.6 christos Length = strlen (Child->Asl.Value.String);
974 1.1.1.4 christos Gbl_TableId = UtStringCacheCalloc (Length + 1);
975 1.1.1.6 christos strcpy (Gbl_TableId, Child->Asl.Value.String);
976 1.1 jruoho
977 1.1.1.3 christos /*
978 1.1.1.3 christos * Convert anything non-alphanumeric to an underscore. This
979 1.1.1.3 christos * allows us to use the TableID to generate unique C symbols.
980 1.1.1.3 christos */
981 1.1 jruoho for (i = 0; i < Length; i++)
982 1.1 jruoho {
983 1.1.1.3 christos if (!isalnum ((int) Gbl_TableId[i]))
984 1.1 jruoho {
985 1.1.1.3 christos Gbl_TableId[i] = '_';
986 1.1 jruoho }
987 1.1 jruoho }
988 1.1 jruoho }
989 1.1 jruoho
990 1.1 jruoho /* OEM Revision */
991 1.1 jruoho
992 1.1 jruoho Child = Child->Asl.Next;
993 1.1 jruoho Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
994 1.1 jruoho }
995 1.1 jruoho
996 1.1 jruoho
997 1.1 jruoho /*******************************************************************************
998 1.1 jruoho *
999 1.1 jruoho * FUNCTION: UtGetArg
1000 1.1 jruoho *
1001 1.1 jruoho * PARAMETERS: Op - Get an argument for this op
1002 1.1 jruoho * Argn - Nth argument to get
1003 1.1 jruoho *
1004 1.1.1.3 christos * RETURN: The argument (as an Op object). NULL if argument does not exist
1005 1.1 jruoho *
1006 1.1 jruoho * DESCRIPTION: Get the specified op's argument (peer)
1007 1.1 jruoho *
1008 1.1 jruoho ******************************************************************************/
1009 1.1 jruoho
1010 1.1 jruoho ACPI_PARSE_OBJECT *
1011 1.1 jruoho UtGetArg (
1012 1.1 jruoho ACPI_PARSE_OBJECT *Op,
1013 1.1 jruoho UINT32 Argn)
1014 1.1 jruoho {
1015 1.1 jruoho ACPI_PARSE_OBJECT *Arg = NULL;
1016 1.1 jruoho
1017 1.1 jruoho
1018 1.1 jruoho /* Get the requested argument object */
1019 1.1 jruoho
1020 1.1 jruoho Arg = Op->Asl.Child;
1021 1.1 jruoho while (Arg && Argn)
1022 1.1 jruoho {
1023 1.1 jruoho Argn--;
1024 1.1 jruoho Arg = Arg->Asl.Next;
1025 1.1 jruoho }
1026 1.1 jruoho
1027 1.1 jruoho return (Arg);
1028 1.1 jruoho }
1029 1.1 jruoho
1030 1.1 jruoho
1031 1.1 jruoho /*******************************************************************************
1032 1.1 jruoho *
1033 1.1 jruoho * FUNCTION: OpnAttachNameToNode
1034 1.1 jruoho *
1035 1.1 jruoho * PARAMETERS: Op - The parent parse node
1036 1.1 jruoho *
1037 1.1 jruoho * RETURN: None
1038 1.1 jruoho *
1039 1.1 jruoho * DESCRIPTION: For the named ASL/AML operators, get the actual name from the
1040 1.1 jruoho * argument list and attach it to the parent node so that we
1041 1.1 jruoho * can get to it quickly later.
1042 1.1 jruoho *
1043 1.1 jruoho ******************************************************************************/
1044 1.1 jruoho
1045 1.1 jruoho static void
1046 1.1 jruoho OpnAttachNameToNode (
1047 1.1 jruoho ACPI_PARSE_OBJECT *Op)
1048 1.1 jruoho {
1049 1.1 jruoho ACPI_PARSE_OBJECT *Child = NULL;
1050 1.1 jruoho
1051 1.1 jruoho
1052 1.1.1.8 christos switch (Op->Asl.AmlOpcode)
1053 1.1 jruoho {
1054 1.1 jruoho case AML_DATA_REGION_OP:
1055 1.1 jruoho case AML_DEVICE_OP:
1056 1.1 jruoho case AML_EVENT_OP:
1057 1.1.1.8 christos case AML_EXTERNAL_OP:
1058 1.1 jruoho case AML_METHOD_OP:
1059 1.1 jruoho case AML_MUTEX_OP:
1060 1.1 jruoho case AML_REGION_OP:
1061 1.1 jruoho case AML_POWER_RES_OP:
1062 1.1 jruoho case AML_PROCESSOR_OP:
1063 1.1 jruoho case AML_THERMAL_ZONE_OP:
1064 1.1 jruoho case AML_NAME_OP:
1065 1.1 jruoho case AML_SCOPE_OP:
1066 1.1 jruoho
1067 1.1 jruoho Child = UtGetArg (Op, 0);
1068 1.1 jruoho break;
1069 1.1 jruoho
1070 1.1 jruoho case AML_ALIAS_OP:
1071 1.1 jruoho
1072 1.1 jruoho Child = UtGetArg (Op, 1);
1073 1.1 jruoho break;
1074 1.1 jruoho
1075 1.1 jruoho case AML_CREATE_BIT_FIELD_OP:
1076 1.1 jruoho case AML_CREATE_BYTE_FIELD_OP:
1077 1.1 jruoho case AML_CREATE_WORD_FIELD_OP:
1078 1.1 jruoho case AML_CREATE_DWORD_FIELD_OP:
1079 1.1 jruoho case AML_CREATE_QWORD_FIELD_OP:
1080 1.1 jruoho
1081 1.1 jruoho Child = UtGetArg (Op, 2);
1082 1.1 jruoho break;
1083 1.1 jruoho
1084 1.1 jruoho case AML_CREATE_FIELD_OP:
1085 1.1 jruoho
1086 1.1 jruoho Child = UtGetArg (Op, 3);
1087 1.1 jruoho break;
1088 1.1 jruoho
1089 1.1 jruoho case AML_BANK_FIELD_OP:
1090 1.1 jruoho case AML_INDEX_FIELD_OP:
1091 1.1 jruoho case AML_FIELD_OP:
1092 1.1 jruoho
1093 1.1 jruoho return;
1094 1.1 jruoho
1095 1.1 jruoho default:
1096 1.1.1.3 christos
1097 1.1 jruoho return;
1098 1.1 jruoho }
1099 1.1 jruoho
1100 1.1 jruoho if (Child)
1101 1.1 jruoho {
1102 1.1 jruoho UtAttachNamepathToOwner (Op, Child);
1103 1.1 jruoho }
1104 1.1 jruoho }
1105 1.1 jruoho
1106 1.1 jruoho
1107 1.1 jruoho /*******************************************************************************
1108 1.1 jruoho *
1109 1.1 jruoho * FUNCTION: OpnGenerateAmlOperands
1110 1.1 jruoho *
1111 1.1 jruoho * PARAMETERS: Op - The parent parse node
1112 1.1 jruoho *
1113 1.1 jruoho * RETURN: None
1114 1.1 jruoho *
1115 1.1.1.3 christos * DESCRIPTION: Prepare nodes to be output as AML data and operands. The more
1116 1.1 jruoho * complex AML opcodes require processing of the child nodes
1117 1.1 jruoho * (arguments/operands).
1118 1.1 jruoho *
1119 1.1 jruoho ******************************************************************************/
1120 1.1 jruoho
1121 1.1 jruoho void
1122 1.1 jruoho OpnGenerateAmlOperands (
1123 1.1 jruoho ACPI_PARSE_OBJECT *Op)
1124 1.1 jruoho {
1125 1.1 jruoho
1126 1.1 jruoho
1127 1.1 jruoho if (Op->Asl.AmlOpcode == AML_RAW_DATA_BYTE)
1128 1.1 jruoho {
1129 1.1 jruoho return;
1130 1.1 jruoho }
1131 1.1 jruoho
1132 1.1 jruoho switch (Op->Asl.ParseOpcode)
1133 1.1 jruoho {
1134 1.1.1.7 christos case PARSEOP_DEFINITION_BLOCK:
1135 1.1.1.3 christos
1136 1.1 jruoho OpnDoDefinitionBlock (Op);
1137 1.1 jruoho break;
1138 1.1 jruoho
1139 1.1 jruoho case PARSEOP_METHOD:
1140 1.1.1.3 christos
1141 1.1 jruoho OpnDoMethod (Op);
1142 1.1 jruoho break;
1143 1.1 jruoho
1144 1.1 jruoho case PARSEOP_MUTEX:
1145 1.1.1.3 christos
1146 1.1 jruoho OpnDoMutex (Op);
1147 1.1 jruoho break;
1148 1.1 jruoho
1149 1.1 jruoho case PARSEOP_FIELD:
1150 1.1.1.3 christos
1151 1.1 jruoho OpnDoField (Op);
1152 1.1 jruoho break;
1153 1.1 jruoho
1154 1.1 jruoho case PARSEOP_INDEXFIELD:
1155 1.1.1.3 christos
1156 1.1 jruoho OpnDoIndexField (Op);
1157 1.1 jruoho break;
1158 1.1 jruoho
1159 1.1 jruoho case PARSEOP_BANKFIELD:
1160 1.1.1.3 christos
1161 1.1 jruoho OpnDoBankField (Op);
1162 1.1 jruoho break;
1163 1.1 jruoho
1164 1.1 jruoho case PARSEOP_BUFFER:
1165 1.1.1.3 christos
1166 1.1 jruoho OpnDoBuffer (Op);
1167 1.1 jruoho break;
1168 1.1 jruoho
1169 1.1 jruoho case PARSEOP_LOADTABLE:
1170 1.1.1.3 christos
1171 1.1 jruoho OpnDoLoadTable (Op);
1172 1.1 jruoho break;
1173 1.1 jruoho
1174 1.1 jruoho case PARSEOP_OPERATIONREGION:
1175 1.1.1.3 christos
1176 1.1 jruoho OpnDoRegion (Op);
1177 1.1 jruoho break;
1178 1.1 jruoho
1179 1.1 jruoho case PARSEOP_RESOURCETEMPLATE:
1180 1.1.1.3 christos
1181 1.1 jruoho RsDoResourceTemplate (Op);
1182 1.1 jruoho break;
1183 1.1 jruoho
1184 1.1 jruoho case PARSEOP_NAMESEG:
1185 1.1 jruoho case PARSEOP_NAMESTRING:
1186 1.1 jruoho case PARSEOP_METHODCALL:
1187 1.1 jruoho case PARSEOP_STRING_LITERAL:
1188 1.1 jruoho default:
1189 1.1.1.3 christos
1190 1.1 jruoho break;
1191 1.1 jruoho }
1192 1.1 jruoho
1193 1.1 jruoho /* TBD: move */
1194 1.1 jruoho
1195 1.1 jruoho OpnAttachNameToNode (Op);
1196 1.1 jruoho }
1197