Rev 1498 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1498 | serge | 1 | /****************************************************************************** |
2 | * |
||
2216 | Serge | 3 | * Module Name: dswload - Dispatcher first pass namespace load callbacks |
1498 | serge | 4 | * |
5 | *****************************************************************************/ |
||
6 | |||
7 | /****************************************************************************** |
||
8 | * |
||
9 | * 1. Copyright Notice |
||
10 | * |
||
2216 | Serge | 11 | * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp. |
1498 | serge | 12 | * All rights reserved. |
13 | * |
||
14 | * 2. License |
||
15 | * |
||
16 | * 2.1. This is your license from Intel Corp. under its intellectual property |
||
17 | * rights. You may have additional license terms from the party that provided |
||
18 | * you this software, covering your right to use that party's intellectual |
||
19 | * property rights. |
||
20 | * |
||
21 | * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
||
22 | * copy of the source code appearing in this file ("Covered Code") an |
||
23 | * irrevocable, perpetual, worldwide license under Intel's copyrights in the |
||
24 | * base code distributed originally by Intel ("Original Intel Code") to copy, |
||
25 | * make derivatives, distribute, use and display any portion of the Covered |
||
26 | * Code in any form, with the right to sublicense such rights; and |
||
27 | * |
||
28 | * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
||
29 | * license (with the right to sublicense), under only those claims of Intel |
||
30 | * patents that are infringed by the Original Intel Code, to make, use, sell, |
||
31 | * offer to sell, and import the Covered Code and derivative works thereof |
||
32 | * solely to the minimum extent necessary to exercise the above copyright |
||
33 | * license, and in no event shall the patent license extend to any additions |
||
34 | * to or modifications of the Original Intel Code. No other license or right |
||
35 | * is granted directly or by implication, estoppel or otherwise; |
||
36 | * |
||
37 | * The above copyright and patent license is granted only if the following |
||
38 | * conditions are met: |
||
39 | * |
||
40 | * 3. Conditions |
||
41 | * |
||
42 | * 3.1. Redistribution of Source with Rights to Further Distribute Source. |
||
43 | * Redistribution of source code of any substantial portion of the Covered |
||
44 | * Code or modification with rights to further distribute source must include |
||
45 | * the above Copyright Notice, the above License, this list of Conditions, |
||
46 | * and the following Disclaimer and Export Compliance provision. In addition, |
||
47 | * Licensee must cause all Covered Code to which Licensee contributes to |
||
48 | * contain a file documenting the changes Licensee made to create that Covered |
||
49 | * Code and the date of any change. Licensee must include in that file the |
||
50 | * documentation of any changes made by any predecessor Licensee. Licensee |
||
51 | * must include a prominent statement that the modification is derived, |
||
52 | * directly or indirectly, from Original Intel Code. |
||
53 | * |
||
54 | * 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
||
55 | * Redistribution of source code of any substantial portion of the Covered |
||
56 | * Code or modification without rights to further distribute source must |
||
57 | * include the following Disclaimer and Export Compliance provision in the |
||
58 | * documentation and/or other materials provided with distribution. In |
||
59 | * addition, Licensee may not authorize further sublicense of source of any |
||
60 | * portion of the Covered Code, and must include terms to the effect that the |
||
61 | * license from Licensee to its licensee is limited to the intellectual |
||
62 | * property embodied in the software Licensee provides to its licensee, and |
||
63 | * not to intellectual property embodied in modifications its licensee may |
||
64 | * make. |
||
65 | * |
||
66 | * 3.3. Redistribution of Executable. Redistribution in executable form of any |
||
67 | * substantial portion of the Covered Code or modification must reproduce the |
||
68 | * above Copyright Notice, and the following Disclaimer and Export Compliance |
||
69 | * provision in the documentation and/or other materials provided with the |
||
70 | * distribution. |
||
71 | * |
||
72 | * 3.4. Intel retains all right, title, and interest in and to the Original |
||
73 | * Intel Code. |
||
74 | * |
||
75 | * 3.5. Neither the name Intel nor any other trademark owned or controlled by |
||
76 | * Intel shall be used in advertising or otherwise to promote the sale, use or |
||
77 | * other dealings in products derived from or relating to the Covered Code |
||
78 | * without prior written authorization from Intel. |
||
79 | * |
||
80 | * 4. Disclaimer and Export Compliance |
||
81 | * |
||
82 | * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
||
83 | * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
||
84 | * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
||
85 | * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
||
86 | * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
||
87 | * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
||
88 | * PARTICULAR PURPOSE. |
||
89 | * |
||
90 | * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
||
91 | * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
||
92 | * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
||
93 | * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
||
94 | * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
||
95 | * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
||
96 | * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
||
97 | * LIMITED REMEDY. |
||
98 | * |
||
99 | * 4.3. Licensee shall not export, either directly or indirectly, any of this |
||
100 | * software or system incorporating such software without first obtaining any |
||
101 | * required license or other approval from the U. S. Department of Commerce or |
||
102 | * any other agency or department of the United States Government. In the |
||
103 | * event Licensee exports any such software from the United States or |
||
104 | * re-exports any such software from a foreign destination, Licensee shall |
||
105 | * ensure that the distribution and export/re-export of the software is in |
||
106 | * compliance with all laws, regulations, orders, or other restrictions of the |
||
107 | * U.S. Export Administration Regulations. Licensee agrees that neither it nor |
||
108 | * any of its subsidiaries will export/re-export any technical data, process, |
||
109 | * software, or service, directly or indirectly, to any country for which the |
||
110 | * United States government or any agency thereof requires an export license, |
||
111 | * other governmental approval, or letter of assurance, without first obtaining |
||
112 | * such license, approval or letter. |
||
113 | * |
||
114 | *****************************************************************************/ |
||
115 | |||
116 | #define __DSWLOAD_C__ |
||
117 | |||
118 | #include "acpi.h" |
||
119 | #include "accommon.h" |
||
120 | #include "acparser.h" |
||
121 | #include "amlcode.h" |
||
122 | #include "acdispat.h" |
||
123 | #include "acinterp.h" |
||
124 | #include "acnamesp.h" |
||
125 | |||
126 | #ifdef ACPI_ASL_COMPILER |
||
127 | #include "acdisasm.h" |
||
128 | #endif |
||
129 | |||
130 | #define _COMPONENT ACPI_DISPATCHER |
||
131 | ACPI_MODULE_NAME ("dswload") |
||
132 | |||
133 | |||
134 | /******************************************************************************* |
||
135 | * |
||
136 | * FUNCTION: AcpiDsInitCallbacks |
||
137 | * |
||
138 | * PARAMETERS: WalkState - Current state of the parse tree walk |
||
139 | * PassNumber - 1, 2, or 3 |
||
140 | * |
||
141 | * RETURN: Status |
||
142 | * |
||
143 | * DESCRIPTION: Init walk state callbacks |
||
144 | * |
||
145 | ******************************************************************************/ |
||
146 | |||
147 | ACPI_STATUS |
||
148 | AcpiDsInitCallbacks ( |
||
149 | ACPI_WALK_STATE *WalkState, |
||
150 | UINT32 PassNumber) |
||
151 | { |
||
152 | |||
153 | switch (PassNumber) |
||
154 | { |
||
155 | case 1: |
||
156 | WalkState->ParseFlags = ACPI_PARSE_LOAD_PASS1 | |
||
157 | ACPI_PARSE_DELETE_TREE; |
||
158 | WalkState->DescendingCallback = AcpiDsLoad1BeginOp; |
||
159 | WalkState->AscendingCallback = AcpiDsLoad1EndOp; |
||
160 | break; |
||
161 | |||
162 | case 2: |
||
163 | WalkState->ParseFlags = ACPI_PARSE_LOAD_PASS1 | |
||
164 | ACPI_PARSE_DELETE_TREE; |
||
165 | WalkState->DescendingCallback = AcpiDsLoad2BeginOp; |
||
166 | WalkState->AscendingCallback = AcpiDsLoad2EndOp; |
||
167 | break; |
||
168 | |||
169 | case 3: |
||
170 | #ifndef ACPI_NO_METHOD_EXECUTION |
||
171 | WalkState->ParseFlags |= ACPI_PARSE_EXECUTE | |
||
172 | ACPI_PARSE_DELETE_TREE; |
||
173 | WalkState->DescendingCallback = AcpiDsExecBeginOp; |
||
174 | WalkState->AscendingCallback = AcpiDsExecEndOp; |
||
175 | #endif |
||
176 | break; |
||
177 | |||
178 | default: |
||
179 | return (AE_BAD_PARAMETER); |
||
180 | } |
||
181 | |||
182 | return (AE_OK); |
||
183 | } |
||
184 | |||
185 | |||
186 | /******************************************************************************* |
||
187 | * |
||
188 | * FUNCTION: AcpiDsLoad1BeginOp |
||
189 | * |
||
190 | * PARAMETERS: WalkState - Current state of the parse tree walk |
||
191 | * OutOp - Where to return op if a new one is created |
||
192 | * |
||
193 | * RETURN: Status |
||
194 | * |
||
195 | * DESCRIPTION: Descending callback used during the loading of ACPI tables. |
||
196 | * |
||
197 | ******************************************************************************/ |
||
198 | |||
199 | ACPI_STATUS |
||
200 | AcpiDsLoad1BeginOp ( |
||
201 | ACPI_WALK_STATE *WalkState, |
||
202 | ACPI_PARSE_OBJECT **OutOp) |
||
203 | { |
||
204 | ACPI_PARSE_OBJECT *Op; |
||
205 | ACPI_NAMESPACE_NODE *Node; |
||
206 | ACPI_STATUS Status; |
||
207 | ACPI_OBJECT_TYPE ObjectType; |
||
208 | char *Path; |
||
209 | UINT32 Flags; |
||
210 | |||
211 | |||
212 | ACPI_FUNCTION_TRACE (DsLoad1BeginOp); |
||
213 | |||
214 | |||
215 | Op = WalkState->Op; |
||
216 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState)); |
||
217 | |||
218 | /* We are only interested in opcodes that have an associated name */ |
||
219 | |||
220 | if (Op) |
||
221 | { |
||
222 | if (!(WalkState->OpInfo->Flags & AML_NAMED)) |
||
223 | { |
||
224 | *OutOp = Op; |
||
225 | return_ACPI_STATUS (AE_OK); |
||
226 | } |
||
227 | |||
228 | /* Check if this object has already been installed in the namespace */ |
||
229 | |||
230 | if (Op->Common.Node) |
||
231 | { |
||
232 | *OutOp = Op; |
||
233 | return_ACPI_STATUS (AE_OK); |
||
234 | } |
||
235 | } |
||
236 | |||
237 | Path = AcpiPsGetNextNamestring (&WalkState->ParserState); |
||
238 | |||
239 | /* Map the raw opcode into an internal object type */ |
||
240 | |||
241 | ObjectType = WalkState->OpInfo->ObjectType; |
||
242 | |||
243 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
||
244 | "State=%p Op=%p [%s]\n", WalkState, Op, AcpiUtGetTypeName (ObjectType))); |
||
245 | |||
246 | switch (WalkState->Opcode) |
||
247 | { |
||
248 | case AML_SCOPE_OP: |
||
249 | |||
250 | /* |
||
251 | * The target name of the Scope() operator must exist at this point so |
||
252 | * that we can actually open the scope to enter new names underneath it. |
||
253 | * Allow search-to-root for single namesegs. |
||
254 | */ |
||
255 | Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType, |
||
256 | ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState, &(Node)); |
||
257 | #ifdef ACPI_ASL_COMPILER |
||
258 | if (Status == AE_NOT_FOUND) |
||
259 | { |
||
260 | /* |
||
261 | * Table disassembly: |
||
262 | * Target of Scope() not found. Generate an External for it, and |
||
263 | * insert the name into the namespace. |
||
264 | */ |
||
265 | AcpiDmAddToExternalList (Op, Path, ACPI_TYPE_DEVICE, 0); |
||
266 | Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType, |
||
267 | ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT, |
||
268 | WalkState, &Node); |
||
269 | } |
||
270 | #endif |
||
271 | if (ACPI_FAILURE (Status)) |
||
272 | { |
||
273 | ACPI_ERROR_NAMESPACE (Path, Status); |
||
274 | return_ACPI_STATUS (Status); |
||
275 | } |
||
276 | |||
277 | /* |
||
278 | * Check to make sure that the target is |
||
279 | * one of the opcodes that actually opens a scope |
||
280 | */ |
||
281 | switch (Node->Type) |
||
282 | { |
||
283 | case ACPI_TYPE_ANY: |
||
284 | case ACPI_TYPE_LOCAL_SCOPE: /* Scope */ |
||
285 | case ACPI_TYPE_DEVICE: |
||
286 | case ACPI_TYPE_POWER: |
||
287 | case ACPI_TYPE_PROCESSOR: |
||
288 | case ACPI_TYPE_THERMAL: |
||
289 | |||
290 | /* These are acceptable types */ |
||
291 | break; |
||
292 | |||
293 | case ACPI_TYPE_INTEGER: |
||
294 | case ACPI_TYPE_STRING: |
||
295 | case ACPI_TYPE_BUFFER: |
||
296 | |||
297 | /* |
||
298 | * These types we will allow, but we will change the type. |
||
299 | * This enables some existing code of the form: |
||
300 | * |
||
301 | * Name (DEB, 0) |
||
302 | * Scope (DEB) { ... } |
||
303 | * |
||
304 | * Note: silently change the type here. On the second pass, |
||
305 | * we will report a warning |
||
306 | */ |
||
307 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, |
||
308 | "Type override - [%4.4s] had invalid type (%s) " |
||
309 | "for Scope operator, changed to type ANY\n", |
||
310 | AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type))); |
||
311 | |||
312 | Node->Type = ACPI_TYPE_ANY; |
||
313 | WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY; |
||
314 | break; |
||
315 | |||
316 | default: |
||
317 | |||
318 | /* All other types are an error */ |
||
319 | |||
320 | ACPI_ERROR ((AE_INFO, |
||
321 | "Invalid type (%s) for target of " |
||
322 | "Scope operator [%4.4s] (Cannot override)", |
||
323 | AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node))); |
||
324 | |||
325 | return_ACPI_STATUS (AE_AML_OPERAND_TYPE); |
||
326 | } |
||
327 | break; |
||
328 | |||
329 | |||
330 | default: |
||
331 | /* |
||
332 | * For all other named opcodes, we will enter the name into |
||
333 | * the namespace. |
||
334 | * |
||
335 | * Setup the search flags. |
||
336 | * Since we are entering a name into the namespace, we do not want to |
||
337 | * enable the search-to-root upsearch. |
||
338 | * |
||
339 | * There are only two conditions where it is acceptable that the name |
||
340 | * already exists: |
||
341 | * 1) the Scope() operator can reopen a scoping object that was |
||
342 | * previously defined (Scope, Method, Device, etc.) |
||
343 | * 2) Whenever we are parsing a deferred opcode (OpRegion, Buffer, |
||
344 | * BufferField, or Package), the name of the object is already |
||
345 | * in the namespace. |
||
346 | */ |
||
347 | if (WalkState->DeferredNode) |
||
348 | { |
||
349 | /* This name is already in the namespace, get the node */ |
||
350 | |||
351 | Node = WalkState->DeferredNode; |
||
352 | Status = AE_OK; |
||
353 | break; |
||
354 | } |
||
355 | |||
356 | /* |
||
357 | * If we are executing a method, do not create any namespace objects |
||
358 | * during the load phase, only during execution. |
||
359 | */ |
||
360 | if (WalkState->MethodNode) |
||
361 | { |
||
362 | Node = NULL; |
||
363 | Status = AE_OK; |
||
364 | break; |
||
365 | } |
||
366 | |||
367 | Flags = ACPI_NS_NO_UPSEARCH; |
||
368 | if ((WalkState->Opcode != AML_SCOPE_OP) && |
||
369 | (!(WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP))) |
||
370 | { |
||
371 | Flags |= ACPI_NS_ERROR_IF_FOUND; |
||
372 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist\n", |
||
373 | AcpiUtGetTypeName (ObjectType))); |
||
374 | } |
||
375 | else |
||
376 | { |
||
377 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
||
378 | "[%s] Both Find or Create allowed\n", |
||
379 | AcpiUtGetTypeName (ObjectType))); |
||
380 | } |
||
381 | |||
382 | /* |
||
383 | * Enter the named type into the internal namespace. We enter the name |
||
384 | * as we go downward in the parse tree. Any necessary subobjects that |
||
385 | * involve arguments to the opcode must be created as we go back up the |
||
386 | * parse tree later. |
||
387 | */ |
||
388 | Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType, |
||
389 | ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node); |
||
390 | if (ACPI_FAILURE (Status)) |
||
391 | { |
||
392 | if (Status == AE_ALREADY_EXISTS) |
||
393 | { |
||
394 | /* The name already exists in this scope */ |
||
395 | |||
396 | if (Node->Flags & ANOBJ_IS_EXTERNAL) |
||
397 | { |
||
398 | /* |
||
399 | * Allow one create on an object or segment that was |
||
400 | * previously declared External |
||
401 | */ |
||
402 | Node->Flags &= ~ANOBJ_IS_EXTERNAL; |
||
403 | Node->Type = (UINT8) ObjectType; |
||
404 | |||
405 | /* Just retyped a node, probably will need to open a scope */ |
||
406 | |||
407 | if (AcpiNsOpensScope (ObjectType)) |
||
408 | { |
||
409 | Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); |
||
410 | if (ACPI_FAILURE (Status)) |
||
411 | { |
||
412 | return_ACPI_STATUS (Status); |
||
413 | } |
||
414 | } |
||
415 | |||
416 | Status = AE_OK; |
||
417 | } |
||
418 | } |
||
419 | |||
420 | if (ACPI_FAILURE (Status)) |
||
421 | { |
||
422 | ACPI_ERROR_NAMESPACE (Path, Status); |
||
423 | return_ACPI_STATUS (Status); |
||
424 | } |
||
425 | } |
||
426 | break; |
||
427 | } |
||
428 | |||
429 | /* Common exit */ |
||
430 | |||
431 | if (!Op) |
||
432 | { |
||
433 | /* Create a new op */ |
||
434 | |||
435 | Op = AcpiPsAllocOp (WalkState->Opcode); |
||
436 | if (!Op) |
||
437 | { |
||
438 | return_ACPI_STATUS (AE_NO_MEMORY); |
||
439 | } |
||
440 | } |
||
441 | |||
442 | /* Initialize the op */ |
||
443 | |||
444 | #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)) |
||
445 | Op->Named.Path = ACPI_CAST_PTR (UINT8, Path); |
||
446 | #endif |
||
447 | |||
448 | if (Node) |
||
449 | { |
||
450 | /* |
||
451 | * Put the Node in the "op" object that the parser uses, so we |
||
452 | * can get it again quickly when this scope is closed |
||
453 | */ |
||
454 | Op->Common.Node = Node; |
||
455 | Op->Named.Name = Node->Name.Integer; |
||
456 | } |
||
457 | |||
458 | AcpiPsAppendArg (AcpiPsGetParentScope (&WalkState->ParserState), Op); |
||
459 | *OutOp = Op; |
||
460 | return_ACPI_STATUS (Status); |
||
461 | } |
||
462 | |||
463 | |||
464 | /******************************************************************************* |
||
465 | * |
||
466 | * FUNCTION: AcpiDsLoad1EndOp |
||
467 | * |
||
468 | * PARAMETERS: WalkState - Current state of the parse tree walk |
||
469 | * |
||
470 | * RETURN: Status |
||
471 | * |
||
472 | * DESCRIPTION: Ascending callback used during the loading of the namespace, |
||
473 | * both control methods and everything else. |
||
474 | * |
||
475 | ******************************************************************************/ |
||
476 | |||
477 | ACPI_STATUS |
||
478 | AcpiDsLoad1EndOp ( |
||
479 | ACPI_WALK_STATE *WalkState) |
||
480 | { |
||
481 | ACPI_PARSE_OBJECT *Op; |
||
482 | ACPI_OBJECT_TYPE ObjectType; |
||
483 | ACPI_STATUS Status = AE_OK; |
||
484 | |||
485 | |||
486 | ACPI_FUNCTION_TRACE (DsLoad1EndOp); |
||
487 | |||
488 | |||
489 | Op = WalkState->Op; |
||
490 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState)); |
||
491 | |||
492 | /* We are only interested in opcodes that have an associated name */ |
||
493 | |||
494 | if (!(WalkState->OpInfo->Flags & (AML_NAMED | AML_FIELD))) |
||
495 | { |
||
496 | return_ACPI_STATUS (AE_OK); |
||
497 | } |
||
498 | |||
499 | /* Get the object type to determine if we should pop the scope */ |
||
500 | |||
501 | ObjectType = WalkState->OpInfo->ObjectType; |
||
502 | |||
503 | #ifndef ACPI_NO_METHOD_EXECUTION |
||
504 | if (WalkState->OpInfo->Flags & AML_FIELD) |
||
505 | { |
||
506 | /* |
||
507 | * If we are executing a method, do not create any namespace objects |
||
508 | * during the load phase, only during execution. |
||
509 | */ |
||
510 | if (!WalkState->MethodNode) |
||
511 | { |
||
512 | if (WalkState->Opcode == AML_FIELD_OP || |
||
513 | WalkState->Opcode == AML_BANK_FIELD_OP || |
||
514 | WalkState->Opcode == AML_INDEX_FIELD_OP) |
||
515 | { |
||
516 | Status = AcpiDsInitFieldObjects (Op, WalkState); |
||
517 | } |
||
518 | } |
||
519 | return_ACPI_STATUS (Status); |
||
520 | } |
||
521 | |||
522 | /* |
||
523 | * If we are executing a method, do not create any namespace objects |
||
524 | * during the load phase, only during execution. |
||
525 | */ |
||
526 | if (!WalkState->MethodNode) |
||
527 | { |
||
528 | if (Op->Common.AmlOpcode == AML_REGION_OP) |
||
529 | { |
||
530 | Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length, |
||
531 | (ACPI_ADR_SPACE_TYPE) ((Op->Common.Value.Arg)->Common.Value.Integer), |
||
532 | WalkState); |
||
533 | if (ACPI_FAILURE (Status)) |
||
534 | { |
||
535 | return_ACPI_STATUS (Status); |
||
536 | } |
||
537 | } |
||
538 | else if (Op->Common.AmlOpcode == AML_DATA_REGION_OP) |
||
539 | { |
||
540 | Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length, |
||
2216 | Serge | 541 | ACPI_ADR_SPACE_DATA_TABLE, WalkState); |
1498 | serge | 542 | if (ACPI_FAILURE (Status)) |
543 | { |
||
544 | return_ACPI_STATUS (Status); |
||
545 | } |
||
546 | } |
||
547 | } |
||
548 | #endif |
||
549 | |||
550 | if (Op->Common.AmlOpcode == AML_NAME_OP) |
||
551 | { |
||
552 | /* For Name opcode, get the object type from the argument */ |
||
553 | |||
554 | if (Op->Common.Value.Arg) |
||
555 | { |
||
556 | ObjectType = (AcpiPsGetOpcodeInfo ( |
||
557 | (Op->Common.Value.Arg)->Common.AmlOpcode))->ObjectType; |
||
558 | |||
559 | /* Set node type if we have a namespace node */ |
||
560 | |||
561 | if (Op->Common.Node) |
||
562 | { |
||
563 | Op->Common.Node->Type = (UINT8) ObjectType; |
||
564 | } |
||
565 | } |
||
566 | } |
||
567 | |||
568 | /* |
||
569 | * If we are executing a method, do not create any namespace objects |
||
570 | * during the load phase, only during execution. |
||
571 | */ |
||
572 | if (!WalkState->MethodNode) |
||
573 | { |
||
574 | if (Op->Common.AmlOpcode == AML_METHOD_OP) |
||
575 | { |
||
576 | /* |
||
577 | * MethodOp PkgLength NameString MethodFlags TermList |
||
578 | * |
||
579 | * Note: We must create the method node/object pair as soon as we |
||
580 | * see the method declaration. This allows later pass1 parsing |
||
581 | * of invocations of the method (need to know the number of |
||
582 | * arguments.) |
||
583 | */ |
||
584 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
||
585 | "LOADING-Method: State=%p Op=%p NamedObj=%p\n", |
||
586 | WalkState, Op, Op->Named.Node)); |
||
587 | |||
588 | if (!AcpiNsGetAttachedObject (Op->Named.Node)) |
||
589 | { |
||
590 | WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node); |
||
591 | WalkState->NumOperands = 1; |
||
592 | |||
593 | Status = AcpiDsCreateOperands (WalkState, Op->Common.Value.Arg); |
||
594 | if (ACPI_SUCCESS (Status)) |
||
595 | { |
||
596 | Status = AcpiExCreateMethod (Op->Named.Data, |
||
597 | Op->Named.Length, WalkState); |
||
598 | } |
||
599 | |||
600 | WalkState->Operands[0] = NULL; |
||
601 | WalkState->NumOperands = 0; |
||
602 | |||
603 | if (ACPI_FAILURE (Status)) |
||
604 | { |
||
605 | return_ACPI_STATUS (Status); |
||
606 | } |
||
607 | } |
||
608 | } |
||
609 | } |
||
610 | |||
611 | /* Pop the scope stack (only if loading a table) */ |
||
612 | |||
613 | if (!WalkState->MethodNode && |
||
614 | AcpiNsOpensScope (ObjectType)) |
||
615 | { |
||
616 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n", |
||
617 | AcpiUtGetTypeName (ObjectType), Op)); |
||
618 | |||
619 | Status = AcpiDsScopeStackPop (WalkState); |
||
620 | } |
||
621 | |||
622 | return_ACPI_STATUS (Status); |
||
623 | } |