ReactOS  0.4.14-dev-998-g623dd26
dswload.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: dswload - Dispatcher first pass namespace load callbacks
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2020, 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 
52 #ifdef ACPI_ASL_COMPILER
53 #include "acdisasm.h"
54 #endif
55 
56 #define _COMPONENT ACPI_DISPATCHER
57  ACPI_MODULE_NAME ("dswload")
58 
59 
60 /*******************************************************************************
61  *
62  * FUNCTION: AcpiDsInitCallbacks
63  *
64  * PARAMETERS: WalkState - Current state of the parse tree walk
65  * PassNumber - 1, 2, or 3
66  *
67  * RETURN: Status
68  *
69  * DESCRIPTION: Init walk state callbacks
70  *
71  ******************************************************************************/
72 
75  ACPI_WALK_STATE *WalkState,
76  UINT32 PassNumber)
77 {
78 
79  switch (PassNumber)
80  {
81  case 0:
82 
83  /* Parse only - caller will setup callbacks */
84 
85  WalkState->ParseFlags = ACPI_PARSE_LOAD_PASS1 |
88  WalkState->DescendingCallback = NULL;
89  WalkState->AscendingCallback = NULL;
90  break;
91 
92  case 1:
93 
94  /* Load pass 1 */
95 
96  WalkState->ParseFlags = ACPI_PARSE_LOAD_PASS1 |
98  WalkState->DescendingCallback = AcpiDsLoad1BeginOp;
99  WalkState->AscendingCallback = AcpiDsLoad1EndOp;
100  break;
101 
102  case 2:
103 
104  /* Load pass 2 */
105 
106  WalkState->ParseFlags = ACPI_PARSE_LOAD_PASS1 |
108  WalkState->DescendingCallback = AcpiDsLoad2BeginOp;
109  WalkState->AscendingCallback = AcpiDsLoad2EndOp;
110  break;
111 
112  case 3:
113 
114  /* Execution pass */
115 
116  WalkState->ParseFlags |= ACPI_PARSE_EXECUTE |
118  WalkState->DescendingCallback = AcpiDsExecBeginOp;
119  WalkState->AscendingCallback = AcpiDsExecEndOp;
120  break;
121 
122  default:
123 
124  return (AE_BAD_PARAMETER);
125  }
126 
127  return (AE_OK);
128 }
129 
130 
131 /*******************************************************************************
132  *
133  * FUNCTION: AcpiDsLoad1BeginOp
134  *
135  * PARAMETERS: WalkState - Current state of the parse tree walk
136  * OutOp - Where to return op if a new one is created
137  *
138  * RETURN: Status
139  *
140  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
141  *
142  ******************************************************************************/
143 
146  ACPI_WALK_STATE *WalkState,
147  ACPI_PARSE_OBJECT **OutOp)
148 {
149  ACPI_PARSE_OBJECT *Op;
153  char *Path;
154  UINT32 Flags;
155 
156 
157  ACPI_FUNCTION_TRACE_PTR (DsLoad1BeginOp, WalkState->Op);
158 
159 
160  Op = WalkState->Op;
161  ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
162 
163  /* We are only interested in opcodes that have an associated name */
164 
165  if (Op)
166  {
167  if (!(WalkState->OpInfo->Flags & AML_NAMED))
168  {
169  *OutOp = Op;
171  }
172 
173  /* Check if this object has already been installed in the namespace */
174 
175  if (Op->Common.Node)
176  {
177  *OutOp = Op;
179  }
180  }
181 
182  Path = AcpiPsGetNextNamestring (&WalkState->ParserState);
183 
184  /* Map the raw opcode into an internal object type */
185 
186  ObjectType = WalkState->OpInfo->ObjectType;
187 
189  "State=%p Op=%p [%s]\n", WalkState, Op,
191 
192  switch (WalkState->Opcode)
193  {
194  case AML_SCOPE_OP:
195  /*
196  * The target name of the Scope() operator must exist at this point so
197  * that we can actually open the scope to enter new names underneath it.
198  * Allow search-to-root for single namesegs.
199  */
200  Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
202 #ifdef ACPI_ASL_COMPILER
203  if (Status == AE_NOT_FOUND)
204  {
205  /*
206  * Table disassembly:
207  * Target of Scope() not found. Generate an External for it, and
208  * insert the name into the namespace.
209  */
211  Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
213  WalkState, &Node);
214  }
215 #endif
216  if (ACPI_FAILURE (Status))
217  {
218  ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, Path, Status);
220  }
221 
222  /*
223  * Check to make sure that the target is
224  * one of the opcodes that actually opens a scope
225  */
226  switch (Node->Type)
227  {
228  case ACPI_TYPE_ANY:
229  case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
230  case ACPI_TYPE_DEVICE:
231  case ACPI_TYPE_POWER:
232  case ACPI_TYPE_PROCESSOR:
233  case ACPI_TYPE_THERMAL:
234 
235  /* These are acceptable types */
236  break;
237 
238  case ACPI_TYPE_INTEGER:
239  case ACPI_TYPE_STRING:
240  case ACPI_TYPE_BUFFER:
241  /*
242  * These types we will allow, but we will change the type.
243  * This enables some existing code of the form:
244  *
245  * Name (DEB, 0)
246  * Scope (DEB) { ... }
247  *
248  * Note: silently change the type here. On the second pass,
249  * we will report a warning
250  */
252  "Type override - [%4.4s] had invalid type (%s) "
253  "for Scope operator, changed to type ANY\n",
255 
256  Node->Type = ACPI_TYPE_ANY;
257  WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
258  break;
259 
260  case ACPI_TYPE_METHOD:
261  /*
262  * Allow scope change to root during execution of module-level
263  * code. Root is typed METHOD during this time.
264  */
265  if ((Node == AcpiGbl_RootNode) &&
266  (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
267  {
268  break;
269  }
270 
271  /*lint -fallthrough */
272 
273  default:
274 
275  /* All other types are an error */
276 
278  "Invalid type (%s) for target of "
279  "Scope operator [%4.4s] (Cannot override)",
281 
283  }
284  break;
285 
286  default:
287  /*
288  * For all other named opcodes, we will enter the name into
289  * the namespace.
290  *
291  * Setup the search flags.
292  * Since we are entering a name into the namespace, we do not want to
293  * enable the search-to-root upsearch.
294  *
295  * There are only two conditions where it is acceptable that the name
296  * already exists:
297  * 1) the Scope() operator can reopen a scoping object that was
298  * previously defined (Scope, Method, Device, etc.)
299  * 2) Whenever we are parsing a deferred opcode (OpRegion, Buffer,
300  * BufferField, or Package), the name of the object is already
301  * in the namespace.
302  */
303  if (WalkState->DeferredNode)
304  {
305  /* This name is already in the namespace, get the node */
306 
307  Node = WalkState->DeferredNode;
308  Status = AE_OK;
309  break;
310  }
311 
312  /*
313  * If we are executing a method, do not create any namespace objects
314  * during the load phase, only during execution.
315  */
316  if (WalkState->MethodNode)
317  {
318  Node = NULL;
319  Status = AE_OK;
320  break;
321  }
322 
324  if ((WalkState->Opcode != AML_SCOPE_OP) &&
325  (!(WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP)))
326  {
327  if (WalkState->NamespaceOverride)
328  {
330  ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Override allowed\n",
332  }
333  else
334  {
336  ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist\n",
338  }
339  }
340  else
341  {
343  "[%s] Both Find or Create allowed\n",
345  }
346 
347  /*
348  * Enter the named type into the internal namespace. We enter the name
349  * as we go downward in the parse tree. Any necessary subobjects that
350  * involve arguments to the opcode must be created as we go back up the
351  * parse tree later.
352  */
353  Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
354  ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
355  if (ACPI_FAILURE (Status))
356  {
357  if (Status == AE_ALREADY_EXISTS)
358  {
359  /* The name already exists in this scope */
360 
361  if (Node->Flags & ANOBJ_IS_EXTERNAL)
362  {
363  /*
364  * Allow one create on an object or segment that was
365  * previously declared External
366  */
367  Node->Flags &= ~ANOBJ_IS_EXTERNAL;
368  Node->Type = (UINT8) ObjectType;
369 
370  /* Just retyped a node, probably will need to open a scope */
371 
373  {
375  Node, ObjectType, WalkState);
376  if (ACPI_FAILURE (Status))
377  {
379  }
380  }
381 
382  Status = AE_OK;
383  }
384  }
385 
386  if (ACPI_FAILURE (Status))
387  {
388  ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, Path, Status);
390  }
391  }
392  break;
393  }
394 
395  /* Common exit */
396 
397  if (!Op)
398  {
399  /* Create a new op */
400 
401  Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml);
402  if (!Op)
403  {
405  }
406  }
407 
408  /* Initialize the op */
409 
410 #ifdef ACPI_CONSTANT_EVAL_ONLY
411  Op->Named.Path = Path;
412 #endif
413 
414  if (Node)
415  {
416  /*
417  * Put the Node in the "op" object that the parser uses, so we
418  * can get it again quickly when this scope is closed
419  */
420  Op->Common.Node = Node;
421  Op->Named.Name = Node->Name.Integer;
422  }
423 
425  *OutOp = Op;
427 }
428 
429 
430 /*******************************************************************************
431  *
432  * FUNCTION: AcpiDsLoad1EndOp
433  *
434  * PARAMETERS: WalkState - Current state of the parse tree walk
435  *
436  * RETURN: Status
437  *
438  * DESCRIPTION: Ascending callback used during the loading of the namespace,
439  * both control methods and everything else.
440  *
441  ******************************************************************************/
442 
445  ACPI_WALK_STATE *WalkState)
446 {
447  ACPI_PARSE_OBJECT *Op;
450 
451 #ifdef ACPI_ASL_COMPILER
452  UINT8 ParamCount;
453 #endif
454 
455 
456  ACPI_FUNCTION_TRACE (DsLoad1EndOp);
457 
458 
459  Op = WalkState->Op;
460  ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
461 
462  /*
463  * Disassembler: handle create field operators here.
464  *
465  * CreateBufferField is a deferred op that is typically processed in load
466  * pass 2. However, disassembly of control method contents walk the parse
467  * tree with ACPI_PARSE_LOAD_PASS1 and AML_CREATE operators are processed
468  * in a later walk. This is a problem when there is a control method that
469  * has the same name as the AML_CREATE object. In this case, any use of the
470  * name segment will be detected as a method call rather than a reference
471  * to a buffer field.
472  *
473  * This earlier creation during disassembly solves this issue by inserting
474  * the named object in the ACPI namespace so that references to this name
475  * would be a name string rather than a method call.
476  */
477  if ((WalkState->ParseFlags & ACPI_PARSE_DISASSEMBLE) &&
478  (WalkState->OpInfo->Flags & AML_CREATE))
479  {
480  Status = AcpiDsCreateBufferField (Op, WalkState);
482  }
483 
484  /* We are only interested in opcodes that have an associated name */
485 
486  if (!(WalkState->OpInfo->Flags & (AML_NAMED | AML_FIELD)))
487  {
489  }
490 
491  /* Get the object type to determine if we should pop the scope */
492 
493  ObjectType = WalkState->OpInfo->ObjectType;
494 
495  if (WalkState->OpInfo->Flags & AML_FIELD)
496  {
497  /*
498  * If we are executing a method, do not create any namespace objects
499  * during the load phase, only during execution.
500  */
501  if (!WalkState->MethodNode)
502  {
503  if (WalkState->Opcode == AML_FIELD_OP ||
504  WalkState->Opcode == AML_BANK_FIELD_OP ||
505  WalkState->Opcode == AML_INDEX_FIELD_OP)
506  {
507  Status = AcpiDsInitFieldObjects (Op, WalkState);
508  }
509  }
511  }
512 
513  /*
514  * If we are executing a method, do not create any namespace objects
515  * during the load phase, only during execution.
516  */
517  if (!WalkState->MethodNode)
518  {
519  if (Op->Common.AmlOpcode == AML_REGION_OP)
520  {
523  ((Op->Common.Value.Arg)->Common.Value.Integer),
524  WalkState);
525  if (ACPI_FAILURE (Status))
526  {
528  }
529  }
530  else if (Op->Common.AmlOpcode == AML_DATA_REGION_OP)
531  {
533  ACPI_ADR_SPACE_DATA_TABLE, WalkState);
534  if (ACPI_FAILURE (Status))
535  {
537  }
538  }
539  }
540 
541  if (Op->Common.AmlOpcode == AML_NAME_OP)
542  {
543  /* For Name opcode, get the object type from the argument */
544 
545  if (Op->Common.Value.Arg)
546  {
548  (Op->Common.Value.Arg)->Common.AmlOpcode))->ObjectType;
549 
550  /* Set node type if we have a namespace node */
551 
552  if (Op->Common.Node)
553  {
554  Op->Common.Node->Type = (UINT8) ObjectType;
555  }
556  }
557  }
558 
559 #ifdef ACPI_ASL_COMPILER
560  /*
561  * For external opcode, get the object type from the argument and
562  * get the parameter count from the argument's next.
563  */
564  if (AcpiGbl_DisasmFlag &&
565  Op->Common.Node &&
566  Op->Common.AmlOpcode == AML_EXTERNAL_OP)
567  {
568  /*
569  * Note, if this external is not a method
570  * Op->Common.Value.Arg->Common.Next->Common.Value.Integer == 0
571  * Therefore, ParamCount will be 0.
572  */
573  ParamCount = (UINT8) Op->Common.Value.Arg->Common.Next->Common.Value.Integer;
574  ObjectType = (UINT8) Op->Common.Value.Arg->Common.Value.Integer;
575  Op->Common.Node->Flags |= ANOBJ_IS_EXTERNAL;
576  Op->Common.Node->Type = (UINT8) ObjectType;
577 
579  &Op->Common.Node, ParamCount);
580 
581  /*
582  * Add the external to the external list because we may be
583  * emitting code based off of the items within the external list.
584  */
585  AcpiDmAddOpToExternalList (Op, Op->Named.Path, (UINT8)ObjectType, ParamCount,
587  }
588 #endif
589 
590  /*
591  * If we are executing a method, do not create any namespace objects
592  * during the load phase, only during execution.
593  */
594  if (!WalkState->MethodNode)
595  {
596  if (Op->Common.AmlOpcode == AML_METHOD_OP)
597  {
598  /*
599  * MethodOp PkgLength NameString MethodFlags TermList
600  *
601  * Note: We must create the method node/object pair as soon as we
602  * see the method declaration. This allows later pass1 parsing
603  * of invocations of the method (need to know the number of
604  * arguments.)
605  */
607  "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
608  WalkState, Op, Op->Named.Node));
609 
610  if (!AcpiNsGetAttachedObject (Op->Named.Node))
611  {
612  WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node);
613  WalkState->NumOperands = 1;
614 
616  WalkState, Op->Common.Value.Arg);
617  if (ACPI_SUCCESS (Status))
618  {
620  Op->Named.Length, WalkState);
621  }
622 
623  WalkState->Operands[0] = NULL;
624  WalkState->NumOperands = 0;
625 
626  if (ACPI_FAILURE (Status))
627  {
629  }
630  }
631  }
632  }
633 
634  /* Pop the scope stack (only if loading a table) */
635 
636  if (!WalkState->MethodNode &&
637  Op->Common.AmlOpcode != AML_EXTERNAL_OP &&
639  {
640  ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n",
642 
643  Status = AcpiDsScopeStackPop (WalkState);
644  }
645 
647 }
ACPI_STATUS AcpiDsCreateOperands(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *FirstArg)
Definition: dsutils.c:753
#define ACPI_NS_SEARCH_PARENT
Definition: acnamesp.h:63
ACPI_STATUS AcpiDsInitFieldObjects(ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
Definition: dsfield.c:603
ObjectType
Definition: metafile.c:80
ACPI_PARSE_OBJ_COMMON Common
Definition: aclocal.h:1078
#define AML_NAMED
Definition: amlcode.h:323
UINT8 ACPI_ADR_SPACE_TYPE
Definition: actypes.h:850
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
ACPI_STATUS AcpiNsLookup(ACPI_GENERIC_STATE *ScopeInfo, char *Name, ACPI_OBJECT_TYPE Type, ACPI_INTERPRETER_MODE InterpreterMode, UINT32 Flags, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE **RetNode)
Definition: nsaccess.c:329
#define ACPI_TYPE_THERMAL
Definition: actypes.h:692
ACPI_STATUS AcpiDsScopeStackPop(ACPI_WALK_STATE *WalkState)
Definition: dswscope.c:192
#define AE_NO_MEMORY
Definition: acexcep.h:112
ACPI_STATUS AcpiDsLoad2BeginOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp)
Definition: dswload2.c:71
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
UINT8 NumOperands
Definition: acstruct.h:80
#define ACPI_TYPE_BUFFER
Definition: actypes.h:682
#define ACPI_TYPE_INTEGER
Definition: actypes.h:680
#define ACPI_EXT_RESOLVED_REFERENCE
Definition: aclocal.h:1379
#define ACPI_TYPE_POWER
Definition: actypes.h:690
ACPI_STATUS AcpiDsScopeStackPush(ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_TYPE Type, ACPI_WALK_STATE *WalkState)
Definition: dswscope.c:107
UINT8 ObjectType
Definition: aclocal.h:874
struct acpi_namespace_node * DeferredNode
Definition: acstruct.h:111
const ACPI_OPCODE_INFO * AcpiPsGetOpcodeInfo(UINT16 Opcode)
Definition: psopinfo.c:72
ACPI_PARSE_OBJECT * AcpiPsGetParentScope(ACPI_PARSE_STATE *state)
Definition: psscope.c:65
ACPI_PARSE_OBJECT * AcpiPsAllocOp(UINT16 Opcode, UINT8 *Aml)
Definition: psutils.c:130
#define ACPI_NS_ERROR_IF_FOUND
Definition: acnamesp.h:66
#define ACPI_ADR_SPACE_DATA_TABLE
Definition: actypes.h:874
ACPI_STATUS AcpiDsLoad1BeginOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp)
Definition: dswload.c:145
UINT32 ParseFlags
Definition: acstruct.h:95
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_PARSE_EXECUTE
Definition: acparser.h:61
void AcpiDmCreateSubobjectForExternal(UINT8 Type, ACPI_NAMESPACE_NODE **Node, UINT32 Value)
#define AE_AML_OPERAND_TYPE
Definition: acexcep.h:182
#define AML_EXTERNAL_OP
Definition: amlcode.h:65
#define AML_REGION_OP
Definition: amlcode.h:180
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
char * AcpiPsGetNextNamestring(ACPI_PARSE_STATE *ParserState)
Definition: psargs.c:172
#define AML_NAME_OP
Definition: amlcode.h:54
ACPI_STATUS AcpiExCreateMethod(UINT8 *AmlStart, UINT32 AmlLength, ACPI_WALK_STATE *WalkState)
Definition: excreate.c:483
#define AML_CREATE
Definition: amlcode.h:320
ACPI_STATUS AcpiDsInitCallbacks(ACPI_WALK_STATE *WalkState, UINT32 PassNumber)
Definition: dswload.c:74
unsigned int UINT32
union node Node
Definition: types.h:1255
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define AE_INFO
Definition: acoutput.h:230
smooth NULL
Definition: ftsmooth.c:416
UINT32 ACPI_OBJECT_TYPE
Definition: actypes.h:677
#define ACPI_FUNCTION_TRACE_PTR(a, b)
Definition: acoutput.h:481
ACPI_STATUS AcpiDsLoad1EndOp(ACPI_WALK_STATE *WalkState)
Definition: dswload.c:444
ACPI_PARSE_OBJ_NAMED Named
Definition: aclocal.h:1079
UINT32 AcpiNsOpensScope(ACPI_OBJECT_TYPE Type)
Definition: nsutils.c:736
void AcpiDmAddOpToExternalList(ACPI_PARSE_OBJECT *Op, char *Path, UINT8 Type, UINT32 Value, UINT16 Flags)
#define ACPI_DB_DISPATCH
Definition: acoutput.h:163
#define AML_BANK_FIELD_OP
Definition: amlcode.h:187
#define ACPI_TYPE_METHOD
Definition: actypes.h:687
ACPI_STATUS AcpiExCreateRegion(UINT8 *AmlStart, UINT32 AmlLength, UINT8 SpaceId, ACPI_WALK_STATE *WalkState)
Definition: excreate.c:268
ACPI_STATUS AcpiDsLoad2EndOp(ACPI_WALK_STATE *WalkState)
Definition: dswload2.c:415
ACPI_PARSE_OBJECT * Op
Definition: acstruct.h:118
#define AE_ALREADY_EXISTS
Definition: acexcep.h:115
#define ACPI_PARSE_LOAD_PASS1
Definition: acparser.h:59
#define AML_FIELD_OP
Definition: amlcode.h:181
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
void AcpiPsAppendArg(ACPI_PARSE_OBJECT *op, ACPI_PARSE_OBJECT *arg)
Definition: pstree.c:138
#define AML_FIELD
Definition: amlcode.h:321
#define AML_SCOPE_OP
Definition: amlcode.h:60
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
#define AE_NOT_FOUND
Definition: acexcep.h:113
const ACPI_OPCODE_INFO * OpInfo
Definition: acstruct.h:119
#define AML_INDEX_FIELD_OP
Definition: amlcode.h:186
ACPI_GENERIC_STATE * ScopeInfo
Definition: acstruct.h:124
#define ACPI_EXT_ORIGIN_FROM_OPCODE
Definition: aclocal.h:1383
#define ACPI_TYPE_ANY
Definition: actypes.h:679
ACPI_PARSE_STATE ParserState
Definition: acstruct.h:97
#define AML_METHOD_OP
Definition: amlcode.h:64
ACPI_STATUS AcpiDsExecBeginOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp)
Definition: dswexec.c:232
#define ACPI_TYPE_DEVICE
Definition: actypes.h:685
struct acpi_namespace_node * MethodNode
Definition: acstruct.h:116
ACPI_COMMON_STATE Common
Definition: aclocal.h:822
#define ACPI_TYPE_PROCESSOR
Definition: actypes.h:691
Status
Definition: gdiplustypes.h:24
BOOLEAN NamespaceOverride
Definition: acstruct.h:88
#define ACPI_PARSE_DISASSEMBLE
Definition: acparser.h:65
union acpi_operand_object * Operands[ACPI_OBJ_NUM_OPERANDS+1]
Definition: acstruct.h:105
#define ACPI_DB_INFO
Definition: acoutput.h:153
PRTL_UNICODE_STRING_BUFFER Path
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_NS_NO_UPSEARCH
Definition: acnamesp.h:62
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
#define ACPI_PARSE_MODULE_LEVEL
Definition: acparser.h:67
ACPI_PARSE_COMMON char * Path
Definition: aclocal.h:1032
#define ACPI_NS_OVERRIDE_IF_FOUND
Definition: acnamesp.h:70
const char * AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:249
ACPI_STATUS AcpiDsExecEndOp(ACPI_WALK_STATE *WalkState)
Definition: dswexec.c:390
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:305
#define ACPI_TYPE_LOCAL_SCOPE
Definition: actypes.h:718
UINT16 Opcode
Definition: acstruct.h:78
#define ACPI_TYPE_STRING
Definition: actypes.h:681
ACPI_STATUS AcpiDsCreateBufferField(ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
Definition: dsfield.c:165
#define ACPI_PARSE_DEFERRED_OP
Definition: acparser.h:64
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
#define ACPI_ERROR_NAMESPACE(s, p, e)
Definition: acmacros.h:462
unsigned char UINT8
#define AML_DATA_REGION_OP
Definition: amlcode.h:188
#define AE_OK
Definition: acexcep.h:97
UINT16 Flags
Definition: aclocal.h:873
#define ACPI_PARSE_DELETE_TREE
Definition: acparser.h:55
Definition: dlist.c:348
UINT8 * Aml
Definition: acstruct.h:91
#define ANOBJ_IS_EXTERNAL
Definition: aclocal.h:224