1 | /****************************************************************************** |
2 | * |
3 | * Module Name: dswload2 - Dispatcher second pass namespace load callbacks |
4 | * |
5 | *****************************************************************************/ |
6 | |
7 | /* |
8 | * Copyright (C) 2000 - 2016, Intel Corp. |
9 | * All rights reserved. |
10 | * |
11 | * Redistribution and use in source and binary forms, with or without |
12 | * modification, are permitted provided that the following conditions |
13 | * are met: |
14 | * 1. Redistributions of source code must retain the above copyright |
15 | * notice, this list of conditions, and the following disclaimer, |
16 | * without modification. |
17 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer |
18 | * substantially similar to the "NO WARRANTY" disclaimer below |
19 | * ("Disclaimer") and any redistribution must be conditioned upon |
20 | * including a substantially similar Disclaimer requirement for further |
21 | * binary redistribution. |
22 | * 3. Neither the names of the above-listed copyright holders nor the names |
23 | * of any contributors may be used to endorse or promote products derived |
24 | * from this software without specific prior written permission. |
25 | * |
26 | * Alternatively, this software may be distributed under the terms of the |
27 | * GNU General Public License ("GPL") version 2 as published by the Free |
28 | * Software Foundation. |
29 | * |
30 | * NO WARRANTY |
31 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
32 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
33 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR |
34 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
35 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
36 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
37 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
38 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
39 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING |
40 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
41 | * POSSIBILITY OF SUCH DAMAGES. |
42 | */ |
43 | |
44 | #include "acpi.h" |
45 | #include "accommon.h" |
46 | #include "acparser.h" |
47 | #include "amlcode.h" |
48 | #include "acdispat.h" |
49 | #include "acinterp.h" |
50 | #include "acnamesp.h" |
51 | #include "acevents.h" |
52 | |
53 | #define _COMPONENT ACPI_DISPATCHER |
54 | ACPI_MODULE_NAME ("dswload2" ) |
55 | |
56 | |
57 | /******************************************************************************* |
58 | * |
59 | * FUNCTION: AcpiDsLoad2BeginOp |
60 | * |
61 | * PARAMETERS: WalkState - Current state of the parse tree walk |
62 | * OutOp - Wher to return op if a new one is created |
63 | * |
64 | * RETURN: Status |
65 | * |
66 | * DESCRIPTION: Descending callback used during the loading of ACPI tables. |
67 | * |
68 | ******************************************************************************/ |
69 | |
70 | ACPI_STATUS |
71 | AcpiDsLoad2BeginOp ( |
72 | ACPI_WALK_STATE *WalkState, |
73 | ACPI_PARSE_OBJECT **OutOp) |
74 | { |
75 | ACPI_PARSE_OBJECT *Op; |
76 | ACPI_NAMESPACE_NODE *Node; |
77 | ACPI_STATUS Status; |
78 | ACPI_OBJECT_TYPE ObjectType; |
79 | char *BufferPtr; |
80 | UINT32 Flags; |
81 | |
82 | |
83 | ACPI_FUNCTION_TRACE (DsLoad2BeginOp); |
84 | |
85 | |
86 | Op = WalkState->Op; |
87 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n" , Op, WalkState)); |
88 | |
89 | if (Op) |
90 | { |
91 | if ((WalkState->ControlState) && |
92 | (WalkState->ControlState->Common.State == |
93 | ACPI_CONTROL_CONDITIONAL_EXECUTING)) |
94 | { |
95 | /* We are executing a while loop outside of a method */ |
96 | |
97 | Status = AcpiDsExecBeginOp (WalkState, OutOp); |
98 | return_ACPI_STATUS (Status); |
99 | } |
100 | |
101 | /* We only care about Namespace opcodes here */ |
102 | |
103 | if ((!(WalkState->OpInfo->Flags & AML_NSOPCODE) && |
104 | (WalkState->Opcode != AML_INT_NAMEPATH_OP)) || |
105 | (!(WalkState->OpInfo->Flags & AML_NAMED))) |
106 | { |
107 | return_ACPI_STATUS (AE_OK); |
108 | } |
109 | |
110 | /* Get the name we are going to enter or lookup in the namespace */ |
111 | |
112 | if (WalkState->Opcode == AML_INT_NAMEPATH_OP) |
113 | { |
114 | /* For Namepath op, get the path string */ |
115 | |
116 | BufferPtr = Op->Common.Value.String; |
117 | if (!BufferPtr) |
118 | { |
119 | /* No name, just exit */ |
120 | |
121 | return_ACPI_STATUS (AE_OK); |
122 | } |
123 | } |
124 | else |
125 | { |
126 | /* Get name from the op */ |
127 | |
128 | BufferPtr = ACPI_CAST_PTR (char, &Op->Named.Name); |
129 | } |
130 | } |
131 | else |
132 | { |
133 | /* Get the namestring from the raw AML */ |
134 | |
135 | BufferPtr = AcpiPsGetNextNamestring (&WalkState->ParserState); |
136 | } |
137 | |
138 | /* Map the opcode into an internal object type */ |
139 | |
140 | ObjectType = WalkState->OpInfo->ObjectType; |
141 | |
142 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
143 | "State=%p Op=%p Type=%X\n" , WalkState, Op, ObjectType)); |
144 | |
145 | switch (WalkState->Opcode) |
146 | { |
147 | case AML_FIELD_OP: |
148 | case AML_BANK_FIELD_OP: |
149 | case AML_INDEX_FIELD_OP: |
150 | |
151 | Node = NULL; |
152 | Status = AE_OK; |
153 | break; |
154 | |
155 | case AML_INT_NAMEPATH_OP: |
156 | /* |
157 | * The NamePath is an object reference to an existing object. |
158 | * Don't enter the name into the namespace, but look it up |
159 | * for use later. |
160 | */ |
161 | Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType, |
162 | ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, |
163 | WalkState, &(Node)); |
164 | break; |
165 | |
166 | case AML_SCOPE_OP: |
167 | |
168 | /* Special case for Scope(\) -> refers to the Root node */ |
169 | |
170 | if (Op && (Op->Named.Node == AcpiGbl_RootNode)) |
171 | { |
172 | Node = Op->Named.Node; |
173 | |
174 | Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); |
175 | if (ACPI_FAILURE (Status)) |
176 | { |
177 | return_ACPI_STATUS (Status); |
178 | } |
179 | } |
180 | else |
181 | { |
182 | /* |
183 | * The Path is an object reference to an existing object. |
184 | * Don't enter the name into the namespace, but look it up |
185 | * for use later. |
186 | */ |
187 | Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType, |
188 | ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, |
189 | WalkState, &(Node)); |
190 | if (ACPI_FAILURE (Status)) |
191 | { |
192 | #ifdef ACPI_ASL_COMPILER |
193 | if (Status == AE_NOT_FOUND) |
194 | { |
195 | Status = AE_OK; |
196 | } |
197 | else |
198 | { |
199 | ACPI_ERROR_NAMESPACE (BufferPtr, Status); |
200 | } |
201 | #else |
202 | ACPI_ERROR_NAMESPACE (BufferPtr, Status); |
203 | #endif |
204 | return_ACPI_STATUS (Status); |
205 | } |
206 | } |
207 | |
208 | /* |
209 | * We must check to make sure that the target is |
210 | * one of the opcodes that actually opens a scope |
211 | */ |
212 | switch (Node->Type) |
213 | { |
214 | case ACPI_TYPE_ANY: |
215 | case ACPI_TYPE_LOCAL_SCOPE: /* Scope */ |
216 | case ACPI_TYPE_DEVICE: |
217 | case ACPI_TYPE_POWER: |
218 | case ACPI_TYPE_PROCESSOR: |
219 | case ACPI_TYPE_THERMAL: |
220 | |
221 | /* These are acceptable types */ |
222 | break; |
223 | |
224 | case ACPI_TYPE_INTEGER: |
225 | case ACPI_TYPE_STRING: |
226 | case ACPI_TYPE_BUFFER: |
227 | |
228 | /* |
229 | * These types we will allow, but we will change the type. |
230 | * This enables some existing code of the form: |
231 | * |
232 | * Name (DEB, 0) |
233 | * Scope (DEB) { ... } |
234 | */ |
235 | ACPI_WARNING ((AE_INFO, |
236 | "Type override - [%4.4s] had invalid type (%s) " |
237 | "for Scope operator, changed to type ANY" , |
238 | AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type))); |
239 | |
240 | Node->Type = ACPI_TYPE_ANY; |
241 | WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY; |
242 | break; |
243 | |
244 | case ACPI_TYPE_METHOD: |
245 | |
246 | /* |
247 | * Allow scope change to root during execution of module-level |
248 | * code. Root is typed METHOD during this time. |
249 | */ |
250 | if ((Node == AcpiGbl_RootNode) && |
251 | (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) |
252 | { |
253 | break; |
254 | } |
255 | |
256 | /*lint -fallthrough */ |
257 | |
258 | default: |
259 | |
260 | /* All other types are an error */ |
261 | |
262 | ACPI_ERROR ((AE_INFO, |
263 | "Invalid type (%s) for target of " |
264 | "Scope operator [%4.4s] (Cannot override)" , |
265 | AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node))); |
266 | |
267 | return_ACPI_STATUS (AE_AML_OPERAND_TYPE); |
268 | } |
269 | break; |
270 | |
271 | default: |
272 | |
273 | /* All other opcodes */ |
274 | |
275 | if (Op && Op->Common.Node) |
276 | { |
277 | /* This op/node was previously entered into the namespace */ |
278 | |
279 | Node = Op->Common.Node; |
280 | |
281 | if (AcpiNsOpensScope (ObjectType)) |
282 | { |
283 | Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); |
284 | if (ACPI_FAILURE (Status)) |
285 | { |
286 | return_ACPI_STATUS (Status); |
287 | } |
288 | } |
289 | |
290 | return_ACPI_STATUS (AE_OK); |
291 | } |
292 | |
293 | /* |
294 | * Enter the named type into the internal namespace. We enter the name |
295 | * as we go downward in the parse tree. Any necessary subobjects that |
296 | * involve arguments to the opcode must be created as we go back up the |
297 | * parse tree later. |
298 | * |
299 | * Note: Name may already exist if we are executing a deferred opcode. |
300 | */ |
301 | if (WalkState->DeferredNode) |
302 | { |
303 | /* This name is already in the namespace, get the node */ |
304 | |
305 | Node = WalkState->DeferredNode; |
306 | Status = AE_OK; |
307 | break; |
308 | } |
309 | |
310 | Flags = ACPI_NS_NO_UPSEARCH; |
311 | if (WalkState->PassNumber == ACPI_IMODE_EXECUTE) |
312 | { |
313 | /* Execution mode, node cannot already exist, node is temporary */ |
314 | |
315 | Flags |= ACPI_NS_ERROR_IF_FOUND; |
316 | |
317 | if (!(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) |
318 | { |
319 | Flags |= ACPI_NS_TEMPORARY; |
320 | } |
321 | } |
322 | |
323 | /* Add new entry or lookup existing entry */ |
324 | |
325 | Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType, |
326 | ACPI_IMODE_LOAD_PASS2, Flags, WalkState, &Node); |
327 | |
328 | if (ACPI_SUCCESS (Status) && (Flags & ACPI_NS_TEMPORARY)) |
329 | { |
330 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
331 | "***New Node [%4.4s] %p is temporary\n" , |
332 | AcpiUtGetNodeName (Node), Node)); |
333 | } |
334 | break; |
335 | } |
336 | |
337 | if (ACPI_FAILURE (Status)) |
338 | { |
339 | ACPI_ERROR_NAMESPACE (BufferPtr, Status); |
340 | return_ACPI_STATUS (Status); |
341 | } |
342 | |
343 | if (!Op) |
344 | { |
345 | /* Create a new op */ |
346 | |
347 | Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml); |
348 | if (!Op) |
349 | { |
350 | return_ACPI_STATUS (AE_NO_MEMORY); |
351 | } |
352 | |
353 | /* Initialize the new op */ |
354 | |
355 | if (Node) |
356 | { |
357 | Op->Named.Name = Node->Name.Integer; |
358 | } |
359 | *OutOp = Op; |
360 | } |
361 | |
362 | /* |
363 | * Put the Node in the "op" object that the parser uses, so we |
364 | * can get it again quickly when this scope is closed |
365 | */ |
366 | Op->Common.Node = Node; |
367 | return_ACPI_STATUS (Status); |
368 | } |
369 | |
370 | |
371 | /******************************************************************************* |
372 | * |
373 | * FUNCTION: AcpiDsLoad2EndOp |
374 | * |
375 | * PARAMETERS: WalkState - Current state of the parse tree walk |
376 | * |
377 | * RETURN: Status |
378 | * |
379 | * DESCRIPTION: Ascending callback used during the loading of the namespace, |
380 | * both control methods and everything else. |
381 | * |
382 | ******************************************************************************/ |
383 | |
384 | ACPI_STATUS |
385 | AcpiDsLoad2EndOp ( |
386 | ACPI_WALK_STATE *WalkState) |
387 | { |
388 | ACPI_PARSE_OBJECT *Op; |
389 | ACPI_STATUS Status = AE_OK; |
390 | ACPI_OBJECT_TYPE ObjectType; |
391 | ACPI_NAMESPACE_NODE *Node; |
392 | ACPI_PARSE_OBJECT *Arg; |
393 | ACPI_NAMESPACE_NODE *NewNode; |
394 | #ifndef ACPI_NO_METHOD_EXECUTION |
395 | UINT32 i; |
396 | UINT8 RegionSpace; |
397 | #endif |
398 | |
399 | |
400 | ACPI_FUNCTION_TRACE (DsLoad2EndOp); |
401 | |
402 | Op = WalkState->Op; |
403 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n" , |
404 | WalkState->OpInfo->Name, Op, WalkState)); |
405 | |
406 | /* Check if opcode had an associated namespace object */ |
407 | |
408 | if (!(WalkState->OpInfo->Flags & AML_NSOBJECT)) |
409 | { |
410 | return_ACPI_STATUS (AE_OK); |
411 | } |
412 | |
413 | if (Op->Common.AmlOpcode == AML_SCOPE_OP) |
414 | { |
415 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
416 | "Ending scope Op=%p State=%p\n" , Op, WalkState)); |
417 | } |
418 | |
419 | ObjectType = WalkState->OpInfo->ObjectType; |
420 | |
421 | /* |
422 | * Get the Node/name from the earlier lookup |
423 | * (It was saved in the *op structure) |
424 | */ |
425 | Node = Op->Common.Node; |
426 | |
427 | /* |
428 | * Put the Node on the object stack (Contains the ACPI Name of |
429 | * this object) |
430 | */ |
431 | WalkState->Operands[0] = (void *) Node; |
432 | WalkState->NumOperands = 1; |
433 | |
434 | /* Pop the scope stack */ |
435 | |
436 | if (AcpiNsOpensScope (ObjectType) && |
437 | (Op->Common.AmlOpcode != AML_INT_METHODCALL_OP)) |
438 | { |
439 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n" , |
440 | AcpiUtGetTypeName (ObjectType), Op)); |
441 | |
442 | Status = AcpiDsScopeStackPop (WalkState); |
443 | if (ACPI_FAILURE (Status)) |
444 | { |
445 | goto Cleanup; |
446 | } |
447 | } |
448 | |
449 | /* |
450 | * Named operations are as follows: |
451 | * |
452 | * AML_ALIAS |
453 | * AML_BANKFIELD |
454 | * AML_CREATEBITFIELD |
455 | * AML_CREATEBYTEFIELD |
456 | * AML_CREATEDWORDFIELD |
457 | * AML_CREATEFIELD |
458 | * AML_CREATEQWORDFIELD |
459 | * AML_CREATEWORDFIELD |
460 | * AML_DATA_REGION |
461 | * AML_DEVICE |
462 | * AML_EVENT |
463 | * AML_FIELD |
464 | * AML_INDEXFIELD |
465 | * AML_METHOD |
466 | * AML_METHODCALL |
467 | * AML_MUTEX |
468 | * AML_NAME |
469 | * AML_NAMEDFIELD |
470 | * AML_OPREGION |
471 | * AML_POWERRES |
472 | * AML_PROCESSOR |
473 | * AML_SCOPE |
474 | * AML_THERMALZONE |
475 | */ |
476 | |
477 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
478 | "Create-Load [%s] State=%p Op=%p NamedObj=%p\n" , |
479 | AcpiPsGetOpcodeName (Op->Common.AmlOpcode), WalkState, Op, Node)); |
480 | |
481 | /* Decode the opcode */ |
482 | |
483 | Arg = Op->Common.Value.Arg; |
484 | |
485 | switch (WalkState->OpInfo->Type) |
486 | { |
487 | #ifndef ACPI_NO_METHOD_EXECUTION |
488 | |
489 | case AML_TYPE_CREATE_FIELD: |
490 | /* |
491 | * Create the field object, but the field buffer and index must |
492 | * be evaluated later during the execution phase |
493 | */ |
494 | Status = AcpiDsCreateBufferField (Op, WalkState); |
495 | break; |
496 | |
497 | case AML_TYPE_NAMED_FIELD: |
498 | /* |
499 | * If we are executing a method, initialize the field |
500 | */ |
501 | if (WalkState->MethodNode) |
502 | { |
503 | Status = AcpiDsInitFieldObjects (Op, WalkState); |
504 | } |
505 | |
506 | switch (Op->Common.AmlOpcode) |
507 | { |
508 | case AML_INDEX_FIELD_OP: |
509 | |
510 | Status = AcpiDsCreateIndexField ( |
511 | Op, (ACPI_HANDLE) Arg->Common.Node, WalkState); |
512 | break; |
513 | |
514 | case AML_BANK_FIELD_OP: |
515 | |
516 | Status = AcpiDsCreateBankField (Op, Arg->Common.Node, WalkState); |
517 | break; |
518 | |
519 | case AML_FIELD_OP: |
520 | |
521 | Status = AcpiDsCreateField (Op, Arg->Common.Node, WalkState); |
522 | break; |
523 | |
524 | default: |
525 | |
526 | /* All NAMED_FIELD opcodes must be handled above */ |
527 | break; |
528 | } |
529 | break; |
530 | |
531 | case AML_TYPE_NAMED_SIMPLE: |
532 | |
533 | Status = AcpiDsCreateOperands (WalkState, Arg); |
534 | if (ACPI_FAILURE (Status)) |
535 | { |
536 | goto Cleanup; |
537 | } |
538 | |
539 | switch (Op->Common.AmlOpcode) |
540 | { |
541 | case AML_PROCESSOR_OP: |
542 | |
543 | Status = AcpiExCreateProcessor (WalkState); |
544 | break; |
545 | |
546 | case AML_POWER_RES_OP: |
547 | |
548 | Status = AcpiExCreatePowerResource (WalkState); |
549 | break; |
550 | |
551 | case AML_MUTEX_OP: |
552 | |
553 | Status = AcpiExCreateMutex (WalkState); |
554 | break; |
555 | |
556 | case AML_EVENT_OP: |
557 | |
558 | Status = AcpiExCreateEvent (WalkState); |
559 | break; |
560 | |
561 | case AML_ALIAS_OP: |
562 | |
563 | Status = AcpiExCreateAlias (WalkState); |
564 | break; |
565 | |
566 | default: |
567 | |
568 | /* Unknown opcode */ |
569 | |
570 | Status = AE_OK; |
571 | goto Cleanup; |
572 | } |
573 | |
574 | /* Delete operands */ |
575 | |
576 | for (i = 1; i < WalkState->NumOperands; i++) |
577 | { |
578 | AcpiUtRemoveReference (WalkState->Operands[i]); |
579 | WalkState->Operands[i] = NULL; |
580 | } |
581 | |
582 | break; |
583 | #endif /* ACPI_NO_METHOD_EXECUTION */ |
584 | |
585 | case AML_TYPE_NAMED_COMPLEX: |
586 | |
587 | switch (Op->Common.AmlOpcode) |
588 | { |
589 | #ifndef ACPI_NO_METHOD_EXECUTION |
590 | case AML_REGION_OP: |
591 | case AML_DATA_REGION_OP: |
592 | |
593 | if (Op->Common.AmlOpcode == AML_REGION_OP) |
594 | { |
595 | RegionSpace = (ACPI_ADR_SPACE_TYPE) |
596 | ((Op->Common.Value.Arg)->Common.Value.Integer); |
597 | } |
598 | else |
599 | { |
600 | RegionSpace = ACPI_ADR_SPACE_DATA_TABLE; |
601 | } |
602 | |
603 | /* |
604 | * The OpRegion is not fully parsed at this time. The only valid |
605 | * argument is the SpaceId. (We must save the address of the |
606 | * AML of the address and length operands) |
607 | * |
608 | * If we have a valid region, initialize it. The namespace is |
609 | * unlocked at this point. |
610 | * |
611 | * Need to unlock interpreter if it is locked (if we are running |
612 | * a control method), in order to allow _REG methods to be run |
613 | * during AcpiEvInitializeRegion. |
614 | */ |
615 | if (WalkState->MethodNode) |
616 | { |
617 | /* |
618 | * Executing a method: initialize the region and unlock |
619 | * the interpreter |
620 | */ |
621 | Status = AcpiExCreateRegion (Op->Named.Data, |
622 | Op->Named.Length, RegionSpace, WalkState); |
623 | if (ACPI_FAILURE (Status)) |
624 | { |
625 | return_ACPI_STATUS (Status); |
626 | } |
627 | } |
628 | |
629 | AcpiExExitInterpreter (); |
630 | Status = AcpiEvInitializeRegion ( |
631 | AcpiNsGetAttachedObject (Node), FALSE); |
632 | AcpiExEnterInterpreter (); |
633 | |
634 | if (ACPI_FAILURE (Status)) |
635 | { |
636 | /* |
637 | * If AE_NOT_EXIST is returned, it is not fatal |
638 | * because many regions get created before a handler |
639 | * is installed for said region. |
640 | */ |
641 | if (AE_NOT_EXIST == Status) |
642 | { |
643 | Status = AE_OK; |
644 | } |
645 | } |
646 | break; |
647 | |
648 | case AML_NAME_OP: |
649 | |
650 | Status = AcpiDsCreateNode (WalkState, Node, Op); |
651 | break; |
652 | |
653 | case AML_METHOD_OP: |
654 | /* |
655 | * MethodOp PkgLength NameString MethodFlags TermList |
656 | * |
657 | * Note: We must create the method node/object pair as soon as we |
658 | * see the method declaration. This allows later pass1 parsing |
659 | * of invocations of the method (need to know the number of |
660 | * arguments.) |
661 | */ |
662 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
663 | "LOADING-Method: State=%p Op=%p NamedObj=%p\n" , |
664 | WalkState, Op, Op->Named.Node)); |
665 | |
666 | if (!AcpiNsGetAttachedObject (Op->Named.Node)) |
667 | { |
668 | WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node); |
669 | WalkState->NumOperands = 1; |
670 | |
671 | Status = AcpiDsCreateOperands ( |
672 | WalkState, Op->Common.Value.Arg); |
673 | if (ACPI_SUCCESS (Status)) |
674 | { |
675 | Status = AcpiExCreateMethod ( |
676 | Op->Named.Data, Op->Named.Length, WalkState); |
677 | } |
678 | |
679 | WalkState->Operands[0] = NULL; |
680 | WalkState->NumOperands = 0; |
681 | |
682 | if (ACPI_FAILURE (Status)) |
683 | { |
684 | return_ACPI_STATUS (Status); |
685 | } |
686 | } |
687 | break; |
688 | |
689 | #endif /* ACPI_NO_METHOD_EXECUTION */ |
690 | |
691 | default: |
692 | |
693 | /* All NAMED_COMPLEX opcodes must be handled above */ |
694 | break; |
695 | } |
696 | break; |
697 | |
698 | case AML_CLASS_INTERNAL: |
699 | |
700 | /* case AML_INT_NAMEPATH_OP: */ |
701 | break; |
702 | |
703 | case AML_CLASS_METHOD_CALL: |
704 | |
705 | ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
706 | "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n" , |
707 | WalkState, Op, Node)); |
708 | |
709 | /* |
710 | * Lookup the method name and save the Node |
711 | */ |
712 | Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String, |
713 | ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2, |
714 | ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, |
715 | WalkState, &(NewNode)); |
716 | if (ACPI_SUCCESS (Status)) |
717 | { |
718 | /* |
719 | * Make sure that what we found is indeed a method |
720 | * We didn't search for a method on purpose, to see if the name |
721 | * would resolve |
722 | */ |
723 | if (NewNode->Type != ACPI_TYPE_METHOD) |
724 | { |
725 | Status = AE_AML_OPERAND_TYPE; |
726 | } |
727 | |
728 | /* We could put the returned object (Node) on the object stack for |
729 | * later, but for now, we will put it in the "op" object that the |
730 | * parser uses, so we can get it again at the end of this scope |
731 | */ |
732 | Op->Common.Node = NewNode; |
733 | } |
734 | else |
735 | { |
736 | ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status); |
737 | } |
738 | break; |
739 | |
740 | |
741 | default: |
742 | |
743 | break; |
744 | } |
745 | |
746 | Cleanup: |
747 | |
748 | /* Remove the Node pushed at the very beginning */ |
749 | |
750 | WalkState->Operands[0] = NULL; |
751 | WalkState->NumOperands = 0; |
752 | return_ACPI_STATUS (Status); |
753 | } |
754 | |