ReactOS  0.4.14-dev-297-g23e575c
hwgpe.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: hwgpe - Low level GPE enable/disable/clear functions
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 "acevents.h"
47 
48 #define _COMPONENT ACPI_HARDWARE
49  ACPI_MODULE_NAME ("hwgpe")
50 
51 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
52 
53 /* Local prototypes */
54 
55 static ACPI_STATUS
57  ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
58  ACPI_GPE_BLOCK_INFO *GpeBlock,
59  void *Context);
60 
61 static ACPI_STATUS
63  UINT8 EnableMask,
64  ACPI_GPE_REGISTER_INFO *GpeRegisterInfo);
65 
66 
67 /******************************************************************************
68  *
69  * FUNCTION: AcpiHwGetGpeRegisterBit
70  *
71  * PARAMETERS: GpeEventInfo - Info block for the GPE
72  *
73  * RETURN: Register mask with a one in the GPE bit position
74  *
75  * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
76  * correct position for the input GPE.
77  *
78  ******************************************************************************/
79 
80 UINT32
83 {
84 
85  return ((UINT32) 1 <<
86  (GpeEventInfo->GpeNumber - GpeEventInfo->RegisterInfo->BaseGpeNumber));
87 }
88 
89 
90 /******************************************************************************
91  *
92  * FUNCTION: AcpiHwLowSetGpe
93  *
94  * PARAMETERS: GpeEventInfo - Info block for the GPE to be disabled
95  * Action - Enable or disable
96  *
97  * RETURN: Status
98  *
99  * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
100  * The EnableMask field of the involved GPE register must be
101  * updated by the caller if necessary.
102  *
103  ******************************************************************************/
104 
108  UINT32 Action)
109 {
110  ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
112  UINT64 EnableMask;
113  UINT32 RegisterBit;
114 
115 
117 
118 
119  /* Get the info block for the entire GPE register */
120 
121  GpeRegisterInfo = GpeEventInfo->RegisterInfo;
122  if (!GpeRegisterInfo)
123  {
124  return (AE_NOT_EXIST);
125  }
126 
127  /* Get current value of the enable register that contains this GPE */
128 
129  Status = AcpiHwRead (&EnableMask, &GpeRegisterInfo->EnableAddress);
130  if (ACPI_FAILURE (Status))
131  {
132  return (Status);
133  }
134 
135  /* Set or clear just the bit that corresponds to this GPE */
136 
137  RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
138  switch (Action)
139  {
141 
142  /* Only enable if the corresponding EnableMask bit is set */
143 
144  if (!(RegisterBit & GpeRegisterInfo->EnableMask))
145  {
146  return (AE_BAD_PARAMETER);
147  }
148 
149  /*lint -fallthrough */
150 
151  case ACPI_GPE_ENABLE:
152 
153  ACPI_SET_BIT (EnableMask, RegisterBit);
154  break;
155 
156  case ACPI_GPE_DISABLE:
157 
158  ACPI_CLEAR_BIT (EnableMask, RegisterBit);
159  break;
160 
161  default:
162 
163  ACPI_ERROR ((AE_INFO, "Invalid GPE Action, %u", Action));
164  return (AE_BAD_PARAMETER);
165  }
166 
167  if (!(RegisterBit & GpeRegisterInfo->MaskForRun))
168  {
169  /* Write the updated enable mask */
170 
171  Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
172  }
173  return (Status);
174 }
175 
176 
177 /******************************************************************************
178  *
179  * FUNCTION: AcpiHwClearGpe
180  *
181  * PARAMETERS: GpeEventInfo - Info block for the GPE to be cleared
182  *
183  * RETURN: Status
184  *
185  * DESCRIPTION: Clear the status bit for a single GPE.
186  *
187  ******************************************************************************/
188 
192 {
193  ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
195  UINT32 RegisterBit;
196 
197 
199 
200  /* Get the info block for the entire GPE register */
201 
202  GpeRegisterInfo = GpeEventInfo->RegisterInfo;
203  if (!GpeRegisterInfo)
204  {
205  return (AE_NOT_EXIST);
206  }
207 
208  /*
209  * Write a one to the appropriate bit in the status register to
210  * clear this GPE.
211  */
212  RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
213 
214  Status = AcpiHwWrite (RegisterBit, &GpeRegisterInfo->StatusAddress);
215  return (Status);
216 }
217 
218 
219 /******************************************************************************
220  *
221  * FUNCTION: AcpiHwGetGpeStatus
222  *
223  * PARAMETERS: GpeEventInfo - Info block for the GPE to queried
224  * EventStatus - Where the GPE status is returned
225  *
226  * RETURN: Status
227  *
228  * DESCRIPTION: Return the status of a single GPE.
229  *
230  ******************************************************************************/
231 
235  ACPI_EVENT_STATUS *EventStatus)
236 {
237  UINT64 InByte;
238  UINT32 RegisterBit;
239  ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
240  ACPI_EVENT_STATUS LocalEventStatus = 0;
242 
243 
245 
246 
247  if (!EventStatus)
248  {
249  return (AE_BAD_PARAMETER);
250  }
251 
252  /* GPE currently handled? */
253 
256  {
257  LocalEventStatus |= ACPI_EVENT_FLAG_HAS_HANDLER;
258  }
259 
260  /* Get the info block for the entire GPE register */
261 
262  GpeRegisterInfo = GpeEventInfo->RegisterInfo;
263 
264  /* Get the register bitmask for this GPE */
265 
266  RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
267 
268  /* GPE currently enabled? (enabled for runtime?) */
269 
270  if (RegisterBit & GpeRegisterInfo->EnableForRun)
271  {
272  LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
273  }
274 
275  /* GPE currently masked? (masked for runtime?) */
276 
277  if (RegisterBit & GpeRegisterInfo->MaskForRun)
278  {
279  LocalEventStatus |= ACPI_EVENT_FLAG_MASKED;
280  }
281 
282  /* GPE enabled for wake? */
283 
284  if (RegisterBit & GpeRegisterInfo->EnableForWake)
285  {
286  LocalEventStatus |= ACPI_EVENT_FLAG_WAKE_ENABLED;
287  }
288 
289  /* GPE currently enabled (enable bit == 1)? */
290 
291  Status = AcpiHwRead (&InByte, &GpeRegisterInfo->EnableAddress);
292  if (ACPI_FAILURE (Status))
293  {
294  return (Status);
295  }
296 
297  if (RegisterBit & InByte)
298  {
299  LocalEventStatus |= ACPI_EVENT_FLAG_ENABLE_SET;
300  }
301 
302  /* GPE currently active (status bit == 1)? */
303 
304  Status = AcpiHwRead (&InByte, &GpeRegisterInfo->StatusAddress);
305  if (ACPI_FAILURE (Status))
306  {
307  return (Status);
308  }
309 
310  if (RegisterBit & InByte)
311  {
312  LocalEventStatus |= ACPI_EVENT_FLAG_STATUS_SET;
313  }
314 
315  /* Set return value */
316 
317  (*EventStatus) = LocalEventStatus;
318  return (AE_OK);
319 }
320 
321 
322 /******************************************************************************
323  *
324  * FUNCTION: AcpiHwGpeEnableWrite
325  *
326  * PARAMETERS: EnableMask - Bit mask to write to the GPE register
327  * GpeRegisterInfo - Gpe Register info
328  *
329  * RETURN: Status
330  *
331  * DESCRIPTION: Write the enable mask byte to the given GPE register.
332  *
333  ******************************************************************************/
334 
335 static ACPI_STATUS
337  UINT8 EnableMask,
338  ACPI_GPE_REGISTER_INFO *GpeRegisterInfo)
339 {
341 
342 
343  GpeRegisterInfo->EnableMask = EnableMask;
344 
345  Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
346  return (Status);
347 }
348 
349 
350 /******************************************************************************
351  *
352  * FUNCTION: AcpiHwDisableGpeBlock
353  *
354  * PARAMETERS: GpeXruptInfo - GPE Interrupt info
355  * GpeBlock - Gpe Block info
356  *
357  * RETURN: Status
358  *
359  * DESCRIPTION: Disable all GPEs within a single GPE block
360  *
361  ******************************************************************************/
362 
365  ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
366  ACPI_GPE_BLOCK_INFO *GpeBlock,
367  void *Context)
368 {
369  UINT32 i;
371 
372 
373  /* Examine each GPE Register within the block */
374 
375  for (i = 0; i < GpeBlock->RegisterCount; i++)
376  {
377  /* Disable all GPEs in this register */
378 
379  Status = AcpiHwGpeEnableWrite (0x00, &GpeBlock->RegisterInfo[i]);
380  if (ACPI_FAILURE (Status))
381  {
382  return (Status);
383  }
384  }
385 
386  return (AE_OK);
387 }
388 
389 
390 /******************************************************************************
391  *
392  * FUNCTION: AcpiHwClearGpeBlock
393  *
394  * PARAMETERS: GpeXruptInfo - GPE Interrupt info
395  * GpeBlock - Gpe Block info
396  *
397  * RETURN: Status
398  *
399  * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
400  *
401  ******************************************************************************/
402 
405  ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
406  ACPI_GPE_BLOCK_INFO *GpeBlock,
407  void *Context)
408 {
409  UINT32 i;
411 
412 
413  /* Examine each GPE Register within the block */
414 
415  for (i = 0; i < GpeBlock->RegisterCount; i++)
416  {
417  /* Clear status on all GPEs in this register */
418 
419  Status = AcpiHwWrite (0xFF, &GpeBlock->RegisterInfo[i].StatusAddress);
420  if (ACPI_FAILURE (Status))
421  {
422  return (Status);
423  }
424  }
425 
426  return (AE_OK);
427 }
428 
429 
430 /******************************************************************************
431  *
432  * FUNCTION: AcpiHwEnableRuntimeGpeBlock
433  *
434  * PARAMETERS: GpeXruptInfo - GPE Interrupt info
435  * GpeBlock - Gpe Block info
436  *
437  * RETURN: Status
438  *
439  * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
440  * combination wake/run GPEs.
441  *
442  ******************************************************************************/
443 
446  ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
447  ACPI_GPE_BLOCK_INFO *GpeBlock,
448  void *Context)
449 {
450  UINT32 i;
452  ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
453  UINT8 EnableMask;
454 
455 
456  /* NOTE: assumes that all GPEs are currently disabled */
457 
458  /* Examine each GPE Register within the block */
459 
460  for (i = 0; i < GpeBlock->RegisterCount; i++)
461  {
462  GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
463  if (!GpeRegisterInfo->EnableForRun)
464  {
465  continue;
466  }
467 
468  /* Enable all "runtime" GPEs in this register */
469 
470  EnableMask = GpeRegisterInfo->EnableForRun &
471  ~GpeRegisterInfo->MaskForRun;
472  Status = AcpiHwGpeEnableWrite (EnableMask, GpeRegisterInfo);
473  if (ACPI_FAILURE (Status))
474  {
475  return (Status);
476  }
477  }
478 
479  return (AE_OK);
480 }
481 
482 
483 /******************************************************************************
484  *
485  * FUNCTION: AcpiHwEnableWakeupGpeBlock
486  *
487  * PARAMETERS: GpeXruptInfo - GPE Interrupt info
488  * GpeBlock - Gpe Block info
489  *
490  * RETURN: Status
491  *
492  * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
493  * combination wake/run GPEs.
494  *
495  ******************************************************************************/
496 
497 static ACPI_STATUS
499  ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
500  ACPI_GPE_BLOCK_INFO *GpeBlock,
501  void *Context)
502 {
503  UINT32 i;
505  ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
506 
507 
508  /* Examine each GPE Register within the block */
509 
510  for (i = 0; i < GpeBlock->RegisterCount; i++)
511  {
512  GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
513 
514  /*
515  * Enable all "wake" GPEs in this register and disable the
516  * remaining ones.
517  */
518  Status = AcpiHwGpeEnableWrite (GpeRegisterInfo->EnableForWake,
519  GpeRegisterInfo);
520  if (ACPI_FAILURE (Status))
521  {
522  return (Status);
523  }
524  }
525 
526  return (AE_OK);
527 }
528 
529 
530 /******************************************************************************
531  *
532  * FUNCTION: AcpiHwDisableAllGpes
533  *
534  * PARAMETERS: None
535  *
536  * RETURN: Status
537  *
538  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
539  *
540  ******************************************************************************/
541 
544  void)
545 {
547 
548 
549  ACPI_FUNCTION_TRACE (HwDisableAllGpes);
550 
551 
554 }
555 
556 
557 /******************************************************************************
558  *
559  * FUNCTION: AcpiHwEnableAllRuntimeGpes
560  *
561  * PARAMETERS: None
562  *
563  * RETURN: Status
564  *
565  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
566  *
567  ******************************************************************************/
568 
571  void)
572 {
574 
575 
576  ACPI_FUNCTION_TRACE (HwEnableAllRuntimeGpes);
577 
578 
581 }
582 
583 
584 /******************************************************************************
585  *
586  * FUNCTION: AcpiHwEnableAllWakeupGpes
587  *
588  * PARAMETERS: None
589  *
590  * RETURN: Status
591  *
592  * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
593  *
594  ******************************************************************************/
595 
598  void)
599 {
601 
602 
603  ACPI_FUNCTION_TRACE (HwEnableAllWakeupGpes);
604 
605 
608 }
609 
610 #endif /* !ACPI_REDUCED_HARDWARE */
ACPI_STATUS AcpiHwDisableAllGpes(void)
Definition: hwgpe.c:543
#define ACPI_GPE_CONDITIONAL_ENABLE
Definition: actypes.h:795
ACPI_STATUS AcpiHwEnableRuntimeGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:445
#define ACPI_EVENT_FLAG_MASKED
Definition: actypes.h:788
static ACPI_STATUS AcpiHwGpeEnableWrite(UINT8 EnableMask, ACPI_GPE_REGISTER_INFO *GpeRegisterInfo)
Definition: hwgpe.c:336
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
ACPI_STATUS AcpiHwClearGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:404
#define ACPI_GPE_DISPATCH_NONE
Definition: actypes.h:809
#define ACPI_SET_BIT(target, bit)
Definition: actypes.h:533
#define ACPI_GPE_DISPATCH_TYPE(flags)
Definition: actypes.h:815
ACPI_GPE_EVENT_INFO * GpeEventInfo
Definition: acevents.h:195
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
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 ACPI_EVENT_FLAG_STATUS_SET
Definition: actypes.h:785
ACPI_GENERIC_ADDRESS EnableAddress
Definition: aclocal.h:568
unsigned int UINT32
#define ACPI_EVENT_FLAG_ENABLED
Definition: actypes.h:783
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
smooth NULL
Definition: ftsmooth.c:416
#define AE_INFO
Definition: acoutput.h:230
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484
ACPI_STATUS AcpiHwEnableAllRuntimeGpes(void)
Definition: hwgpe.c:570
UINT32 AcpiHwGetGpeRegisterBit(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: hwgpe.c:81
static ACPI_STATUS AcpiHwEnableWakeupGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:498
#define ACPI_EVENT_FLAG_HAS_HANDLER
Definition: actypes.h:787
ACPI_STATUS AcpiHwGetGpeStatus(ACPI_GPE_EVENT_INFO *GpeEventInfo, ACPI_EVENT_STATUS *EventStatus)
Definition: hwgpe.c:233
struct acpi_gpe_register_info * RegisterInfo
Definition: aclocal.h:555
_In_ PLIST_ENTRY _In_ PSTRING _In_ USHORT _In_opt_ PSTRING _In_opt_ PSTRING _In_ ULONG _In_ ULONG Action
Definition: fsrtlfuncs.h:738
UINT32 ACPI_EVENT_STATUS
Definition: actypes.h:780
#define ACPI_CLEAR_BIT(target, bit)
Definition: actypes.h:534
ACPI_GENERIC_ADDRESS StatusAddress
Definition: aclocal.h:567
ACPI_STATUS AcpiHwEnableAllWakeupGpes(void)
Definition: hwgpe.c:597
ACPI_STATUS AcpiHwRead(UINT64 *Value, ACPI_GENERIC_ADDRESS *Reg)
Definition: hwregs.c:259
#define AE_NOT_EXIST
Definition: acexcep.h:114
#define ACPI_EVENT_FLAG_WAKE_ENABLED
Definition: actypes.h:784
ACPI_STATUS AcpiHwClearGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: hwgpe.c:190
#define ACPI_GPE_ENABLE
Definition: actypes.h:793
ACPI_GPE_REGISTER_INFO * RegisterInfo
Definition: aclocal.h:587
UINT32 RegisterCount
Definition: aclocal.h:590
Status
Definition: gdiplustypes.h:24
ACPI_STATUS AcpiHwDisableGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:364
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
ACPI_STATUS AcpiEvWalkGpeList(ACPI_GPE_CALLBACK GpeWalkCallback, void *Context)
Definition: evgpeutil.c:67
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
#define ACPI_GPE_DISABLE
Definition: actypes.h:794
unsigned long long UINT64
unsigned char UINT8
ACPI_STATUS AcpiHwWrite(UINT64 Value, ACPI_GENERIC_ADDRESS *Reg)
Definition: hwregs.c:357
#define AE_OK
Definition: acexcep.h:97
ACPI_STATUS AcpiHwLowSetGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 Action)
Definition: hwgpe.c:106
#define ACPI_EVENT_FLAG_ENABLE_SET
Definition: actypes.h:786