xref: /titanic_51/usr/src/uts/intel/io/acpica/executer/exoparg2.c (revision 791a814c934fcd4deb13b26c1f116ff283272a0d)
1 /******************************************************************************
2  *
3  * Module Name: exoparg2 - AML execution - opcodes with 2 arguments
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
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 
117 #define __EXOPARG2_C__
118 
119 #include "acpi.h"
120 #include "accommon.h"
121 #include "acparser.h"
122 #include "acinterp.h"
123 #include "acevents.h"
124 #include "amlcode.h"
125 
126 
127 #define _COMPONENT          ACPI_EXECUTER
128         ACPI_MODULE_NAME    ("exoparg2")
129 
130 
131 /*!
132  * Naming convention for AML interpreter execution routines.
133  *
134  * The routines that begin execution of AML opcodes are named with a common
135  * convention based upon the number of arguments, the number of target operands,
136  * and whether or not a value is returned:
137  *
138  *      AcpiExOpcode_xA_yT_zR
139  *
140  * Where:
141  *
142  * xA - ARGUMENTS:    The number of arguments (input operands) that are
143  *                    required for this opcode type (1 through 6 args).
144  * yT - TARGETS:      The number of targets (output operands) that are required
145  *                    for this opcode type (0, 1, or 2 targets).
146  * zR - RETURN VALUE: Indicates whether this opcode type returns a value
147  *                    as the function return (0 or 1).
148  *
149  * The AcpiExOpcode* functions are called via the Dispatcher component with
150  * fully resolved operands.
151 !*/
152 
153 
154 /*******************************************************************************
155  *
156  * FUNCTION:    AcpiExOpcode_2A_0T_0R
157  *
158  * PARAMETERS:  WalkState           - Current walk state
159  *
160  * RETURN:      Status
161  *
162  * DESCRIPTION: Execute opcode with two arguments, no target, and no return
163  *              value.
164  *
165  * ALLOCATION:  Deletes both operands
166  *
167  ******************************************************************************/
168 
169 ACPI_STATUS
170 AcpiExOpcode_2A_0T_0R (
171     ACPI_WALK_STATE         *WalkState)
172 {
173     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
174     ACPI_NAMESPACE_NODE     *Node;
175     UINT32                  Value;
176     ACPI_STATUS             Status = AE_OK;
177 
178 
179     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_0R,
180             AcpiPsGetOpcodeName (WalkState->Opcode));
181 
182 
183     /* Examine the opcode */
184 
185     switch (WalkState->Opcode)
186     {
187     case AML_NOTIFY_OP:         /* Notify (NotifyObject, NotifyValue) */
188 
189         /* The first operand is a namespace node */
190 
191         Node = (ACPI_NAMESPACE_NODE *) Operand[0];
192 
193         /* Second value is the notify value */
194 
195         Value = (UINT32) Operand[1]->Integer.Value;
196 
197         /* Are notifies allowed on this object? */
198 
199         if (!AcpiEvIsNotifyObject (Node))
200         {
201             ACPI_ERROR ((AE_INFO,
202                 "Unexpected notify object type [%s]",
203                 AcpiUtGetTypeName (Node->Type)));
204 
205             Status = AE_AML_OPERAND_TYPE;
206             break;
207         }
208 
209 #ifdef ACPI_GPE_NOTIFY_CHECK
210         /*
211          * GPE method wake/notify check.  Here, we want to ensure that we
212          * don't receive any "DeviceWake" Notifies from a GPE _Lxx or _Exx
213          * GPE method during system runtime.  If we do, the GPE is marked
214          * as "wake-only" and disabled.
215          *
216          * 1) Is the Notify() value == DeviceWake?
217          * 2) Is this a GPE deferred method?  (An _Lxx or _Exx method)
218          * 3) Did the original GPE happen at system runtime?
219          *    (versus during wake)
220          *
221          * If all three cases are true, this is a wake-only GPE that should
222          * be disabled at runtime.
223          */
224         if (Value == 2)     /* DeviceWake */
225         {
226             Status = AcpiEvCheckForWakeOnlyGpe (WalkState->GpeEventInfo);
227             if (ACPI_FAILURE (Status))
228             {
229                 /* AE_WAKE_ONLY_GPE only error, means ignore this notify */
230 
231                 return_ACPI_STATUS (AE_OK)
232             }
233         }
234 #endif
235 
236         /*
237          * Dispatch the notify to the appropriate handler
238          * NOTE: the request is queued for execution after this method
239          * completes.  The notify handlers are NOT invoked synchronously
240          * from this thread -- because handlers may in turn run other
241          * control methods.
242          */
243         Status = AcpiEvQueueNotifyRequest (Node, Value);
244         break;
245 
246 
247     default:
248 
249         ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
250             WalkState->Opcode));
251         Status = AE_AML_BAD_OPCODE;
252     }
253 
254     return_ACPI_STATUS (Status);
255 }
256 
257 
258 /*******************************************************************************
259  *
260  * FUNCTION:    AcpiExOpcode_2A_2T_1R
261  *
262  * PARAMETERS:  WalkState           - Current walk state
263  *
264  * RETURN:      Status
265  *
266  * DESCRIPTION: Execute a dyadic operator (2 operands) with 2 output targets
267  *              and one implicit return value.
268  *
269  ******************************************************************************/
270 
271 ACPI_STATUS
272 AcpiExOpcode_2A_2T_1R (
273     ACPI_WALK_STATE         *WalkState)
274 {
275     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
276     ACPI_OPERAND_OBJECT     *ReturnDesc1 = NULL;
277     ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;
278     ACPI_STATUS             Status;
279 
280 
281     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_2T_1R,
282         AcpiPsGetOpcodeName (WalkState->Opcode));
283 
284 
285     /* Execute the opcode */
286 
287     switch (WalkState->Opcode)
288     {
289     case AML_DIVIDE_OP:
290 
291         /* Divide (Dividend, Divisor, RemainderResult QuotientResult) */
292 
293         ReturnDesc1 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
294         if (!ReturnDesc1)
295         {
296             Status = AE_NO_MEMORY;
297             goto Cleanup;
298         }
299 
300         ReturnDesc2 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
301         if (!ReturnDesc2)
302         {
303             Status = AE_NO_MEMORY;
304             goto Cleanup;
305         }
306 
307         /* Quotient to ReturnDesc1, remainder to ReturnDesc2 */
308 
309         Status = AcpiUtDivide (Operand[0]->Integer.Value,
310                                Operand[1]->Integer.Value,
311                                &ReturnDesc1->Integer.Value,
312                                &ReturnDesc2->Integer.Value);
313         if (ACPI_FAILURE (Status))
314         {
315             goto Cleanup;
316         }
317         break;
318 
319 
320     default:
321 
322         ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
323             WalkState->Opcode));
324         Status = AE_AML_BAD_OPCODE;
325         goto Cleanup;
326     }
327 
328     /* Store the results to the target reference operands */
329 
330     Status = AcpiExStore (ReturnDesc2, Operand[2], WalkState);
331     if (ACPI_FAILURE (Status))
332     {
333         goto Cleanup;
334     }
335 
336     Status = AcpiExStore (ReturnDesc1, Operand[3], WalkState);
337     if (ACPI_FAILURE (Status))
338     {
339         goto Cleanup;
340     }
341 
342 Cleanup:
343     /*
344      * Since the remainder is not returned indirectly, remove a reference to
345      * it. Only the quotient is returned indirectly.
346      */
347     AcpiUtRemoveReference (ReturnDesc2);
348 
349     if (ACPI_FAILURE (Status))
350     {
351         /* Delete the return object */
352 
353         AcpiUtRemoveReference (ReturnDesc1);
354     }
355 
356     /* Save return object (the remainder) on success */
357 
358     else
359     {
360         WalkState->ResultObj = ReturnDesc1;
361     }
362 
363     return_ACPI_STATUS (Status);
364 }
365 
366 
367 /*******************************************************************************
368  *
369  * FUNCTION:    AcpiExOpcode_2A_1T_1R
370  *
371  * PARAMETERS:  WalkState           - Current walk state
372  *
373  * RETURN:      Status
374  *
375  * DESCRIPTION: Execute opcode with two arguments, one target, and a return
376  *              value.
377  *
378  ******************************************************************************/
379 
380 ACPI_STATUS
381 AcpiExOpcode_2A_1T_1R (
382     ACPI_WALK_STATE         *WalkState)
383 {
384     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
385     ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
386     ACPI_INTEGER            Index;
387     ACPI_STATUS             Status = AE_OK;
388     ACPI_SIZE               Length;
389 
390 
391     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_1T_1R,
392         AcpiPsGetOpcodeName (WalkState->Opcode));
393 
394 
395     /* Execute the opcode */
396 
397     if (WalkState->OpInfo->Flags & AML_MATH)
398     {
399         /* All simple math opcodes (add, etc.) */
400 
401         ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
402         if (!ReturnDesc)
403         {
404             Status = AE_NO_MEMORY;
405             goto Cleanup;
406         }
407 
408         ReturnDesc->Integer.Value = AcpiExDoMathOp (WalkState->Opcode,
409                                                 Operand[0]->Integer.Value,
410                                                 Operand[1]->Integer.Value);
411         goto StoreResultToTarget;
412     }
413 
414     switch (WalkState->Opcode)
415     {
416     case AML_MOD_OP: /* Mod (Dividend, Divisor, RemainderResult (ACPI 2.0) */
417 
418         ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
419         if (!ReturnDesc)
420         {
421             Status = AE_NO_MEMORY;
422             goto Cleanup;
423         }
424 
425         /* ReturnDesc will contain the remainder */
426 
427         Status = AcpiUtDivide (Operand[0]->Integer.Value,
428                                Operand[1]->Integer.Value,
429                                NULL,
430                                &ReturnDesc->Integer.Value);
431         break;
432 
433 
434     case AML_CONCAT_OP: /* Concatenate (Data1, Data2, Result) */
435 
436         Status = AcpiExDoConcatenate (Operand[0], Operand[1],
437                     &ReturnDesc, WalkState);
438         break;
439 
440 
441     case AML_TO_STRING_OP: /* ToString (Buffer, Length, Result) (ACPI 2.0) */
442 
443         /*
444          * Input object is guaranteed to be a buffer at this point (it may have
445          * been converted.)  Copy the raw buffer data to a new object of
446          * type String.
447          */
448 
449         /*
450          * Get the length of the new string. It is the smallest of:
451          * 1) Length of the input buffer
452          * 2) Max length as specified in the ToString operator
453          * 3) Length of input buffer up to a zero byte (null terminator)
454          *
455          * NOTE: A length of zero is ok, and will create a zero-length, null
456          *       terminated string.
457          */
458         Length = 0;
459         while ((Length < Operand[0]->Buffer.Length) &&
460                (Length < Operand[1]->Integer.Value) &&
461                (Operand[0]->Buffer.Pointer[Length]))
462         {
463             Length++;
464         }
465 
466         /* Allocate a new string object */
467 
468         ReturnDesc = AcpiUtCreateStringObject (Length);
469         if (!ReturnDesc)
470         {
471             Status = AE_NO_MEMORY;
472             goto Cleanup;
473         }
474 
475         /*
476          * Copy the raw buffer data with no transform.
477          * (NULL terminated already)
478          */
479         ACPI_MEMCPY (ReturnDesc->String.Pointer,
480             Operand[0]->Buffer.Pointer, Length);
481         break;
482 
483 
484     case AML_CONCAT_RES_OP:
485 
486         /* ConcatenateResTemplate (Buffer, Buffer, Result) (ACPI 2.0) */
487 
488         Status = AcpiExConcatTemplate (Operand[0], Operand[1],
489                     &ReturnDesc, WalkState);
490         break;
491 
492 
493     case AML_INDEX_OP:              /* Index (Source Index Result) */
494 
495         /* Create the internal return object */
496 
497         ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
498         if (!ReturnDesc)
499         {
500             Status = AE_NO_MEMORY;
501             goto Cleanup;
502         }
503 
504         /* Initialize the Index reference object */
505 
506         Index = Operand[1]->Integer.Value;
507         ReturnDesc->Reference.Value = (UINT32) Index;
508         ReturnDesc->Reference.Class = ACPI_REFCLASS_INDEX;
509 
510         /*
511          * At this point, the Source operand is a String, Buffer, or Package.
512          * Verify that the index is within range.
513          */
514         switch ((Operand[0])->Common.Type)
515         {
516         case ACPI_TYPE_STRING:
517 
518             if (Index >= Operand[0]->String.Length)
519             {
520                 Status = AE_AML_STRING_LIMIT;
521             }
522 
523             ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
524             break;
525 
526         case ACPI_TYPE_BUFFER:
527 
528             if (Index >= Operand[0]->Buffer.Length)
529             {
530                 Status = AE_AML_BUFFER_LIMIT;
531             }
532 
533             ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
534             break;
535 
536         case ACPI_TYPE_PACKAGE:
537 
538             if (Index >= Operand[0]->Package.Count)
539             {
540                 Status = AE_AML_PACKAGE_LIMIT;
541             }
542 
543             ReturnDesc->Reference.TargetType = ACPI_TYPE_PACKAGE;
544             ReturnDesc->Reference.Where = &Operand[0]->Package.Elements [Index];
545             break;
546 
547         default:
548 
549             Status = AE_AML_INTERNAL;
550             goto Cleanup;
551         }
552 
553         /* Failure means that the Index was beyond the end of the object */
554 
555         if (ACPI_FAILURE (Status))
556         {
557             ACPI_EXCEPTION ((AE_INFO, Status,
558                 "Index (%X%8.8X) is beyond end of object",
559                 ACPI_FORMAT_UINT64 (Index)));
560             goto Cleanup;
561         }
562 
563         /*
564          * Save the target object and add a reference to it for the life
565          * of the index
566          */
567         ReturnDesc->Reference.Object = Operand[0];
568         AcpiUtAddReference (Operand[0]);
569 
570         /* Store the reference to the Target */
571 
572         Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
573 
574         /* Return the reference */
575 
576         WalkState->ResultObj = ReturnDesc;
577         goto Cleanup;
578 
579 
580     default:
581 
582         ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
583             WalkState->Opcode));
584         Status = AE_AML_BAD_OPCODE;
585         break;
586     }
587 
588 
589 StoreResultToTarget:
590 
591     if (ACPI_SUCCESS (Status))
592     {
593         /*
594          * Store the result of the operation (which is now in ReturnDesc) into
595          * the Target descriptor.
596          */
597         Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
598         if (ACPI_FAILURE (Status))
599         {
600             goto Cleanup;
601         }
602 
603         if (!WalkState->ResultObj)
604         {
605             WalkState->ResultObj = ReturnDesc;
606         }
607     }
608 
609 
610 Cleanup:
611 
612     /* Delete return object on error */
613 
614     if (ACPI_FAILURE (Status))
615     {
616         AcpiUtRemoveReference (ReturnDesc);
617         WalkState->ResultObj = NULL;
618     }
619 
620     return_ACPI_STATUS (Status);
621 }
622 
623 
624 /*******************************************************************************
625  *
626  * FUNCTION:    AcpiExOpcode_2A_0T_1R
627  *
628  * PARAMETERS:  WalkState           - Current walk state
629  *
630  * RETURN:      Status
631  *
632  * DESCRIPTION: Execute opcode with 2 arguments, no target, and a return value
633  *
634  ******************************************************************************/
635 
636 ACPI_STATUS
637 AcpiExOpcode_2A_0T_1R (
638     ACPI_WALK_STATE         *WalkState)
639 {
640     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
641     ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
642     ACPI_STATUS             Status = AE_OK;
643     BOOLEAN                 LogicalResult = FALSE;
644 
645 
646     ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_1R,
647         AcpiPsGetOpcodeName (WalkState->Opcode));
648 
649 
650     /* Create the internal return object */
651 
652     ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
653     if (!ReturnDesc)
654     {
655         Status = AE_NO_MEMORY;
656         goto Cleanup;
657     }
658 
659     /* Execute the Opcode */
660 
661     if (WalkState->OpInfo->Flags & AML_LOGICAL_NUMERIC)
662     {
663         /* LogicalOp  (Operand0, Operand1) */
664 
665         Status = AcpiExDoLogicalNumericOp (WalkState->Opcode,
666                         Operand[0]->Integer.Value, Operand[1]->Integer.Value,
667                         &LogicalResult);
668         goto StoreLogicalResult;
669     }
670     else if (WalkState->OpInfo->Flags & AML_LOGICAL)
671     {
672         /* LogicalOp  (Operand0, Operand1) */
673 
674         Status = AcpiExDoLogicalOp (WalkState->Opcode, Operand[0],
675                     Operand[1], &LogicalResult);
676         goto StoreLogicalResult;
677     }
678 
679     switch (WalkState->Opcode)
680     {
681     case AML_ACQUIRE_OP:            /* Acquire (MutexObject, Timeout) */
682 
683         Status = AcpiExAcquireMutex (Operand[1], Operand[0], WalkState);
684         if (Status == AE_TIME)
685         {
686             LogicalResult = TRUE;       /* TRUE = Acquire timed out */
687             Status = AE_OK;
688         }
689         break;
690 
691 
692     case AML_WAIT_OP:               /* Wait (EventObject, Timeout) */
693 
694         Status = AcpiExSystemWaitEvent (Operand[1], Operand[0]);
695         if (Status == AE_TIME)
696         {
697             LogicalResult = TRUE;       /* TRUE, Wait timed out */
698             Status = AE_OK;
699         }
700         break;
701 
702 
703     default:
704 
705         ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
706             WalkState->Opcode));
707         Status = AE_AML_BAD_OPCODE;
708         goto Cleanup;
709     }
710 
711 
712 StoreLogicalResult:
713     /*
714      * Set return value to according to LogicalResult. logical TRUE (all ones)
715      * Default is FALSE (zero)
716      */
717     if (LogicalResult)
718     {
719         ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;
720     }
721 
722 Cleanup:
723 
724     /* Delete return object on error */
725 
726     if (ACPI_FAILURE (Status))
727     {
728         AcpiUtRemoveReference (ReturnDesc);
729     }
730 
731     /* Save return object on success */
732 
733     else
734     {
735         WalkState->ResultObj = ReturnDesc;
736     }
737 
738     return_ACPI_STATUS (Status);
739 }
740 
741 
742