ReactOS  0.4.11-dev-195-gef016bf
exoparg2.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: exoparg2 - AML execution - opcodes with 2 arguments
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2017, 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 "acinterp.h"
48 #include "acevents.h"
49 #include "amlcode.h"
50 
51 
52 #define _COMPONENT ACPI_EXECUTER
53  ACPI_MODULE_NAME ("exoparg2")
54 
55 
56 
79 /*******************************************************************************
80  *
81  * FUNCTION: AcpiExOpcode_2A_0T_0R
82  *
83  * PARAMETERS: WalkState - Current walk state
84  *
85  * RETURN: Status
86  *
87  * DESCRIPTION: Execute opcode with two arguments, no target, and no return
88  * value.
89  *
90  * ALLOCATION: Deletes both operands
91  *
92  ******************************************************************************/
93 
96  ACPI_WALK_STATE *WalkState)
97 {
98  ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
100  UINT32 Value;
102 
103 
104  ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_0R,
105  AcpiPsGetOpcodeName (WalkState->Opcode));
106 
107 
108  /* Examine the opcode */
109 
110  switch (WalkState->Opcode)
111  {
112  case AML_NOTIFY_OP: /* Notify (NotifyObject, NotifyValue) */
113 
114  /* The first operand is a namespace node */
115 
116  Node = (ACPI_NAMESPACE_NODE *) Operand[0];
117 
118  /* Second value is the notify value */
119 
120  Value = (UINT32) Operand[1]->Integer.Value;
121 
122  /* Are notifies allowed on this object? */
123 
124  if (!AcpiEvIsNotifyObject (Node))
125  {
127  "Unexpected notify object type [%s]",
128  AcpiUtGetTypeName (Node->Type)));
129 
130  Status = AE_AML_OPERAND_TYPE;
131  break;
132  }
133 
134  /*
135  * Dispatch the notify to the appropriate handler
136  * NOTE: the request is queued for execution after this method
137  * completes. The notify handlers are NOT invoked synchronously
138  * from this thread -- because handlers may in turn run other
139  * control methods.
140  */
141  Status = AcpiEvQueueNotifyRequest (Node, Value);
142  break;
143 
144  default:
145 
146  ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
147  WalkState->Opcode));
148  Status = AE_AML_BAD_OPCODE;
149  }
150 
151  return_ACPI_STATUS (Status);
152 }
153 
154 
155 /*******************************************************************************
156  *
157  * FUNCTION: AcpiExOpcode_2A_2T_1R
158  *
159  * PARAMETERS: WalkState - Current walk state
160  *
161  * RETURN: Status
162  *
163  * DESCRIPTION: Execute a dyadic operator (2 operands) with 2 output targets
164  * and one implicit return value.
165  *
166  ******************************************************************************/
167 
170  ACPI_WALK_STATE *WalkState)
171 {
172  ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
173  ACPI_OPERAND_OBJECT *ReturnDesc1 = NULL;
174  ACPI_OPERAND_OBJECT *ReturnDesc2 = NULL;
176 
177 
178  ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_2T_1R,
179  AcpiPsGetOpcodeName (WalkState->Opcode));
180 
181 
182  /* Execute the opcode */
183 
184  switch (WalkState->Opcode)
185  {
186  case AML_DIVIDE_OP:
187 
188  /* Divide (Dividend, Divisor, RemainderResult QuotientResult) */
189 
191  if (!ReturnDesc1)
192  {
193  Status = AE_NO_MEMORY;
194  goto Cleanup;
195  }
196 
198  if (!ReturnDesc2)
199  {
200  Status = AE_NO_MEMORY;
201  goto Cleanup;
202  }
203 
204  /* Quotient to ReturnDesc1, remainder to ReturnDesc2 */
205 
206  Status = AcpiUtDivide (
207  Operand[0]->Integer.Value,
208  Operand[1]->Integer.Value,
209  &ReturnDesc1->Integer.Value,
210  &ReturnDesc2->Integer.Value);
211  if (ACPI_FAILURE (Status))
212  {
213  goto Cleanup;
214  }
215  break;
216 
217  default:
218 
219  ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
220  WalkState->Opcode));
221 
222  Status = AE_AML_BAD_OPCODE;
223  goto Cleanup;
224  }
225 
226  /* Store the results to the target reference operands */
227 
228  Status = AcpiExStore (ReturnDesc2, Operand[2], WalkState);
229  if (ACPI_FAILURE (Status))
230  {
231  goto Cleanup;
232  }
233 
234  Status = AcpiExStore (ReturnDesc1, Operand[3], WalkState);
235  if (ACPI_FAILURE (Status))
236  {
237  goto Cleanup;
238  }
239 
240 Cleanup:
241  /*
242  * Since the remainder is not returned indirectly, remove a reference to
243  * it. Only the quotient is returned indirectly.
244  */
245  AcpiUtRemoveReference (ReturnDesc2);
246 
247  if (ACPI_FAILURE (Status))
248  {
249  /* Delete the return object */
250 
251  AcpiUtRemoveReference (ReturnDesc1);
252  }
253 
254  /* Save return object (the remainder) on success */
255 
256  else
257  {
258  WalkState->ResultObj = ReturnDesc1;
259  }
260 
261  return_ACPI_STATUS (Status);
262 }
263 
264 
265 /*******************************************************************************
266  *
267  * FUNCTION: AcpiExOpcode_2A_1T_1R
268  *
269  * PARAMETERS: WalkState - Current walk state
270  *
271  * RETURN: Status
272  *
273  * DESCRIPTION: Execute opcode with two arguments, one target, and a return
274  * value.
275  *
276  ******************************************************************************/
277 
280  ACPI_WALK_STATE *WalkState)
281 {
282  ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
283  ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
284  UINT64 Index;
286  ACPI_SIZE Length = 0;
287 
288 
289  ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_1T_1R,
290  AcpiPsGetOpcodeName (WalkState->Opcode));
291 
292 
293  /* Execute the opcode */
294 
295  if (WalkState->OpInfo->Flags & AML_MATH)
296  {
297  /* All simple math opcodes (add, etc.) */
298 
300  if (!ReturnDesc)
301  {
302  Status = AE_NO_MEMORY;
303  goto Cleanup;
304  }
305 
306  ReturnDesc->Integer.Value = AcpiExDoMathOp (
307  WalkState->Opcode,
308  Operand[0]->Integer.Value,
309  Operand[1]->Integer.Value);
310  goto StoreResultToTarget;
311  }
312 
313  switch (WalkState->Opcode)
314  {
315  case AML_MOD_OP: /* Mod (Dividend, Divisor, RemainderResult (ACPI 2.0) */
316 
318  if (!ReturnDesc)
319  {
320  Status = AE_NO_MEMORY;
321  goto Cleanup;
322  }
323 
324  /* ReturnDesc will contain the remainder */
325 
326  Status = AcpiUtDivide (
327  Operand[0]->Integer.Value,
328  Operand[1]->Integer.Value,
329  NULL,
330  &ReturnDesc->Integer.Value);
331  break;
332 
333  case AML_CONCATENATE_OP: /* Concatenate (Data1, Data2, Result) */
334 
335  Status = AcpiExDoConcatenate (
336  Operand[0], Operand[1], &ReturnDesc, WalkState);
337  break;
338 
339  case AML_TO_STRING_OP: /* ToString (Buffer, Length, Result) (ACPI 2.0) */
340  /*
341  * Input object is guaranteed to be a buffer at this point (it may have
342  * been converted.) Copy the raw buffer data to a new object of
343  * type String.
344  */
345 
346  /*
347  * Get the length of the new string. It is the smallest of:
348  * 1) Length of the input buffer
349  * 2) Max length as specified in the ToString operator
350  * 3) Length of input buffer up to a zero byte (null terminator)
351  *
352  * NOTE: A length of zero is ok, and will create a zero-length, null
353  * terminated string.
354  */
355  while ((Length < Operand[0]->Buffer.Length) &&
356  (Length < Operand[1]->Integer.Value) &&
357  (Operand[0]->Buffer.Pointer[Length]))
358  {
359  Length++;
360  }
361 
362  /* Allocate a new string object */
363 
364  ReturnDesc = AcpiUtCreateStringObject (Length);
365  if (!ReturnDesc)
366  {
367  Status = AE_NO_MEMORY;
368  goto Cleanup;
369  }
370 
371  /*
372  * Copy the raw buffer data with no transform.
373  * (NULL terminated already)
374  */
375  memcpy (ReturnDesc->String.Pointer,
376  Operand[0]->Buffer.Pointer, Length);
377  break;
378 
380 
381  /* ConcatenateResTemplate (Buffer, Buffer, Result) (ACPI 2.0) */
382 
383  Status = AcpiExConcatTemplate (
384  Operand[0], Operand[1], &ReturnDesc, WalkState);
385  break;
386 
387  case AML_INDEX_OP: /* Index (Source Index Result) */
388 
389  /* Create the internal return object */
390 
392  if (!ReturnDesc)
393  {
394  Status = AE_NO_MEMORY;
395  goto Cleanup;
396  }
397 
398  /* Initialize the Index reference object */
399 
400  Index = Operand[1]->Integer.Value;
401  ReturnDesc->Reference.Value = (UINT32) Index;
402  ReturnDesc->Reference.Class = ACPI_REFCLASS_INDEX;
403 
404  /*
405  * At this point, the Source operand is a String, Buffer, or Package.
406  * Verify that the index is within range.
407  */
408  switch ((Operand[0])->Common.Type)
409  {
410  case ACPI_TYPE_STRING:
411 
412  if (Index >= Operand[0]->String.Length)
413  {
414  Length = Operand[0]->String.Length;
415  Status = AE_AML_STRING_LIMIT;
416  }
417 
419  ReturnDesc->Reference.IndexPointer =
420  &(Operand[0]->Buffer.Pointer [Index]);
421  break;
422 
423  case ACPI_TYPE_BUFFER:
424 
425  if (Index >= Operand[0]->Buffer.Length)
426  {
427  Length = Operand[0]->Buffer.Length;
428  Status = AE_AML_BUFFER_LIMIT;
429  }
430 
432  ReturnDesc->Reference.IndexPointer =
433  &(Operand[0]->Buffer.Pointer [Index]);
434  break;
435 
436  case ACPI_TYPE_PACKAGE:
437 
438  if (Index >= Operand[0]->Package.Count)
439  {
440  Length = Operand[0]->Package.Count;
441  Status = AE_AML_PACKAGE_LIMIT;
442  }
443 
444  ReturnDesc->Reference.TargetType = ACPI_TYPE_PACKAGE;
445  ReturnDesc->Reference.Where =
446  &Operand[0]->Package.Elements [Index];
447  break;
448 
449  default:
450 
452  "Invalid object type: %X", (Operand[0])->Common.Type));
453  Status = AE_AML_INTERNAL;
454  goto Cleanup;
455  }
456 
457  /* Failure means that the Index was beyond the end of the object */
458 
459  if (ACPI_FAILURE (Status))
460  {
461  ACPI_EXCEPTION ((AE_INFO, Status,
462  "Index (0x%X%8.8X) is beyond end of object (length 0x%X)",
463  ACPI_FORMAT_UINT64 (Index), (UINT32) Length));
464  goto Cleanup;
465  }
466 
467  /*
468  * Save the target object and add a reference to it for the life
469  * of the index
470  */
471  ReturnDesc->Reference.Object = Operand[0];
472  AcpiUtAddReference (Operand[0]);
473 
474  /* Store the reference to the Target */
475 
476  Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
477 
478  /* Return the reference */
479 
480  WalkState->ResultObj = ReturnDesc;
481  goto Cleanup;
482 
483  default:
484 
485  ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
486  WalkState->Opcode));
487  Status = AE_AML_BAD_OPCODE;
488  break;
489  }
490 
491 
492 StoreResultToTarget:
493 
494  if (ACPI_SUCCESS (Status))
495  {
496  /*
497  * Store the result of the operation (which is now in ReturnDesc) into
498  * the Target descriptor.
499  */
500  Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
501  if (ACPI_FAILURE (Status))
502  {
503  goto Cleanup;
504  }
505 
506  if (!WalkState->ResultObj)
507  {
508  WalkState->ResultObj = ReturnDesc;
509  }
510  }
511 
512 
513 Cleanup:
514 
515  /* Delete return object on error */
516 
517  if (ACPI_FAILURE (Status))
518  {
519  AcpiUtRemoveReference (ReturnDesc);
520  WalkState->ResultObj = NULL;
521  }
522 
523  return_ACPI_STATUS (Status);
524 }
525 
526 
527 /*******************************************************************************
528  *
529  * FUNCTION: AcpiExOpcode_2A_0T_1R
530  *
531  * PARAMETERS: WalkState - Current walk state
532  *
533  * RETURN: Status
534  *
535  * DESCRIPTION: Execute opcode with 2 arguments, no target, and a return value
536  *
537  ******************************************************************************/
538 
541  ACPI_WALK_STATE *WalkState)
542 {
543  ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
544  ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
546  BOOLEAN LogicalResult = FALSE;
547 
548 
549  ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_1R,
550  AcpiPsGetOpcodeName (WalkState->Opcode));
551 
552 
553  /* Create the internal return object */
554 
556  if (!ReturnDesc)
557  {
558  Status = AE_NO_MEMORY;
559  goto Cleanup;
560  }
561 
562  /* Execute the Opcode */
563 
564  if (WalkState->OpInfo->Flags & AML_LOGICAL_NUMERIC)
565  {
566  /* LogicalOp (Operand0, Operand1) */
567 
568  Status = AcpiExDoLogicalNumericOp (WalkState->Opcode,
569  Operand[0]->Integer.Value, Operand[1]->Integer.Value,
570  &LogicalResult);
571  goto StoreLogicalResult;
572  }
573  else if (WalkState->OpInfo->Flags & AML_LOGICAL)
574  {
575  /* LogicalOp (Operand0, Operand1) */
576 
577  Status = AcpiExDoLogicalOp (WalkState->Opcode, Operand[0],
578  Operand[1], &LogicalResult);
579  goto StoreLogicalResult;
580  }
581 
582  switch (WalkState->Opcode)
583  {
584  case AML_ACQUIRE_OP: /* Acquire (MutexObject, Timeout) */
585 
586  Status = AcpiExAcquireMutex (Operand[1], Operand[0], WalkState);
587  if (Status == AE_TIME)
588  {
589  LogicalResult = TRUE; /* TRUE = Acquire timed out */
590  Status = AE_OK;
591  }
592  break;
593 
594 
595  case AML_WAIT_OP: /* Wait (EventObject, Timeout) */
596 
597  Status = AcpiExSystemWaitEvent (Operand[1], Operand[0]);
598  if (Status == AE_TIME)
599  {
600  LogicalResult = TRUE; /* TRUE, Wait timed out */
601  Status = AE_OK;
602  }
603  break;
604 
605  default:
606 
607  ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
608  WalkState->Opcode));
609 
610  Status = AE_AML_BAD_OPCODE;
611  goto Cleanup;
612  }
613 
614 
615 StoreLogicalResult:
616  /*
617  * Set return value to according to LogicalResult. logical TRUE (all ones)
618  * Default is FALSE (zero)
619  */
620  if (LogicalResult)
621  {
622  ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
623  }
624 
625 Cleanup:
626 
627  /* Delete return object on error */
628 
629  if (ACPI_FAILURE (Status))
630  {
631  AcpiUtRemoveReference (ReturnDesc);
632  }
633 
634  /* Save return object on success */
635 
636  else
637  {
638  WalkState->ResultObj = ReturnDesc;
639  }
640 
641  return_ACPI_STATUS (Status);
642 }
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:235
#define AE_AML_BUFFER_LIMIT
Definition: acexcep.h:177
void AcpiUtAddReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:738
#define TRUE
Definition: types.h:120
const char * AcpiPsGetOpcodeName(UINT16 Opcode)
Definition: psopinfo.c:169
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
ACPI_STATUS AcpiExStore(ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState)
Definition: exstore.c:91
#define AE_NO_MEMORY
Definition: acexcep.h:105
UINT64 AcpiExDoMathOp(UINT16 Opcode, UINT64 Integer0, UINT64 Integer1)
Definition: exmisc.c:167
ACPI_STATUS AcpiExAcquireMutex(ACPI_OPERAND_OBJECT *TimeDesc, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
Definition: exmutex.c:248
#define AML_LOGICAL
Definition: amlcode.h:332
ACPI_STATUS AcpiExDoLogicalOp(UINT16 Opcode, ACPI_OPERAND_OBJECT *Operand0, ACPI_OPERAND_OBJECT *Operand1, BOOLEAN *LogicalResult)
Definition: exmisc.c:335
ACPI_OBJECT_PACKAGE Package
Definition: acobject.h:519
#define ACPI_TYPE_BUFFER
Definition: actypes.h:674
#define ACPI_TYPE_INTEGER
Definition: actypes.h:672
#define AML_LOGICAL_NUMERIC
Definition: amlcode.h:333
#define AE_AML_INTERNAL
Definition: acexcep.h:182
#define ACPI_TYPE_LOCAL_REFERENCE
Definition: actypes.h:703
#define AML_INDEX_OP
Definition: amlcode.h:112
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define AE_TIME
Definition: acexcep.h:118
ACPI_STATUS AcpiExDoConcatenate(ACPI_OPERAND_OBJECT *Operand0, ACPI_OPERAND_OBJECT *Operand1, ACPI_OPERAND_OBJECT **ActualReturnDesc, ACPI_WALK_STATE *WalkState)
Definition: exconcat.c:85
#define AE_AML_OPERAND_TYPE
Definition: acexcep.h:170
#define ACPI_TYPE_PACKAGE
Definition: actypes.h:675
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
CHAR16 * String
Definition: acefiex.h:201
ACPI_STATUS AcpiExOpcode_2A_2T_1R(ACPI_WALK_STATE *WalkState)
Definition: exoparg2.c:169
#define FALSE
Definition: types.h:117
ACPI_OBJECT_COMMON_HEADER UINT8 Class
Definition: acobject.h:439
unsigned int UINT32
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:212
smooth NULL
Definition: ftsmooth.c:416
#define AE_INFO
Definition: acoutput.h:226
#define AE_AML_BAD_OPCODE
Definition: acexcep.h:168
Definition: bufpool.h:45
ACPI_OBJECT_REFERENCE Reference
Definition: acobject.h:536
#define AML_MOD_OP
Definition: amlcode.h:109
ACPI_OPERAND_OBJECT * AcpiUtCreateStringObject(ACPI_SIZE StringSize)
Definition: utobject.c:320
#define AML_ACQUIRE_OP
Definition: amlcode.h:168
unsigned char BOOLEAN
ACPI_OBJECT_BUFFER Buffer
Definition: acobject.h:518
union acpi_operand_object * ResultObj
Definition: acstruct.h:118
#define AML_CONCATENATE_TEMPLATE_OP
Definition: amlcode.h:108
if(!(yy_init))
Definition: macro.lex.yy.c:717
static const UCHAR Index[8]
Definition: usbohci.c:18
const ACPI_OPCODE_INFO * OpInfo
Definition: acstruct.h:116
#define AE_AML_STRING_LIMIT
Definition: acexcep.h:184
ACPI_STATUS AcpiExDoLogicalNumericOp(UINT16 Opcode, UINT64 Integer0, UINT64 Integer1, BOOLEAN *LogicalResult)
Definition: exmisc.c:262
ACPI_STATUS AcpiExSystemWaitEvent(ACPI_OPERAND_OBJECT *TimeDesc, ACPI_OPERAND_OBJECT *ObjDesc)
Definition: exsystem.c:294
VOID UINTN Length
Definition: acefiex.h:744
ACPI_OBJECT_INTEGER Integer
Definition: acobject.h:516
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ACPI_STATUS AcpiExConcatTemplate(ACPI_OPERAND_OBJECT *Operand0, ACPI_OPERAND_OBJECT *Operand1, ACPI_OPERAND_OBJECT **ActualReturnDesc, ACPI_WALK_STATE *WalkState)
Definition: exconcat.c:388
static const WCHAR Cleanup[]
Definition: register.c:80
#define AML_NOTIFY_OP
Definition: amlcode.h:110
UINTN UINT8 Value
Definition: acefiex.h:751
ACPI_OBJECT_STRING String
Definition: acobject.h:517
Status
Definition: gdiplustypes.h:24
ACPI_STATUS AcpiExOpcode_2A_1T_1R(ACPI_WALK_STATE *WalkState)
Definition: exoparg2.c:279
#define AML_MATH
Definition: amlcode.h:334
union acpi_operand_object * Operands[ACPI_OBJ_NUM_OPERANDS+1]
Definition: acstruct.h:103
#define AML_CONCATENATE_OP
Definition: amlcode.h:91
#define return_ACPI_STATUS(s)
Definition: acoutput.h:490
#define ACPI_FORMAT_UINT64(i)
Definition: acmacros.h:71
#define ACPI_TYPE_BUFFER_FIELD
Definition: actypes.h:685
#define ACPI_FUNCTION_TRACE_STR(a, b)
Definition: acoutput.h:477
#define AML_WAIT_OP
Definition: amlcode.h:170
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:776
const char * AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:249
ACPI_STATUS AcpiEvQueueNotifyRequest(ACPI_NAMESPACE_NODE *Node, UINT32 NotifyValue)
Definition: evmisc.c:111
BOOLEAN AcpiEvIsNotifyObject(ACPI_NAMESPACE_NODE *Node)
Definition: evmisc.c:75
ACPI_STATUS AcpiExOpcode_2A_0T_1R(ACPI_WALK_STATE *WalkState)
Definition: exoparg2.c:540
#define ACPI_ERROR(plist)
Definition: acoutput.h:236
#define ACPI_UINT64_MAX
Definition: actypes.h:67
UINT16 Opcode
Definition: acstruct.h:78
union acpi_operand_object ** Where
Definition: acobject.h:444
#define ACPI_TYPE_STRING
Definition: actypes.h:673
#define AcpiUtCreateInternalObject(t)
Definition: acutils.h:611
#define AML_TO_STRING_OP
Definition: amlcode.h:130
unsigned long long UINT64
#define AE_AML_PACKAGE_LIMIT
Definition: acexcep.h:178
ACPI_STATUS AcpiExOpcode_2A_0T_0R(ACPI_WALK_STATE *WalkState)
Definition: exoparg2.c:95
#define AE_OK
Definition: acexcep.h:97
UINT16 Flags
Definition: aclocal.h:873
union gl_dlist_node Node
Definition: dlist.c:302
ACPI_STATUS AcpiUtDivide(UINT64 InDividend, UINT64 InDivisor, UINT64 *OutQuotient, UINT64 *OutRemainder)
Definition: utmath.c:402
#define AML_DIVIDE_OP
Definition: amlcode.h:96
union acpi_operand_object ** Elements
Definition: acobject.h:161