ReactOS  0.4.15-dev-1386-g5cb9f87
evhandler.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: evhandler - Support for Address Space handlers
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 "acevents.h"
47 #include "acnamesp.h"
48 #include "acinterp.h"
49 
50 #define _COMPONENT ACPI_EVENTS
51  ACPI_MODULE_NAME ("evhandler")
52 
53 
54 /* Local prototypes */
55 
56 static ACPI_STATUS
58  ACPI_HANDLE ObjHandle,
59  UINT32 Level,
60  void *Context,
61  void **ReturnValue);
62 
63 
64 /* These are the address spaces that will get default handlers */
65 
67 {
72 };
73 
74 
75 /*******************************************************************************
76  *
77  * FUNCTION: AcpiEvInstallRegionHandlers
78  *
79  * PARAMETERS: None
80  *
81  * RETURN: Status
82  *
83  * DESCRIPTION: Installs the core subsystem default address space handlers.
84  *
85  ******************************************************************************/
86 
89  void)
90 {
92  UINT32 i;
93 
94 
95  ACPI_FUNCTION_TRACE (EvInstallRegionHandlers);
96 
97 
99  if (ACPI_FAILURE (Status))
100  {
102  }
103 
104  /*
105  * All address spaces (PCI Config, EC, SMBus) are scope dependent and
106  * registration must occur for a specific device.
107  *
108  * In the case of the system memory and IO address spaces there is
109  * currently no device associated with the address space. For these we
110  * use the root.
111  *
112  * We install the default PCI config space handler at the root so that
113  * this space is immediately available even though the we have not
114  * enumerated all the PCI Root Buses yet. This is to conform to the ACPI
115  * specification which states that the PCI config space must be always
116  * available -- even though we are nowhere near ready to find the PCI root
117  * buses at this point.
118  *
119  * NOTE: We ignore AE_ALREADY_EXISTS because this means that a handler
120  * has already been installed (via AcpiInstallAddressSpaceHandler).
121  * Similar for AE_SAME_HANDLER.
122  */
123  for (i = 0; i < ACPI_NUM_DEFAULT_SPACES; i++)
124  {
125  Status = AcpiEvInstallSpaceHandler (AcpiGbl_RootNode,
128  switch (Status)
129  {
130  case AE_OK:
131  case AE_SAME_HANDLER:
132  case AE_ALREADY_EXISTS:
133 
134  /* These exceptions are all OK */
135 
136  Status = AE_OK;
137  break;
138 
139  default:
140 
141  goto UnlockAndExit;
142  }
143  }
144 
145 UnlockAndExit:
148 }
149 
150 
151 /*******************************************************************************
152  *
153  * FUNCTION: AcpiEvHasDefaultHandler
154  *
155  * PARAMETERS: Node - Namespace node for the device
156  * SpaceId - The address space ID
157  *
158  * RETURN: TRUE if default handler is installed, FALSE otherwise
159  *
160  * DESCRIPTION: Check if the default handler is installed for the requested
161  * space ID.
162  *
163  ******************************************************************************/
164 
165 BOOLEAN
169 {
170  ACPI_OPERAND_OBJECT *ObjDesc;
171  ACPI_OPERAND_OBJECT *HandlerObj;
172 
173 
174  /* Must have an existing internal object */
175 
176  ObjDesc = AcpiNsGetAttachedObject (Node);
177  if (ObjDesc)
178  {
179  HandlerObj = ObjDesc->CommonNotify.Handler;
180 
181  /* Walk the linked list of handlers for this object */
182 
183  while (HandlerObj)
184  {
185  if (HandlerObj->AddressSpace.SpaceId == SpaceId)
186  {
187  if (HandlerObj->AddressSpace.HandlerFlags &
189  {
190  return (TRUE);
191  }
192  }
193 
194  HandlerObj = HandlerObj->AddressSpace.Next;
195  }
196  }
197 
198  return (FALSE);
199 }
200 
201 
202 /*******************************************************************************
203  *
204  * FUNCTION: AcpiEvInstallHandler
205  *
206  * PARAMETERS: WalkNamespace callback
207  *
208  * DESCRIPTION: This routine installs an address handler into objects that are
209  * of type Region or Device.
210  *
211  * If the Object is a Device, and the device has a handler of
212  * the same type then the search is terminated in that branch.
213  *
214  * This is because the existing handler is closer in proximity
215  * to any more regions than the one we are trying to install.
216  *
217  ******************************************************************************/
218 
219 static ACPI_STATUS
221  ACPI_HANDLE ObjHandle,
222  UINT32 Level,
223  void *Context,
224  void **ReturnValue)
225 {
226  ACPI_OPERAND_OBJECT *HandlerObj;
227  ACPI_OPERAND_OBJECT *NextHandlerObj;
228  ACPI_OPERAND_OBJECT *ObjDesc;
231 
232 
233  ACPI_FUNCTION_NAME (EvInstallHandler);
234 
235 
236  HandlerObj = (ACPI_OPERAND_OBJECT *) Context;
237 
238  /* Parameter validation */
239 
240  if (!HandlerObj)
241  {
242  return (AE_OK);
243  }
244 
245  /* Convert and validate the device handle */
246 
247  Node = AcpiNsValidateHandle (ObjHandle);
248  if (!Node)
249  {
250  return (AE_BAD_PARAMETER);
251  }
252 
253  /*
254  * We only care about regions and objects that are allowed to have
255  * address space handlers
256  */
257  if ((Node->Type != ACPI_TYPE_DEVICE) &&
258  (Node->Type != ACPI_TYPE_REGION) &&
259  (Node != AcpiGbl_RootNode))
260  {
261  return (AE_OK);
262  }
263 
264  /* Check for an existing internal object */
265 
266  ObjDesc = AcpiNsGetAttachedObject (Node);
267  if (!ObjDesc)
268  {
269  /* No object, just exit */
270 
271  return (AE_OK);
272  }
273 
274  /* Devices are handled different than regions */
275 
276  if (ObjDesc->Common.Type == ACPI_TYPE_DEVICE)
277  {
278  /* Check if this Device already has a handler for this address space */
279 
280  NextHandlerObj = AcpiEvFindRegionHandler (
281  HandlerObj->AddressSpace.SpaceId, ObjDesc->CommonNotify.Handler);
282  if (NextHandlerObj)
283  {
284  /* Found a handler, is it for the same address space? */
285 
287  "Found handler for region [%s] in device %p(%p) handler %p\n",
289  ObjDesc, NextHandlerObj, HandlerObj));
290 
291  /*
292  * Since the object we found it on was a device, then it means
293  * that someone has already installed a handler for the branch
294  * of the namespace from this device on. Just bail out telling
295  * the walk routine to not traverse this branch. This preserves
296  * the scoping rule for handlers.
297  */
298  return (AE_CTRL_DEPTH);
299  }
300 
301  /*
302  * As long as the device didn't have a handler for this space we
303  * don't care about it. We just ignore it and proceed.
304  */
305  return (AE_OK);
306  }
307 
308  /* Object is a Region */
309 
310  if (ObjDesc->Region.SpaceId != HandlerObj->AddressSpace.SpaceId)
311  {
312  /* This region is for a different address space, just ignore it */
313 
314  return (AE_OK);
315  }
316 
317  /*
318  * Now we have a region and it is for the handler's address space type.
319  *
320  * First disconnect region for any previous handler (if any)
321  */
322  AcpiEvDetachRegion (ObjDesc, FALSE);
323 
324  /* Connect the region to the new handler */
325 
326  Status = AcpiEvAttachRegion (HandlerObj, ObjDesc, FALSE);
327  return (Status);
328 }
329 
330 
331 /*******************************************************************************
332  *
333  * FUNCTION: AcpiEvFindRegionHandler
334  *
335  * PARAMETERS: SpaceId - The address space ID
336  * HandlerObj - Head of the handler object list
337  *
338  * RETURN: Matching handler object. NULL if space ID not matched
339  *
340  * DESCRIPTION: Search a handler object list for a match on the address
341  * space ID.
342  *
343  ******************************************************************************/
344 
348  ACPI_OPERAND_OBJECT *HandlerObj)
349 {
350 
351  /* Walk the handler list for this device */
352 
353  while (HandlerObj)
354  {
355  /* Same SpaceId indicates a handler is installed */
356 
357  if (HandlerObj->AddressSpace.SpaceId == SpaceId)
358  {
359  return (HandlerObj);
360  }
361 
362  /* Next handler object */
363 
364  HandlerObj = HandlerObj->AddressSpace.Next;
365  }
366 
367  return (NULL);
368 }
369 
370 
371 /*******************************************************************************
372  *
373  * FUNCTION: AcpiEvInstallSpaceHandler
374  *
375  * PARAMETERS: Node - Namespace node for the device
376  * SpaceId - The address space ID
377  * Handler - Address of the handler
378  * Setup - Address of the setup function
379  * Context - Value passed to the handler on each access
380  *
381  * RETURN: Status
382  *
383  * DESCRIPTION: Install a handler for all OpRegions of a given SpaceId.
384  * Assumes namespace is locked
385  *
386  ******************************************************************************/
387 
394  void *Context)
395 {
396  ACPI_OPERAND_OBJECT *ObjDesc;
397  ACPI_OPERAND_OBJECT *HandlerObj;
400  UINT8 Flags = 0;
401 
402 
403  ACPI_FUNCTION_TRACE (EvInstallSpaceHandler);
404 
405 
406  /*
407  * This registration is valid for only the types below and the root.
408  * The root node is where the default handlers get installed.
409  */
410  if ((Node->Type != ACPI_TYPE_DEVICE) &&
411  (Node->Type != ACPI_TYPE_PROCESSOR) &&
412  (Node->Type != ACPI_TYPE_THERMAL) &&
413  (Node != AcpiGbl_RootNode))
414  {
416  goto UnlockAndExit;
417  }
418 
420  {
422 
423  switch (SpaceId)
424  {
426 
429  break;
430 
432 
435  break;
436 
438 
441  break;
442 
443  case ACPI_ADR_SPACE_CMOS:
444 
447  break;
448 
450 
453  break;
454 
456 
458  Setup = NULL;
459  break;
460 
461  default:
462 
464  goto UnlockAndExit;
465  }
466  }
467 
468  /* If the caller hasn't specified a setup routine, use the default */
469 
470  if (!Setup)
471  {
473  }
474 
475  /* Check for an existing internal object */
476 
477  ObjDesc = AcpiNsGetAttachedObject (Node);
478  if (ObjDesc)
479  {
480  /*
481  * The attached device object already exists. Now make sure
482  * the handler is not already installed.
483  */
484  HandlerObj = AcpiEvFindRegionHandler (SpaceId,
485  ObjDesc->CommonNotify.Handler);
486 
487  if (HandlerObj)
488  {
489  if (HandlerObj->AddressSpace.Handler == Handler)
490  {
491  /*
492  * It is (relatively) OK to attempt to install the SAME
493  * handler twice. This can easily happen with the
494  * PCI_Config space.
495  */
497  goto UnlockAndExit;
498  }
499  else
500  {
501  /* A handler is already installed */
502 
504  }
505 
506  goto UnlockAndExit;
507  }
508  }
509  else
510  {
512  "Creating object on Device %p while installing handler\n",
513  Node));
514 
515  /* ObjDesc does not exist, create one */
516 
517  if (Node->Type == ACPI_TYPE_ANY)
518  {
520  }
521  else
522  {
523  Type = Node->Type;
524  }
525 
526  ObjDesc = AcpiUtCreateInternalObject (Type);
527  if (!ObjDesc)
528  {
530  goto UnlockAndExit;
531  }
532 
533  /* Init new descriptor */
534 
535  ObjDesc->Common.Type = (UINT8) Type;
536 
537  /* Attach the new object to the Node */
538 
539  Status = AcpiNsAttachObject (Node, ObjDesc, Type);
540 
541  /* Remove local reference to the object */
542 
543  AcpiUtRemoveReference (ObjDesc);
544 
545  if (ACPI_FAILURE (Status))
546  {
547  goto UnlockAndExit;
548  }
549  }
550 
552  "Installing address handler for region %s(%X) "
553  "on Device %4.4s %p(%p)\n",
555  AcpiUtGetNodeName (Node), Node, ObjDesc));
556 
557  /*
558  * Install the handler
559  *
560  * At this point there is no existing handler. Just allocate the object
561  * for the handler and link it into the list.
562  */
564  if (!HandlerObj)
565  {
567  goto UnlockAndExit;
568  }
569 
570  /* Init handler obj */
571 
572  HandlerObj->AddressSpace.SpaceId = (UINT8) SpaceId;
573  HandlerObj->AddressSpace.HandlerFlags = Flags;
574  HandlerObj->AddressSpace.RegionList = NULL;
575  HandlerObj->AddressSpace.Node = Node;
576  HandlerObj->AddressSpace.Handler = Handler;
577  HandlerObj->AddressSpace.Context = Context;
578  HandlerObj->AddressSpace.Setup = Setup;
579 
580  /* Install at head of Device.AddressSpace list */
581 
582  HandlerObj->AddressSpace.Next = ObjDesc->CommonNotify.Handler;
583 
584  /*
585  * The Device object is the first reference on the HandlerObj.
586  * Each region that uses the handler adds a reference.
587  */
588  ObjDesc->CommonNotify.Handler = HandlerObj;
589 
590  /*
591  * Walk the namespace finding all of the regions this handler will
592  * manage.
593  *
594  * Start at the device and search the branch toward the leaf nodes
595  * until either the leaf is encountered or a device is detected that
596  * has an address handler of the same type.
597  *
598  * In either case, back up and search down the remainder of the branch
599  */
602  AcpiEvInstallHandler, NULL, HandlerObj, NULL);
603 
604 UnlockAndExit:
606 }
ACPI_STATUS AcpiEvPciConfigRegionSetup(ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext)
Definition: evrgnini.c:179
#define ACPI_NUM_DEFAULT_SPACES
Definition: acconfig.h:202
ACPI_NAMESPACE_NODE * Node
Definition: acobject.h:414
UINT8 ACPI_ADR_SPACE_TYPE
Definition: actypes.h:850
ACPI_STATUS(* ACPI_ADR_SPACE_SETUP)(ACPI_HANDLE RegionHandle, UINT32 Function, void *HandlerContext, void **RegionContext)
Definition: actypes.h:1216
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
ACPI_STATUS(* ACPI_ADR_SPACE_HANDLER)(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
Definition: actypes.h:1194
#define ACPI_TYPE_THERMAL
Definition: actypes.h:692
#define ACPI_NS_WALK_UNLOCK
Definition: acnamesp.h:77
ACPI_STATUS AcpiExDataTableSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
Definition: exregion.c:579
#define AE_NO_MEMORY
Definition: acexcep.h:112
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE ACPI_HANDLE ACPI_HANDLE *OutHandle ACPI_HANDLE *OutHandle void *Context void *Context ACPI_EVENT_HANDLER Handler UINT32 UINT32 ACPI_GPE_HANDLER void *Context UINT32 ACPI_NOTIFY_HANDLER void *Context ACPI_ADR_SPACE_TYPE ACPI_ADR_SPACE_HANDLER ACPI_ADR_SPACE_SETUP Setup
Definition: acpixf.h:828
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
#define AE_SAME_HANDLER
Definition: acexcep.h:133
#define TRUE
Definition: types.h:120
ACPI_STATUS AcpiEvDefaultRegionSetup(ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext)
Definition: evrgnini.c:510
#define AE_CTRL_DEPTH
Definition: acexcep.h:229
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:55
ACPI_ADR_SPACE_SETUP Setup
Definition: acobject.h:416
#define ACPI_ADR_SPACE_DATA_TABLE
Definition: actypes.h:875
union acpi_operand_object * RegionList
Definition: acobject.h:417
UINT32 ACPI_STATUS
Definition: actypes.h:460
ACPI_OBJECT_COMMON_HEADER UINT8 SpaceId
Definition: acobject.h:202
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
#define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED
Definition: acobject.h:424
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE ACPI_HANDLE ACPI_HANDLE *OutHandle ACPI_HANDLE *OutHandle void *Context void *Context ACPI_EVENT_HANDLER Handler UINT32 UINT32 ACPI_GPE_HANDLER void *Context UINT32 ACPI_NOTIFY_HANDLER void *Context ACPI_ADR_SPACE_TYPE SpaceId
Definition: acpixf.h:828
ACPI_STATUS AcpiUtReleaseMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:348
UINT32 void void ** ReturnValue
Definition: acevents.h:214
#define ACPI_ADR_SPACE_SYSTEM_IO
Definition: actypes.h:853
const char * AcpiUtGetRegionName(UINT8 SpaceId)
Definition: utdecode.c:125
#define FALSE
Definition: types.h:117
ACPI_STATUS AcpiUtAcquireMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:256
unsigned int UINT32
ACPI_STATUS AcpiEvInstallSpaceHandler(ACPI_NAMESPACE_NODE *Node, ACPI_ADR_SPACE_TYPE SpaceId, ACPI_ADR_SPACE_HANDLER Handler, ACPI_ADR_SPACE_SETUP Setup, void *Context)
Definition: evhandler.c:389
union node Node
Definition: types.h:1255
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
void AcpiEvDetachRegion(ACPI_OPERAND_OBJECT *RegionObj, BOOLEAN AcpiNsIsLocked)
Definition: evregion.c:362
unsigned char BOOLEAN
union acpi_operand_object * Next
Definition: acobject.h:418
UINT8 AcpiGbl_DefaultAddressSpaces[ACPI_NUM_DEFAULT_SPACES]
Definition: evhandler.c:66
#define ACPI_DB_OPREGION
Definition: acoutput.h:167
#define ACPI_TYPE_LOCAL_ADDRESS_HANDLER
Definition: actypes.h:715
UINT32 ACPI_OBJECT_TYPE
Definition: actypes.h:677
ACPI_ADR_SPACE_HANDLER Handler
Definition: acobject.h:413
ACPI_OBJECT_REGION Region
Definition: acobject.h:525
ACPI_STATUS AcpiEvInstallRegionHandlers(void)
Definition: evhandler.c:88
Status
Definition: gdiplustypes.h:24
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
static ACPI_STATUS AcpiEvInstallHandler(ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue)
Definition: evhandler.c:220
#define AE_ALREADY_EXISTS
Definition: acexcep.h:115
#define ACPI_DEFAULT_HANDLER
Definition: actypes.h:1202
#define ACPI_UINT32_MAX
Definition: actypes.h:66
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
Type
Definition: Type.h:6
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
ACPI_STATUS AcpiExCmosSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
Definition: exregion.c:505
ACPI_OBJECT_ADDR_HANDLER AddressSpace
Definition: acobject.h:537
#define ACPI_TYPE_ANY
Definition: actypes.h:679
ACPI_STATUS AcpiEvAttachRegion(ACPI_OPERAND_OBJECT *HandlerObj, ACPI_OPERAND_OBJECT *RegionObj, BOOLEAN AcpiNsIsLocked)
Definition: evregion.c:532
#define ACPI_TYPE_DEVICE
Definition: actypes.h:685
#define ACPI_TYPE_PROCESSOR
Definition: actypes.h:691
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER Handler
Definition: acpixf.h:668
ACPI_STATUS AcpiEvPciBarRegionSetup(ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext)
Definition: evrgnini.c:450
ACPI_STATUS AcpiNsAttachObject(ACPI_NAMESPACE_NODE *Node, ACPI_OPERAND_OBJECT *Object, ACPI_OBJECT_TYPE Type)
Definition: nsobject.c:76
ACPI_OPERAND_OBJECT * AcpiEvFindRegionHandler(ACPI_ADR_SPACE_TYPE SpaceId, ACPI_OPERAND_OBJECT *HandlerObj)
Definition: evhandler.c:346
#define ACPI_ADR_SPACE_CMOS
Definition: actypes.h:857
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
ACPI_OBJECT_COMMON_HEADER UINT8 SpaceId
Definition: acobject.h:411
ACPI_STATUS AcpiEvIoSpaceRegionSetup(ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext)
Definition: evrgnini.c:139
ACPI_OBJECT_COMMON Common
Definition: acobject.h:517
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:781
#define NULL
Definition: types.h:112
#define ACPI_ADR_SPACE_PCI_CONFIG
Definition: actypes.h:854
ACPI_STATUS AcpiExPciConfigSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
Definition: exregion.c:424
ACPI_STATUS AcpiEvSystemMemoryRegionSetup(ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext)
Definition: evrgnini.c:70
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:306
struct tagContext Context
Definition: acpixf.h:1034
ACPI_OBJECT_NOTIFY_COMMON CommonNotify
Definition: acobject.h:526
#define ACPI_TYPE_REGION
Definition: actypes.h:689
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
ACPI_NAMESPACE_NODE * AcpiNsValidateHandle(ACPI_HANDLE Handle)
Definition: nsutils.c:655
#define AcpiUtCreateInternalObject(t)
Definition: acutils.h:655
#define ACPI_ADR_SPACE_SYSTEM_MEMORY
Definition: actypes.h:852
#define ACPI_MTX_NAMESPACE
Definition: aclocal.h:85
ACPI_STATUS AcpiEvCmosRegionSetup(ACPI_HANDLE Handle, UINT32 Function, void *HandlerContext, void **RegionContext)
Definition: evrgnini.c:481
ACPI_STATUS AcpiExSystemIoSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
Definition: exregion.c:359
unsigned char UINT8
ACPI_STATUS AcpiExSystemMemorySpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
Definition: exregion.c:72
#define AE_OK
Definition: acexcep.h:97
BOOLEAN AcpiEvHasDefaultHandler(ACPI_NAMESPACE_NODE *Node, ACPI_ADR_SPACE_TYPE SpaceId)
Definition: evhandler.c:166
ACPI_STATUS AcpiExPciBarSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
Definition: exregion.c:542
#define ACPI_ADR_SPACE_PCI_BAR_TARGET
Definition: actypes.h:858
Definition: dlist.c:348