ReactOS 0.4.15-dev-8332-ga943bb4
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 - 2022, 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 MERCHANTABILITY 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
55static ACPI_STATUS
57 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
58 ACPI_GPE_BLOCK_INFO *GpeBlock,
59 void *Context);
60
61static 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
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
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
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
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 */
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
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
335static 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
497static 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: AcpiHwGetGpeBlockStatus
533 *
534 * PARAMETERS: GpeXruptInfo - GPE Interrupt info
535 * GpeBlock - Gpe Block info
536 *
537 * RETURN: Success
538 *
539 * DESCRIPTION: Produce a combined GPE status bits mask for the given block.
540 *
541 ******************************************************************************/
542
543static ACPI_STATUS
545 ACPI_GPE_XRUPT_INFO *GpeXruptInfo,
546 ACPI_GPE_BLOCK_INFO *GpeBlock,
547 void *RetPtr)
548{
549 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
550 UINT64 InEnable;
551 UINT64 InStatus;
553 UINT8 *Ret = RetPtr;
554 UINT32 i;
555
556
557 /* Examine each GPE Register within the block */
558
559 for (i = 0; i < GpeBlock->RegisterCount; i++)
560 {
561 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
562
563 Status = AcpiHwRead (&InEnable, &GpeRegisterInfo->EnableAddress);
564 if (ACPI_FAILURE (Status))
565 {
566 continue;
567 }
568
569 Status = AcpiHwRead (&InStatus, &GpeRegisterInfo->StatusAddress);
570 if (ACPI_FAILURE (Status))
571 {
572 continue;
573 }
574
575 *Ret |= InEnable & InStatus;
576 }
577
578 return (AE_OK);
579}
580
581
582/******************************************************************************
583 *
584 * FUNCTION: AcpiHwDisableAllGpes
585 *
586 * PARAMETERS: None
587 *
588 * RETURN: Status
589 *
590 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
591 *
592 ******************************************************************************/
593
596 void)
597{
599
600
601 ACPI_FUNCTION_TRACE (HwDisableAllGpes);
602
603
606}
607
608
609/******************************************************************************
610 *
611 * FUNCTION: AcpiHwEnableAllRuntimeGpes
612 *
613 * PARAMETERS: None
614 *
615 * RETURN: Status
616 *
617 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
618 *
619 ******************************************************************************/
620
623 void)
624{
626
627
628 ACPI_FUNCTION_TRACE (HwEnableAllRuntimeGpes);
629
630
633}
634
635
636/******************************************************************************
637 *
638 * FUNCTION: AcpiHwEnableAllWakeupGpes
639 *
640 * PARAMETERS: None
641 *
642 * RETURN: Status
643 *
644 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
645 *
646 ******************************************************************************/
647
650 void)
651{
653
654
655 ACPI_FUNCTION_TRACE (HwEnableAllWakeupGpes);
656
657
660}
661
662
663/******************************************************************************
664 *
665 * FUNCTION: AcpiHwCheckAllGpes
666 *
667 * PARAMETERS: None
668 *
669 * RETURN: Combined status of all GPEs
670 *
671 * DESCRIPTION: Check all enabled GPEs in all GPE blocks and return TRUE if the
672 * status bit is set for at least one of them of FALSE otherwise.
673 *
674 ******************************************************************************/
675
676UINT8
678 void)
679{
680 UINT8 Ret = 0;
681
682
684
686 return (Ret != 0);
687}
688
689#endif /* !ACPI_REDUCED_HARDWARE */
unsigned long long UINT64
unsigned char UINT8
unsigned int UINT32
ACPI_GPE_EVENT_INFO * GpeEventInfo
Definition: acevents.h:195
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
#define AE_NOT_EXIST
Definition: acexcep.h:114
#define AE_OK
Definition: acexcep.h:97
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
#define AE_INFO
Definition: acoutput.h:230
#define ACPI_GPE_ENABLE
Definition: actypes.h:803
#define ACPI_GPE_CONDITIONAL_ENABLE
Definition: actypes.h:805
#define ACPI_EVENT_FLAG_ENABLED
Definition: actypes.h:793
#define ACPI_SET_BIT(target, bit)
Definition: actypes.h:533
#define ACPI_EVENT_FLAG_MASKED
Definition: actypes.h:798
#define ACPI_GPE_DISPATCH_NONE
Definition: actypes.h:819
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_GPE_DISPATCH_TYPE(flags)
Definition: actypes.h:825
#define ACPI_GPE_DISABLE
Definition: actypes.h:804
#define ACPI_EVENT_FLAG_HAS_HANDLER
Definition: actypes.h:797
#define ACPI_EVENT_FLAG_STATUS_SET
Definition: actypes.h:795
UINT32 ACPI_EVENT_STATUS
Definition: actypes.h:790
#define ACPI_EVENT_FLAG_ENABLE_SET
Definition: actypes.h:796
#define ACPI_CLEAR_BIT(target, bit)
Definition: actypes.h:534
#define ACPI_EVENT_FLAG_WAKE_ENABLED
Definition: actypes.h:794
#define ACPI_FALLTHROUGH
Definition: actypes.h:1466
#define NULL
Definition: types.h:112
ACPI_STATUS AcpiEvWalkGpeList(ACPI_GPE_CALLBACK GpeWalkCallback, void *Context)
Definition: evgpeutil.c:67
Status
Definition: gdiplustypes.h:25
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
ACPI_STATUS AcpiHwDisableGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:364
UINT32 AcpiHwGetGpeRegisterBit(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: hwgpe.c:81
ACPI_STATUS AcpiHwClearGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: hwgpe.c:190
static ACPI_STATUS AcpiHwGpeEnableWrite(UINT8 EnableMask, ACPI_GPE_REGISTER_INFO *GpeRegisterInfo)
Definition: hwgpe.c:336
static ACPI_STATUS AcpiHwGetGpeBlockStatus(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *RetPtr)
Definition: hwgpe.c:544
ACPI_STATUS AcpiHwEnableAllWakeupGpes(void)
Definition: hwgpe.c:649
ACPI_STATUS AcpiHwLowSetGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 Action)
Definition: hwgpe.c:106
ACPI_STATUS AcpiHwDisableAllGpes(void)
Definition: hwgpe.c:595
UINT8 AcpiHwCheckAllGpes(void)
Definition: hwgpe.c:677
ACPI_STATUS AcpiHwEnableRuntimeGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:445
ACPI_STATUS AcpiHwClearGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:404
ACPI_STATUS AcpiHwEnableAllRuntimeGpes(void)
Definition: hwgpe.c:622
static ACPI_STATUS AcpiHwEnableWakeupGpeBlock(ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
Definition: hwgpe.c:498
ACPI_STATUS AcpiHwGetGpeStatus(ACPI_GPE_EVENT_INFO *GpeEventInfo, ACPI_EVENT_STATUS *EventStatus)
Definition: hwgpe.c:233
ACPI_STATUS AcpiHwWrite(UINT64 Value, ACPI_GENERIC_ADDRESS *Reg)
Definition: hwregs.c:357
ACPI_STATUS AcpiHwRead(UINT64 *Value, ACPI_GENERIC_ADDRESS *Reg)
Definition: hwregs.c:259
UINT32 RegisterCount
Definition: aclocal.h:590
ACPI_GPE_REGISTER_INFO * RegisterInfo
Definition: aclocal.h:587
struct acpi_gpe_register_info * RegisterInfo
Definition: aclocal.h:555
ACPI_GENERIC_ADDRESS EnableAddress
Definition: aclocal.h:568
ACPI_GENERIC_ADDRESS StatusAddress
Definition: aclocal.h:567
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:510