ReactOS  0.4.14-dev-552-g2fad488
nsinit.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: nsinit - namespace initialization
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2019, 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 "acnamesp.h"
47 #include "acdispat.h"
48 #include "acinterp.h"
49 #include "acevents.h"
50 
51 #define _COMPONENT ACPI_NAMESPACE
52  ACPI_MODULE_NAME ("nsinit")
53 
54 /* Local prototypes */
55 
56 static ACPI_STATUS
58  ACPI_HANDLE ObjHandle,
59  UINT32 Level,
60  void *Context,
61  void **ReturnValue);
62 
63 static ACPI_STATUS
65  ACPI_HANDLE ObjHandle,
66  UINT32 NestingLevel,
67  void *Context,
68  void **ReturnValue);
69 
70 static ACPI_STATUS
72  ACPI_HANDLE ObjHandle,
73  UINT32 NestingLevel,
74  void *Context,
75  void **ReturnValue);
76 
77 
78 /*******************************************************************************
79  *
80  * FUNCTION: AcpiNsInitializeObjects
81  *
82  * PARAMETERS: None
83  *
84  * RETURN: Status
85  *
86  * DESCRIPTION: Walk the entire namespace and perform any necessary
87  * initialization on the objects found therein
88  *
89  ******************************************************************************/
90 
93  void)
94 {
97 
98 
99  ACPI_FUNCTION_TRACE (NsInitializeObjects);
100 
101 
103  "[Init] Completing Initialization of ACPI Objects\n"));
105  "**** Starting initialization of namespace objects ****\n"));
107  "Final data object initialization: "));
108 
109  /* Clear the info block */
110 
111  memset (&Info, 0, sizeof (ACPI_INIT_WALK_INFO));
112 
113  /* Walk entire namespace from the supplied root */
114 
115  /*
116  * TBD: will become ACPI_TYPE_PACKAGE as this type object
117  * is now the only one that supports deferred initialization
118  * (forward references).
119  */
122  if (ACPI_FAILURE (Status))
123  {
124  ACPI_EXCEPTION ((AE_INFO, Status, "During WalkNamespace"));
125  }
126 
128  "Namespace contains %u (0x%X) objects\n",
129  Info.ObjectCount,
130  Info.ObjectCount));
131 
133  "%u Control Methods found\n%u Op Regions found\n",
134  Info.MethodCount, Info.OpRegionCount));
135 
137 }
138 
139 
140 /*******************************************************************************
141  *
142  * FUNCTION: AcpiNsInitializeDevices
143  *
144  * PARAMETERS: None
145  *
146  * RETURN: ACPI_STATUS
147  *
148  * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices.
149  * This means running _INI on all present devices.
150  *
151  * Note: We install PCI config space handler on region access,
152  * not here.
153  *
154  ******************************************************************************/
155 
158  UINT32 Flags)
159 {
163 
164 
165  ACPI_FUNCTION_TRACE (NsInitializeDevices);
166 
167 
168  if (!(Flags & ACPI_NO_DEVICE_INIT))
169  {
171  "[Init] Initializing ACPI Devices\n"));
172 
173  /* Init counters */
174 
175  Info.DeviceCount = 0;
176  Info.Num_STA = 0;
177  Info.Num_INI = 0;
178 
180  "Initializing Device/Processor/Thermal objects "
181  "and executing _INI/_STA methods:\n"));
182 
183  /* Tree analysis: find all subtrees that contain _INI methods */
184 
187  if (ACPI_FAILURE (Status))
188  {
189  goto ErrorExit;
190  }
191 
192  /* Allocate the evaluation information block */
193 
194  Info.EvaluateInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
195  if (!Info.EvaluateInfo)
196  {
198  goto ErrorExit;
199  }
200 
201  /*
202  * Execute the "global" _INI method that may appear at the root.
203  * This support is provided for Windows compatibility (Vista+) and
204  * is not part of the ACPI specification.
205  */
206  Info.EvaluateInfo->PrefixNode = AcpiGbl_RootNode;
207  Info.EvaluateInfo->RelativePathname = METHOD_NAME__INI;
208  Info.EvaluateInfo->Parameters = NULL;
209  Info.EvaluateInfo->Flags = ACPI_IGNORE_RETURN_VALUE;
210 
211  Status = AcpiNsEvaluate (Info.EvaluateInfo);
212  if (ACPI_SUCCESS (Status))
213  {
214  Info.Num_INI++;
215  }
216 
217  /*
218  * Execute \_SB._INI.
219  * There appears to be a strict order requirement for \_SB._INI,
220  * which should be evaluated before any _REG evaluations.
221  */
222  Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
223  if (ACPI_SUCCESS (Status))
224  {
225  memset (Info.EvaluateInfo, 0, sizeof (ACPI_EVALUATE_INFO));
226  Info.EvaluateInfo->PrefixNode = Handle;
227  Info.EvaluateInfo->RelativePathname = METHOD_NAME__INI;
228  Info.EvaluateInfo->Parameters = NULL;
229  Info.EvaluateInfo->Flags = ACPI_IGNORE_RETURN_VALUE;
230 
231  Status = AcpiNsEvaluate (Info.EvaluateInfo);
232  if (ACPI_SUCCESS (Status))
233  {
234  Info.Num_INI++;
235  }
236  }
237  }
238 
239  /*
240  * Run all _REG methods
241  *
242  * Note: Any objects accessed by the _REG methods will be automatically
243  * initialized, even if they contain executable AML (see the call to
244  * AcpiNsInitializeObjects below).
245  *
246  * Note: According to the ACPI specification, we actually needn't execute
247  * _REG for SystemMemory/SystemIo operation regions, but for PCI_Config
248  * operation regions, it is required to evaluate _REG for those on a PCI
249  * root bus that doesn't contain _BBN object. So this code is kept here
250  * in order not to break things.
251  */
253  {
255  "[Init] Executing _REG OpRegion methods\n"));
256 
258  if (ACPI_FAILURE (Status))
259  {
260  goto ErrorExit;
261  }
262  }
263 
264  if (!(Flags & ACPI_NO_DEVICE_INIT))
265  {
266  /* Walk namespace to execute all _INIs on present devices */
267 
270 
271  /*
272  * Any _OSI requests should be completed by now. If the BIOS has
273  * requested any Windows OSI strings, we will always truncate
274  * I/O addresses to 16 bits -- for Windows compatibility.
275  */
276  if (AcpiGbl_OsiData >= ACPI_OSI_WIN_2000)
277  {
278  AcpiGbl_TruncateIoAddresses = TRUE;
279  }
280 
281  ACPI_FREE (Info.EvaluateInfo);
282  if (ACPI_FAILURE (Status))
283  {
284  goto ErrorExit;
285  }
286 
288  " Executed %u _INI methods requiring %u _STA executions "
289  "(examined %u objects)\n",
290  Info.Num_INI, Info.Num_STA, Info.DeviceCount));
291  }
292 
294 
295 
296 ErrorExit:
297  ACPI_EXCEPTION ((AE_INFO, Status, "During device initialization"));
299 }
300 
301 
302 /*******************************************************************************
303  *
304  * FUNCTION: AcpiNsInitOnePackage
305  *
306  * PARAMETERS: ObjHandle - Node
307  * Level - Current nesting level
308  * Context - Not used
309  * ReturnValue - Not used
310  *
311  * RETURN: Status
312  *
313  * DESCRIPTION: Callback from AcpiWalkNamespace. Invoked for every package
314  * within the namespace. Used during dynamic load of an SSDT.
315  *
316  ******************************************************************************/
317 
320  ACPI_HANDLE ObjHandle,
321  UINT32 Level,
322  void *Context,
323  void **ReturnValue)
324 {
326  ACPI_OPERAND_OBJECT *ObjDesc;
328 
329 
330  ObjDesc = AcpiNsGetAttachedObject (Node);
331  if (!ObjDesc)
332  {
333  return (AE_OK);
334  }
335 
336  /* Exit if package is already initialized */
337 
338  if (ObjDesc->Package.Flags & AOPOBJ_DATA_VALID)
339  {
340  return (AE_OK);
341  }
342 
343  Status = AcpiDsGetPackageArguments (ObjDesc);
344  if (ACPI_FAILURE (Status))
345  {
346  return (AE_OK);
347  }
348 
350  NULL);
351  if (ACPI_FAILURE (Status))
352  {
353  return (AE_OK);
354  }
355 
356  ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
357  return (AE_OK);
358 }
359 
360 
361 /*******************************************************************************
362  *
363  * FUNCTION: AcpiNsInitOneObject
364  *
365  * PARAMETERS: ObjHandle - Node
366  * Level - Current nesting level
367  * Context - Points to a init info struct
368  * ReturnValue - Not used
369  *
370  * RETURN: Status
371  *
372  * DESCRIPTION: Callback from AcpiWalkNamespace. Invoked for every object
373  * within the namespace.
374  *
375  * Currently, the only objects that require initialization are:
376  * 1) Methods
377  * 2) Op Regions
378  *
379  ******************************************************************************/
380 
381 static ACPI_STATUS
383  ACPI_HANDLE ObjHandle,
384  UINT32 Level,
385  void *Context,
386  void **ReturnValue)
387 {
392  ACPI_OPERAND_OBJECT *ObjDesc;
393 
394 
395  ACPI_FUNCTION_NAME (NsInitOneObject);
396 
397 
398  Info->ObjectCount++;
399 
400  /* And even then, we are only interested in a few object types */
401 
402  Type = AcpiNsGetType (ObjHandle);
403  ObjDesc = AcpiNsGetAttachedObject (Node);
404  if (!ObjDesc)
405  {
406  return (AE_OK);
407  }
408 
409  /* Increment counters for object types we are looking for */
410 
411  switch (Type)
412  {
413  case ACPI_TYPE_REGION:
414 
415  Info->OpRegionCount++;
416  break;
417 
419 
420  Info->FieldCount++;
421  break;
422 
424 
425  Info->FieldCount++;
426  break;
427 
428  case ACPI_TYPE_BUFFER:
429 
430  Info->BufferCount++;
431  break;
432 
433  case ACPI_TYPE_PACKAGE:
434 
435  Info->PackageCount++;
436  break;
437 
438  default:
439 
440  /* No init required, just exit now */
441 
442  return (AE_OK);
443  }
444 
445  /* If the object is already initialized, nothing else to do */
446 
447  if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
448  {
449  return (AE_OK);
450  }
451 
452  /* Must lock the interpreter before executing AML code */
453 
455 
456  /*
457  * Only initialization of Package objects can be deferred, in order
458  * to support forward references.
459  */
460  switch (Type)
461  {
463 
464  /* TBD: BankFields do not require deferred init, remove this code */
465 
466  Info->FieldInit++;
468  break;
469 
470  case ACPI_TYPE_PACKAGE:
471 
472  /* Complete the initialization/resolution of the package object */
473 
474  Info->PackageInit++;
475  Status = AcpiNsInitOnePackage (ObjHandle, Level, NULL, NULL);
476  break;
477 
478  default:
479 
480  /* No other types should get here */
481 
482  Status = AE_TYPE;
484  "Opcode is not deferred [%4.4s] (%s)",
486  break;
487  }
488 
489  if (ACPI_FAILURE (Status))
490  {
492  "Could not execute arguments for [%4.4s] (%s)",
494  }
495 
496  /*
497  * We ignore errors from above, and always return OK, since we don't want
498  * to abort the walk on any single error.
499  */
501  return (AE_OK);
502 }
503 
504 
505 /*******************************************************************************
506  *
507  * FUNCTION: AcpiNsFindIniMethods
508  *
509  * PARAMETERS: ACPI_WALK_CALLBACK
510  *
511  * RETURN: ACPI_STATUS
512  *
513  * DESCRIPTION: Called during namespace walk. Finds objects named _INI under
514  * device/processor/thermal objects, and marks the entire subtree
515  * with a SUBTREE_HAS_INI flag. This flag is used during the
516  * subsequent device initialization walk to avoid entire subtrees
517  * that do not contain an _INI.
518  *
519  ******************************************************************************/
520 
521 static ACPI_STATUS
523  ACPI_HANDLE ObjHandle,
524  UINT32 NestingLevel,
525  void *Context,
526  void **ReturnValue)
527 {
530  ACPI_NAMESPACE_NODE *ParentNode;
531 
532 
533  /* Keep count of device/processor/thermal objects */
534 
535  Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
536  if ((Node->Type == ACPI_TYPE_DEVICE) ||
537  (Node->Type == ACPI_TYPE_PROCESSOR) ||
538  (Node->Type == ACPI_TYPE_THERMAL))
539  {
540  Info->DeviceCount++;
541  return (AE_OK);
542  }
543 
544  /* We are only looking for methods named _INI */
545 
546  if (!ACPI_COMPARE_NAMESEG (Node->Name.Ascii, METHOD_NAME__INI))
547  {
548  return (AE_OK);
549  }
550 
551  /*
552  * The only _INI methods that we care about are those that are
553  * present under Device, Processor, and Thermal objects.
554  */
555  ParentNode = Node->Parent;
556  switch (ParentNode->Type)
557  {
558  case ACPI_TYPE_DEVICE:
559  case ACPI_TYPE_PROCESSOR:
560  case ACPI_TYPE_THERMAL:
561 
562  /* Mark parent and bubble up the INI present flag to the root */
563 
564  while (ParentNode)
565  {
566  ParentNode->Flags |= ANOBJ_SUBTREE_HAS_INI;
567  ParentNode = ParentNode->Parent;
568  }
569  break;
570 
571  default:
572 
573  break;
574  }
575 
576  return (AE_OK);
577 }
578 
579 
580 /*******************************************************************************
581  *
582  * FUNCTION: AcpiNsInitOneDevice
583  *
584  * PARAMETERS: ACPI_WALK_CALLBACK
585  *
586  * RETURN: ACPI_STATUS
587  *
588  * DESCRIPTION: This is called once per device soon after ACPI is enabled
589  * to initialize each device. It determines if the device is
590  * present, and if so, calls _INI.
591  *
592  ******************************************************************************/
593 
594 static ACPI_STATUS
596  ACPI_HANDLE ObjHandle,
597  UINT32 NestingLevel,
598  void *Context,
599  void **ReturnValue)
600 {
602  ACPI_EVALUATE_INFO *Info = WalkInfo->EvaluateInfo;
603  UINT32 Flags;
606 
607 
608  ACPI_FUNCTION_TRACE (NsInitOneDevice);
609 
610 
611  /* We are interested in Devices, Processors and ThermalZones only */
612 
614  if ((DeviceNode->Type != ACPI_TYPE_DEVICE) &&
615  (DeviceNode->Type != ACPI_TYPE_PROCESSOR) &&
616  (DeviceNode->Type != ACPI_TYPE_THERMAL))
617  {
619  }
620 
621  /*
622  * Because of an earlier namespace analysis, all subtrees that contain an
623  * _INI method are tagged.
624  *
625  * If this device subtree does not contain any _INI methods, we
626  * can exit now and stop traversing this entire subtree.
627  */
628  if (!(DeviceNode->Flags & ANOBJ_SUBTREE_HAS_INI))
629  {
631  }
632 
633  /*
634  * Run _STA to determine if this device is present and functioning. We
635  * must know this information for two important reasons (from ACPI spec):
636  *
637  * 1) We can only run _INI if the device is present.
638  * 2) We must abort the device tree walk on this subtree if the device is
639  * not present and is not functional (we will not examine the children)
640  *
641  * The _STA method is not required to be present under the device, we
642  * assume the device is present if _STA does not exist.
643  */
644  ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (
646 
648  if (ACPI_FAILURE (Status))
649  {
650  /* Ignore error and move on to next device */
651 
653  }
654 
655  /*
656  * Flags == -1 means that _STA was not found. In this case, we assume that
657  * the device is both present and functional.
658  *
659  * From the ACPI spec, description of _STA:
660  *
661  * "If a device object (including the processor object) does not have an
662  * _STA object, then OSPM assumes that all of the above bits are set (in
663  * other words, the device is present, ..., and functioning)"
664  */
665  if (Flags != ACPI_UINT32_MAX)
666  {
667  WalkInfo->Num_STA++;
668  }
669 
670  /*
671  * Examine the PRESENT and FUNCTIONING status bits
672  *
673  * Note: ACPI spec does not seem to specify behavior for the present but
674  * not functioning case, so we assume functioning if present.
675  */
677  {
678  /* Device is not present, we must examine the Functioning bit */
679 
681  {
682  /*
683  * Device is not present but is "functioning". In this case,
684  * we will not run _INI, but we continue to examine the children
685  * of this device.
686  *
687  * From the ACPI spec, description of _STA: (Note - no mention
688  * of whether to run _INI or not on the device in question)
689  *
690  * "_STA may return bit 0 clear (not present) with bit 3 set
691  * (device is functional). This case is used to indicate a valid
692  * device for which no device driver should be loaded (for example,
693  * a bridge device.) Children of this device may be present and
694  * valid. OSPM should continue enumeration below a device whose
695  * _STA returns this bit combination"
696  */
698  }
699  else
700  {
701  /*
702  * Device is not present and is not functioning. We must abort the
703  * walk of this subtree immediately -- don't look at the children
704  * of such a device.
705  *
706  * From the ACPI spec, description of _INI:
707  *
708  * "If the _STA method indicates that the device is not present,
709  * OSPM will not run the _INI and will not examine the children
710  * of the device for _INI methods"
711  */
713  }
714  }
715 
716  /*
717  * The device is present or is assumed present if no _STA exists.
718  * Run the _INI if it exists (not required to exist)
719  *
720  * Note: We know there is an _INI within this subtree, but it may not be
721  * under this particular device, it may be lower in the branch.
722  */
723  if (!ACPI_COMPARE_NAMESEG (DeviceNode->Name.Ascii, "_SB_") ||
724  DeviceNode->Parent != AcpiGbl_RootNode)
725  {
726  ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (
728 
729  memset (Info, 0, sizeof (ACPI_EVALUATE_INFO));
730  Info->PrefixNode = DeviceNode;
731  Info->RelativePathname = METHOD_NAME__INI;
732  Info->Parameters = NULL;
734 
736  if (ACPI_SUCCESS (Status))
737  {
738  WalkInfo->Num_INI++;
739  }
740 
741 #ifdef ACPI_DEBUG_OUTPUT
742  else if (Status != AE_NOT_FOUND)
743  {
744  /* Ignore error and move on to next device */
745 
746  char *ScopeName = AcpiNsGetNormalizedPathname (DeviceNode, TRUE);
747 
748  ACPI_EXCEPTION ((AE_INFO, Status, "during %s._INI execution",
749  ScopeName));
750  ACPI_FREE (ScopeName);
751  }
752 #endif
753  }
754 
755  /* Ignore errors from above */
756 
757  Status = AE_OK;
758 
759  /*
760  * The _INI method has been run if present; call the Global Initialization
761  * Handler for this device.
762  */
763  if (AcpiGbl_InitHandler)
764  {
765  Status = AcpiGbl_InitHandler (DeviceNode, ACPI_INIT_DEVICE_INI);
766  }
767 
769 }
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
#define ACPI_DEBUG_PRINT_RAW(pl)
Definition: acoutput.h:476
#define ACPI_FREE(a)
Definition: actypes.h:386
ACPI_STATUS AcpiDsGetBankFieldArguments(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: dsargs.c:245
#define ACPI_ALLOCATE_ZEROED(a)
Definition: actypes.h:385
#define TRUE
Definition: types.h:120
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
#define ACPI_TYPE_THERMAL
Definition: actypes.h:691
Type
Definition: Type.h:6
#define AE_NO_MEMORY
Definition: acexcep.h:112
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
ACPI_OBJECT_PACKAGE Package
Definition: acobject.h:520
ACPI_STATUS AcpiWalkNamespace(ACPI_OBJECT_TYPE Type, ACPI_HANDLE StartObject, UINT32 MaxDepth, ACPI_WALK_CALLBACK DescendingCallback, ACPI_WALK_CALLBACK AscendingCallback, void *Context, void **ReturnValue)
Definition: nsxfeval.c:640
#define ACPI_TYPE_BUFFER
Definition: actypes.h:681
ACPI_STATUS AcpiNsEvaluate(ACPI_EVALUATE_INFO *Info)
Definition: nseval.c:82
#define METHOD_NAME__STA
Definition: acnames.h:73
#define AE_CTRL_DEPTH
Definition: acexcep.h:229
ACPI_STATUS AcpiUtWalkPackageTree(ACPI_OPERAND_OBJECT *SourceObject, void *TargetObject, ACPI_PKG_CALLBACK WalkCallback, void *Context)
Definition: utmisc.c:264
#define ACPI_INIT_DEVICE_INI
Definition: actypes.h:1161
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:55
UINT32 ACPI_STATUS
Definition: actypes.h:460
ACPI_EVALUATE_INFO * EvaluateInfo
Definition: acstruct.h:244
struct acpi_namespace_node * Parent
Definition: aclocal.h:192
ACPI_STATUS AcpiNsInitializeDevices(UINT32 Flags)
Definition: nsinit.c:157
struct TraceInfo Info
#define ACPI_NO_DEVICE_INIT
Definition: actypes.h:601
ACPI_STATUS AcpiNsWalkNamespace(ACPI_OBJECT_TYPE Type, ACPI_HANDLE StartObject, UINT32 MaxDepth, UINT32 Flags, ACPI_WALK_CALLBACK DescendingCallback, ACPI_WALK_CALLBACK AscendingCallback, void *Context, void **ReturnValue)
Definition: nswalk.c:190
static ACPI_STATUS AcpiNsFindIniMethods(ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context, void **ReturnValue)
Definition: nsinit.c:522
ACPI_OBJECT_TYPE AcpiNsGetType(ACPI_NAMESPACE_NODE *Node)
Definition: nsutils.c:120
#define ACPI_DEBUG_EXEC(a)
Definition: acoutput.h:477
#define ACPI_TYPE_PACKAGE
Definition: actypes.h:682
#define ACPI_STA_DEVICE_PRESENT
Definition: actypes.h:1314
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
UINT32 void void ** ReturnValue
Definition: acevents.h:214
unsigned int UINT32
ACPI_STATUS AcpiNsInitOnePackage(ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue)
Definition: nsinit.c:319
union node Node
Definition: types.h:1255
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define ACPI_OSI_WIN_2000
Definition: actypes.h:1396
#define AE_INFO
Definition: acoutput.h:230
smooth NULL
Definition: ftsmooth.c:416
UINT32 ACPI_OBJECT_TYPE
Definition: actypes.h:676
#define ANOBJ_SUBTREE_HAS_INI
Definition: aclocal.h:219
#define ACPI_ROOT_OBJECT
Definition: actypes.h:500
#define ACPI_DB_DISPATCH
Definition: acoutput.h:163
_In_ HANDLE Handle
Definition: extypes.h:390
#define ACPI_TYPE_METHOD
Definition: actypes.h:686
#define ACPI_UINT32_MAX
Definition: actypes.h:66
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
#define AE_NOT_FOUND
Definition: acexcep.h:113
ACPI_STATUS AcpiGetHandle(ACPI_HANDLE Parent, ACPI_STRING Pathname, ACPI_HANDLE *RetHandle)
Definition: nsxfname.c:85
#define ACPI_COMPARE_NAMESEG(a, b)
Definition: actypes.h:561
Definition: Node.h:9
#define ACPI_TYPE_ANY
Definition: actypes.h:678
#define ACPI_TYPE_DEVICE
Definition: actypes.h:684
#define AE_TYPE
Definition: acexcep.h:116
ACPI_STATUS AcpiUtExecute_STA(ACPI_NAMESPACE_NODE *DeviceNode, UINT32 *StatusFlags)
Definition: uteval.c:269
#define ACPI_TYPE_PROCESSOR
Definition: actypes.h:690
Status
Definition: gdiplustypes.h:24
#define ACPI_DB_INIT
Definition: acoutput.h:151
#define METHOD_NAME__INI
Definition: acnames.h:59
char * AcpiNsGetNormalizedPathname(ACPI_NAMESPACE_NODE *Node, BOOLEAN NoTrailing)
Definition: nsnames.c:373
static ACPI_STATUS AcpiNsInitOneDevice(ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context, void **ReturnValue)
Definition: nsinit.c:595
#define ACPI_DB_EXEC
Definition: acoutput.h:165
void AcpiExExitInterpreter(void)
Definition: exutils.c:139
ACPI_STATUS AcpiDsInitPackageElement(UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context)
Definition: dspkginit.c:369
void AcpiExEnterInterpreter(void)
Definition: exutils.c:91
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
static VOID ErrorExit(LPTSTR lpszMessage)
Definition: telnetd.c:647
#define ACPI_TYPE_BUFFER_FIELD
Definition: actypes.h:692
ACPI_OBJECT_COMMON Common
Definition: acobject.h:516
#define ACPI_NO_ADDRESS_SPACE_INIT
Definition: actypes.h:602
const char * AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:249
static ACPI_STATUS AcpiNsInitOneObject(ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue)
Definition: nsinit.c:382
#define ACPI_STA_DEVICE_FUNCTIONING
Definition: actypes.h:1317
ACPI_STATUS AcpiDsGetPackageArguments(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: dsargs.c:344
ACPI_STATUS AcpiEvInitializeOpRegions(void)
Definition: evregion.c:84
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:305
#define AOPOBJ_DATA_VALID
Definition: acobject.h:96
#define ACPI_TYPE_REGION
Definition: actypes.h:688
#define ACPI_TYPE_LOCAL_BANK_FIELD
Definition: actypes.h:708
ACPI_STATUS AcpiNsInitializeObjects(void)
Definition: nsinit.c:92
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
#define ACPI_IGNORE_RETURN_VALUE
Definition: acstruct.h:231
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
#define memset(x, y, z)
Definition: compat.h:39
#define AE_OK
Definition: acexcep.h:97
Definition: dlist.c:348