ReactOS 0.4.15-dev-8222-g9164419
evgpe.c
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Module Name: evgpe - General Purpose Event handling and dispatch
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#include "acnamesp.h"
48
49#define _COMPONENT ACPI_EVENTS
50 ACPI_MODULE_NAME ("evgpe")
51
52#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
53
54/* Local prototypes */
55
56static void ACPI_SYSTEM_XFACE
58 void *Context);
59
60static void ACPI_SYSTEM_XFACE
62 void *Context);
63
64
65/*******************************************************************************
66 *
67 * FUNCTION: AcpiEvUpdateGpeEnableMask
68 *
69 * PARAMETERS: GpeEventInfo - GPE to update
70 *
71 * RETURN: Status
72 *
73 * DESCRIPTION: Updates GPE register enable mask based upon whether there are
74 * runtime references to this GPE
75 *
76 ******************************************************************************/
77
81{
82 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
83 UINT32 RegisterBit;
84
85
86 ACPI_FUNCTION_TRACE (EvUpdateGpeEnableMask);
87
88
89 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
90 if (!GpeRegisterInfo)
91 {
93 }
94
96
97 /* Clear the run bit up front */
98
99 ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
100
101 /* Set the mask bit only if there are references to this GPE */
102
104 {
105 ACPI_SET_BIT (GpeRegisterInfo->EnableForRun, (UINT8) RegisterBit);
106 }
107
108 GpeRegisterInfo->EnableMask = GpeRegisterInfo->EnableForRun;
110}
111
112
113/*******************************************************************************
114 *
115 * FUNCTION: AcpiEvEnableGpe
116 *
117 * PARAMETERS: GpeEventInfo - GPE to enable
118 *
119 * RETURN: Status
120 *
121 * DESCRIPTION: Enable a GPE.
122 *
123 ******************************************************************************/
124
128{
130
131
132 ACPI_FUNCTION_TRACE (EvEnableGpe);
133
134
135 /* Enable the requested GPE */
136
139}
140
141
142/*******************************************************************************
143 *
144 * FUNCTION: AcpiEvMaskGpe
145 *
146 * PARAMETERS: GpeEventInfo - GPE to be blocked/unblocked
147 * IsMasked - Whether the GPE is masked or not
148 *
149 * RETURN: Status
150 *
151 * DESCRIPTION: Unconditionally mask/unmask a GPE during runtime.
152 *
153 ******************************************************************************/
154
158 BOOLEAN IsMasked)
159{
160 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
161 UINT32 RegisterBit;
162
163
164 ACPI_FUNCTION_TRACE (EvMaskGpe);
165
166
167 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
168 if (!GpeRegisterInfo)
169 {
171 }
172
174
175 /* Perform the action */
176
177 if (IsMasked)
178 {
179 if (RegisterBit & GpeRegisterInfo->MaskForRun)
180 {
182 }
183
185 ACPI_SET_BIT (GpeRegisterInfo->MaskForRun, (UINT8) RegisterBit);
186 }
187 else
188 {
189 if (!(RegisterBit & GpeRegisterInfo->MaskForRun))
190 {
192 }
193
194 ACPI_CLEAR_BIT (GpeRegisterInfo->MaskForRun, (UINT8) RegisterBit);
197 {
199 }
200 }
201
203}
204
205
206/*******************************************************************************
207 *
208 * FUNCTION: AcpiEvAddGpeReference
209 *
210 * PARAMETERS: GpeEventInfo - Add a reference to this GPE
211 * ClearOnEnable - Clear GPE status before enabling it
212 *
213 * RETURN: Status
214 *
215 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
216 * hardware-enabled.
217 *
218 ******************************************************************************/
219
223 BOOLEAN ClearOnEnable)
224{
226
227
228 ACPI_FUNCTION_TRACE (EvAddGpeReference);
229
230
232 {
234 }
235
237 if (GpeEventInfo->RuntimeCount == 1)
238 {
239 /* Enable on first reference */
240
241 if (ClearOnEnable)
242 {
244 }
245
247 if (ACPI_SUCCESS (Status))
248 {
250 }
251
252 if (ACPI_FAILURE (Status))
253 {
255 }
256 }
257
259}
260
261
262/*******************************************************************************
263 *
264 * FUNCTION: AcpiEvRemoveGpeReference
265 *
266 * PARAMETERS: GpeEventInfo - Remove a reference to this GPE
267 *
268 * RETURN: Status
269 *
270 * DESCRIPTION: Remove a reference to a GPE. When the last reference is
271 * removed, the GPE is hardware-disabled.
272 *
273 ******************************************************************************/
274
278{
280
281
282 ACPI_FUNCTION_TRACE (EvRemoveGpeReference);
283
284
286 {
288 }
289
292 {
293 /* Disable on last reference */
294
296 if (ACPI_SUCCESS (Status))
297 {
299 }
300
301 if (ACPI_FAILURE (Status))
302 {
304 }
305 }
306
308}
309
310
311/*******************************************************************************
312 *
313 * FUNCTION: AcpiEvLowGetGpeInfo
314 *
315 * PARAMETERS: GpeNumber - Raw GPE number
316 * GpeBlock - A GPE info block
317 *
318 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE (The GpeNumber
319 * is not within the specified GPE block)
320 *
321 * DESCRIPTION: Returns the EventInfo struct associated with this GPE. This is
322 * the low-level implementation of EvGetGpeEventInfo.
323 *
324 ******************************************************************************/
325
329 ACPI_GPE_BLOCK_INFO *GpeBlock)
330{
331 UINT32 GpeIndex;
332
333
334 /*
335 * Validate that the GpeNumber is within the specified GpeBlock.
336 * (Two steps)
337 */
338 if (!GpeBlock ||
339 (GpeNumber < GpeBlock->BlockBaseNumber))
340 {
341 return (NULL);
342 }
343
344 GpeIndex = GpeNumber - GpeBlock->BlockBaseNumber;
345 if (GpeIndex >= GpeBlock->GpeCount)
346 {
347 return (NULL);
348 }
349
350 return (&GpeBlock->EventInfo[GpeIndex]);
351}
352
353
354/*******************************************************************************
355 *
356 * FUNCTION: AcpiEvGetGpeEventInfo
357 *
358 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
359 * GpeNumber - Raw GPE number
360 *
361 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE
362 *
363 * DESCRIPTION: Returns the EventInfo struct associated with this GPE.
364 * Validates the GpeBlock and the GpeNumber
365 *
366 * Should be called only when the GPE lists are semaphore locked
367 * and not subject to change.
368 *
369 ******************************************************************************/
370
373 ACPI_HANDLE GpeDevice,
375{
376 ACPI_OPERAND_OBJECT *ObjDesc;
377 ACPI_GPE_EVENT_INFO *GpeInfo;
378 UINT32 i;
379
380
382
383
384 /* A NULL GpeDevice means use the FADT-defined GPE block(s) */
385
386 if (!GpeDevice)
387 {
388 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
389
390 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++)
391 {
393 AcpiGbl_GpeFadtBlocks[i]);
394 if (GpeInfo)
395 {
396 return (GpeInfo);
397 }
398 }
399
400 /* The GpeNumber was not in the range of either FADT GPE block */
401
402 return (NULL);
403 }
404
405 /* A Non-NULL GpeDevice means this is a GPE Block Device */
406
407 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) GpeDevice);
408 if (!ObjDesc ||
409 !ObjDesc->Device.GpeBlock)
410 {
411 return (NULL);
412 }
413
414 return (AcpiEvLowGetGpeInfo (GpeNumber, ObjDesc->Device.GpeBlock));
415}
416
417
418/*******************************************************************************
419 *
420 * FUNCTION: AcpiEvGpeDetect
421 *
422 * PARAMETERS: GpeXruptList - Interrupt block for this interrupt.
423 * Can have multiple GPE blocks attached.
424 *
425 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
426 *
427 * DESCRIPTION: Detect if any GP events have occurred. This function is
428 * executed at interrupt level.
429 *
430 ******************************************************************************/
431
432UINT32
434 ACPI_GPE_XRUPT_INFO *GpeXruptList)
435{
436 ACPI_GPE_BLOCK_INFO *GpeBlock;
437 ACPI_NAMESPACE_NODE *GpeDevice;
438 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
443 UINT32 i;
444 UINT32 j;
445
446
447 ACPI_FUNCTION_NAME (EvGpeDetect);
448
449 /* Check for the case where there are no GPEs */
450
451 if (!GpeXruptList)
452 {
453 return (IntStatus);
454 }
455
456 /*
457 * We need to obtain the GPE lock for both the data structs and registers
458 * Note: Not necessary to obtain the hardware lock, since the GPE
459 * registers are owned by the GpeLock.
460 */
461 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
462
463 /* Examine all GPE blocks attached to this interrupt level */
464
465 GpeBlock = GpeXruptList->GpeBlockListHead;
466 while (GpeBlock)
467 {
468 GpeDevice = GpeBlock->Node;
469
470 /*
471 * Read all of the 8-bit GPE status and enable registers in this GPE
472 * block, saving all of them. Find all currently active GP events.
473 */
474 for (i = 0; i < GpeBlock->RegisterCount; i++)
475 {
476 /* Get the next status/enable pair */
477
478 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
479
480 /*
481 * Optimization: If there are no GPEs enabled within this
482 * register, we can safely ignore the entire register.
483 */
484 if (!(GpeRegisterInfo->EnableForRun |
485 GpeRegisterInfo->EnableForWake))
486 {
488 "Ignore disabled registers for GPE %02X-%02X: "
489 "RunEnable=%02X, WakeEnable=%02X\n",
490 GpeRegisterInfo->BaseGpeNumber,
491 GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
492 GpeRegisterInfo->EnableForRun,
493 GpeRegisterInfo->EnableForWake));
494 continue;
495 }
496
497 /* Now look at the individual GPEs in this byte register */
498
499 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
500 {
501 /* Detect and dispatch one GPE bit */
502
503 GpeEventInfo = &GpeBlock->EventInfo[((ACPI_SIZE) i *
505 GpeNumber = j + GpeRegisterInfo->BaseGpeNumber;
506 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
507 IntStatus |= AcpiEvDetectGpe (
508 GpeDevice, GpeEventInfo, GpeNumber);
509 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
510 }
511 }
512
513 GpeBlock = GpeBlock->Next;
514 }
515
516 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
517 return (IntStatus);
518}
519
520
521/*******************************************************************************
522 *
523 * FUNCTION: AcpiEvAsynchExecuteGpeMethod
524 *
525 * PARAMETERS: Context (GpeEventInfo) - Info for this GPE
526 *
527 * RETURN: None
528 *
529 * DESCRIPTION: Perform the actual execution of a GPE control method. This
530 * function is called from an invocation of AcpiOsExecute and
531 * therefore does NOT execute at interrupt level - so that
532 * the control method itself is not executed in the context of
533 * an interrupt handler.
534 *
535 ******************************************************************************/
536
537static void ACPI_SYSTEM_XFACE
539 void *Context)
540{
545
546
547 ACPI_FUNCTION_TRACE (EvAsynchExecuteGpeMethod);
548
549
550 /* Do the correct dispatch - normal method or implicit notify */
551
553 {
555 /*
556 * Implicit notify.
557 * Dispatch a DEVICE_WAKE notify to the appropriate handler.
558 * NOTE: the request is queued for execution after this method
559 * completes. The notify handlers are NOT invoked synchronously
560 * from this thread -- because handlers may in turn run other
561 * control methods.
562 *
563 * June 2012: Expand implicit notify mechanism to support
564 * notifies on multiple device objects.
565 */
567 while (ACPI_SUCCESS (Status) && Notify)
568 {
570 Notify->DeviceNode, ACPI_NOTIFY_DEVICE_WAKE);
571
572 Notify = Notify->Next;
573 }
574 break;
575
577
578 /* Allocate the evaluation information block */
579
581 if (!Info)
582 {
584 }
585 else
586 {
587 /*
588 * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the
589 * _Lxx/_Exx control method that corresponds to this GPE
590 */
591 Info->PrefixNode = GpeEventInfo->Dispatch.MethodNode;
593
595 ACPI_FREE (Info);
596 }
597
598 if (ACPI_FAILURE (Status))
599 {
601 "while evaluating GPE method [%4.4s]",
603 }
604 break;
605
606 default:
607
608 goto ErrorExit; /* Should never happen */
609 }
610
611 /* Defer enabling of GPE until all notify handlers are done */
612
615 if (ACPI_SUCCESS (Status))
616 {
618 }
619
623}
624
625
626/*******************************************************************************
627 *
628 * FUNCTION: AcpiEvAsynchEnableGpe
629 *
630 * PARAMETERS: Context (GpeEventInfo) - Info for this GPE
631 * Callback from AcpiOsExecute
632 *
633 * RETURN: None
634 *
635 * DESCRIPTION: Asynchronous clear/enable for GPE. This allows the GPE to
636 * complete (i.e., finish execution of Notify)
637 *
638 ******************************************************************************/
639
640static void ACPI_SYSTEM_XFACE
642 void *Context)
643{
646
647
648 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
650 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
651
652 return;
653}
654
655
656/*******************************************************************************
657 *
658 * FUNCTION: AcpiEvFinishGpe
659 *
660 * PARAMETERS: GpeEventInfo - Info for this GPE
661 *
662 * RETURN: Status
663 *
664 * DESCRIPTION: Clear/Enable a GPE. Common code that is used after execution
665 * of a GPE method or a synchronous or asynchronous GPE handler.
666 *
667 ******************************************************************************/
668
672{
674
675
678 {
679 /*
680 * GPE is level-triggered, we clear the GPE status bit after
681 * handling the event.
682 */
684 if (ACPI_FAILURE (Status))
685 {
686 return (Status);
687 }
688 }
689
690 /*
691 * Enable this GPE, conditionally. This means that the GPE will
692 * only be physically enabled if the EnableMask bit is set
693 * in the EventInfo.
694 */
697 return (AE_OK);
698}
699
700
701/*******************************************************************************
702 *
703 * FUNCTION: AcpiEvDetectGpe
704 *
705 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
706 * GpeEventInfo - Info for this GPE
707 * GpeNumber - Number relative to the parent GPE block
708 *
709 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
710 *
711 * DESCRIPTION: Detect and dispatch a General Purpose Event to either a function
712 * (e.g. EC) or method (e.g. _Lxx/_Exx) handler.
713 * NOTE: GPE is W1C, so it is possible to handle a single GPE from both
714 * task and irq context in parallel as long as the process to
715 * detect and mask the GPE is atomic.
716 * However the atomicity of ACPI_GPE_DISPATCH_RAW_HANDLER is
717 * dependent on the raw handler itself.
718 *
719 ******************************************************************************/
720
721UINT32
723 ACPI_NAMESPACE_NODE *GpeDevice,
726{
728 UINT8 EnabledStatusByte;
729 UINT64 StatusReg;
730 UINT64 EnableReg;
731 UINT32 RegisterBit;
732 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
733 ACPI_GPE_HANDLER_INFO *GpeHandlerInfo;
736
737
738 ACPI_FUNCTION_TRACE (EvGpeDetect);
739
740
741 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
742
743 if (!GpeEventInfo)
744 {
746 if (!GpeEventInfo)
747 {
748 goto ErrorExit;
749 }
750 }
751
752 /* Get the info block for the entire GPE register */
753
754 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
755
756 /* Get the register bitmask for this GPE */
757
759
760 /* GPE currently enabled (enable bit == 1)? */
761
762 Status = AcpiHwRead (&EnableReg, &GpeRegisterInfo->EnableAddress);
763 if (ACPI_FAILURE (Status))
764 {
765 goto ErrorExit;
766 }
767
768 /* GPE currently active (status bit == 1)? */
769
770 Status = AcpiHwRead (&StatusReg, &GpeRegisterInfo->StatusAddress);
771 if (ACPI_FAILURE (Status))
772 {
773 goto ErrorExit;
774 }
775
776 /* Check if there is anything active at all in this GPE */
777
779 "Read registers for GPE %02X: Status=%02X, Enable=%02X, "
780 "RunEnable=%02X, WakeEnable=%02X\n",
781 GpeNumber,
782 (UINT32) (StatusReg & RegisterBit),
783 (UINT32) (EnableReg & RegisterBit),
784 GpeRegisterInfo->EnableForRun,
785 GpeRegisterInfo->EnableForWake));
786
787 EnabledStatusByte = (UINT8) (StatusReg & EnableReg);
788 if (!(EnabledStatusByte & RegisterBit))
789 {
790 goto ErrorExit;
791 }
792
793 /* Invoke global event handler if present */
794
795 AcpiGpeCount++;
796 if (AcpiGbl_GlobalEventHandler)
797 {
798 AcpiGbl_GlobalEventHandler (ACPI_EVENT_TYPE_GPE,
799 GpeDevice, GpeNumber,
800 AcpiGbl_GlobalEventHandlerContext);
801 }
802
803 /* Found an active GPE */
804
807 {
808 /* Dispatch the event to a raw handler */
809
810 GpeHandlerInfo = GpeEventInfo->Dispatch.Handler;
811
812 /*
813 * There is no protection around the namespace node
814 * and the GPE handler to ensure a safe destruction
815 * because:
816 * 1. The namespace node is expected to always
817 * exist after loading a table.
818 * 2. The GPE handler is expected to be flushed by
819 * AcpiOsWaitEventsComplete() before the
820 * destruction.
821 */
822 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
823 IntStatus |= GpeHandlerInfo->Address (
824 GpeDevice, GpeNumber, GpeHandlerInfo->Context);
825 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
826 }
827 else
828 {
829 /* Dispatch the event to a standard handler or method. */
830
831 IntStatus |= AcpiEvGpeDispatch (GpeDevice,
833 }
834
836 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
837 return (IntStatus);
838}
839
840
841/*******************************************************************************
842 *
843 * FUNCTION: AcpiEvGpeDispatch
844 *
845 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
846 * GpeEventInfo - Info for this GPE
847 * GpeNumber - Number relative to the parent GPE block
848 *
849 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
850 *
851 * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
852 * or method (e.g. _Lxx/_Exx) handler.
853 *
854 ******************************************************************************/
855
856UINT32
858 ACPI_NAMESPACE_NODE *GpeDevice,
861{
864
865
866 ACPI_FUNCTION_TRACE (EvGpeDispatch);
867
868
869 /*
870 * Always disable the GPE so that it does not keep firing before
871 * any asynchronous activity completes (either from the execution
872 * of a GPE method or an asynchronous GPE handler.)
873 *
874 * If there is no handler or method to run, just disable the
875 * GPE and leave it disabled permanently to prevent further such
876 * pointless events from firing.
877 */
879 if (ACPI_FAILURE (Status))
880 {
882 "Unable to disable GPE %02X", GpeNumber));
884 }
885
886 /*
887 * If edge-triggered, clear the GPE status bit now. Note that
888 * level-triggered events are cleared after the GPE is serviced.
889 */
892 {
894 if (ACPI_FAILURE (Status))
895 {
897 "Unable to clear GPE %02X", GpeNumber));
901 }
902 }
903
905
906 /*
907 * Dispatch the GPE to either an installed handler or the control
908 * method associated with this GPE (_Lxx or _Exx). If a handler
909 * exists, we invoke it and do not attempt to run the method.
910 * If there is neither a handler nor a method, leave the GPE
911 * disabled.
912 */
914 {
916
917 /* Invoke the installed handler (at interrupt level) */
918
920 GpeDevice, GpeNumber,
922
923 /* If requested, clear (if level-triggered) and re-enable the GPE */
924
926 {
928 }
929 break;
930
933 /*
934 * Execute the method associated with the GPE
935 * NOTE: Level-triggered GPEs are cleared after the method completes.
936 */
939 if (ACPI_FAILURE (Status))
940 {
942 "Unable to queue handler for GPE %02X - event disabled",
943 GpeNumber));
944 }
945 break;
946
947 default:
948 /*
949 * No handler or method to run!
950 * 03/2010: This case should no longer be possible. We will not allow
951 * a GPE to be enabled if it has no handler or method.
952 */
954 "No handler or method for GPE %02X, disabling event",
955 GpeNumber));
956 break;
957 }
958
960}
961
962#endif /* !ACPI_REDUCED_HARDWARE */
unsigned char BOOLEAN
unsigned long long UINT64
unsigned char UINT8
unsigned int UINT32
#define ACPI_SYSTEM_XFACE
Definition: acenv.h:326
UINT32 void void ** ReturnValue
Definition: acevents.h:216
ACPI_GPE_EVENT_INFO * GpeEventInfo
Definition: acevents.h:195
ACPI_GPE_EVENT_INFO UINT32 GpeNumber
Definition: acevents.h:196
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
#define AE_NO_MEMORY
Definition: acexcep.h:112
#define AE_NOT_EXIST
Definition: acexcep.h:114
#define AE_LIMIT
Definition: acexcep.h:124
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
#define AE_OK
Definition: acexcep.h:97
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
ACPI_STATUS AcpiNsEvaluate(ACPI_EVALUATE_INFO *Info)
Definition: nseval.c:82
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
#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 ACPI_DB_INTERRUPTS
Definition: acoutput.h:178
#define AE_INFO
Definition: acoutput.h:230
#define return_VOID
Definition: acoutput.h:495
#define return_UINT32(s)
Definition: acoutput.h:501
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
@ OSL_NOTIFY_HANDLER
Definition: acpiosxf.h:58
@ OSL_GPE_HANDLER
Definition: acpiosxf.h:59
void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
Definition: osl.c:516
ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
Definition: osl.c:498
ACPI_STATUS AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function, void *Context)
Definition: osl.c:224
#define ACPI_IGNORE_RETURN_VALUE
Definition: acstruct.h:231
#define ACPI_GPE_LEVEL_TRIGGERED
Definition: actypes.h:827
#define ACPI_GPE_ENABLE
Definition: actypes.h:803
#define ACPI_GPE_CONDITIONAL_ENABLE
Definition: actypes.h:805
#define ACPI_NOTIFY_DEVICE_WAKE
Definition: actypes.h:658
#define ACPI_MAX_GPE_BLOCKS
Definition: actypes.h:403
#define ACPI_SET_BIT(target, bit)
Definition: actypes.h:533
#define ACPI_CPU_FLAGS
Definition: actypes.h:252
#define ACPI_FREE(a)
Definition: actypes.h:386
#define ACPI_INTERRUPT_HANDLED
Definition: actypes.h:1264
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_GPE_DISPATCH_TYPE(flags)
Definition: actypes.h:825
#define ACPI_GPE_DISPATCH_METHOD
Definition: actypes.h:820
#define ACPI_GPE_DISABLE
Definition: actypes.h:804
#define ACPI_GPE_DISPATCH_NOTIFY
Definition: actypes.h:822
#define ACPI_REENABLE_GPE
Definition: actypes.h:1268
#define ACPI_GPE_DISPATCH_RAW_HANDLER
Definition: actypes.h:823
#define ACPI_ALLOCATE_ZEROED(a)
Definition: actypes.h:385
#define ACPI_CLEAR_BIT(target, bit)
Definition: actypes.h:534
#define ACPI_UINT8_MAX
Definition: actypes.h:64
#define ACPI_GPE_XRUPT_TYPE_MASK
Definition: actypes.h:829
#define ACPI_INTERRUPT_NOT_HANDLED
Definition: actypes.h:1263
#define ACPI_GPE_EDGE_TRIGGERED
Definition: actypes.h:828
#define ACPI_GPE_REGISTER_WIDTH
Definition: actypes.h:407
#define ACPI_GPE_DISPATCH_HANDLER
Definition: actypes.h:821
#define ACPI_EVENT_TYPE_GPE
Definition: actypes.h:1143
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:306
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
BOOL WINAPI SHIM_OBJ_NAME() Notify(DWORD fdwReason, PVOID ptr)
UINT32 AcpiEvGpeDispatch(ACPI_NAMESPACE_NODE *GpeDevice, ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 GpeNumber)
Definition: evgpe.c:857
ACPI_STATUS AcpiEvFinishGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:670
ACPI_GPE_EVENT_INFO * AcpiEvGetGpeEventInfo(ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
Definition: evgpe.c:372
UINT32 AcpiEvGpeDetect(ACPI_GPE_XRUPT_INFO *GpeXruptList)
Definition: evgpe.c:433
ACPI_STATUS AcpiEvMaskGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo, BOOLEAN IsMasked)
Definition: evgpe.c:156
ACPI_STATUS AcpiEvUpdateGpeEnableMask(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:79
ACPI_STATUS AcpiEvEnableGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:126
ACPI_GPE_EVENT_INFO * AcpiEvLowGetGpeInfo(UINT32 GpeNumber, ACPI_GPE_BLOCK_INFO *GpeBlock)
Definition: evgpe.c:327
UINT32 AcpiEvDetectGpe(ACPI_NAMESPACE_NODE *GpeDevice, ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 GpeNumber)
Definition: evgpe.c:722
static void ACPI_SYSTEM_XFACE AcpiEvAsynchEnableGpe(void *Context)
Definition: evgpe.c:641
static void ACPI_SYSTEM_XFACE AcpiEvAsynchExecuteGpeMethod(void *Context)
Definition: evgpe.c:538
ACPI_STATUS AcpiEvRemoveGpeReference(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:276
ACPI_STATUS AcpiEvAddGpeReference(ACPI_GPE_EVENT_INFO *GpeEventInfo, BOOLEAN ClearOnEnable)
Definition: evgpe.c:221
ACPI_STATUS AcpiEvQueueNotifyRequest(ACPI_NAMESPACE_NODE *Node, UINT32 NotifyValue)
Definition: evmisc.c:111
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
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 GLint GLint j
Definition: glfuncs.h:250
UINT32 AcpiHwGetGpeRegisterBit(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: hwgpe.c:81
ACPI_STATUS AcpiHwClearGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: hwgpe.c:190
ACPI_STATUS AcpiHwLowSetGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 Action)
Definition: hwgpe.c:106
ACPI_STATUS AcpiHwRead(UINT64 *Value, ACPI_GENERIC_ADDRESS *Reg)
Definition: hwregs.c:259
UINT16 BlockBaseNumber
Definition: aclocal.h:592
UINT32 RegisterCount
Definition: aclocal.h:590
ACPI_GPE_REGISTER_INFO * RegisterInfo
Definition: aclocal.h:587
struct acpi_gpe_block_info * Next
Definition: aclocal.h:585
ACPI_NAMESPACE_NODE * Node
Definition: aclocal.h:583
ACPI_GPE_EVENT_INFO * EventInfo
Definition: aclocal.h:588
struct acpi_gpe_register_info * RegisterInfo
Definition: aclocal.h:555
union acpi_gpe_dispatch_info Dispatch
Definition: aclocal.h:554
BOOLEAN DisableForDispatch
Definition: aclocal.h:559
ACPI_GPE_HANDLER Address
Definition: aclocal.h:519
ACPI_GENERIC_ADDRESS EnableAddress
Definition: aclocal.h:568
ACPI_GENERIC_ADDRESS StatusAddress
Definition: aclocal.h:567
ACPI_GPE_BLOCK_INFO * GpeBlockListHead
Definition: aclocal.h:604
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_NOTIFY_INFO ACPI_GPE_BLOCK_INFO * GpeBlock
Definition: acobject.h:271
static VOID ErrorExit(LPTSTR lpszMessage)
Definition: telnetd.c:647
ACPI_GPE_HANDLER_INFO * Handler
Definition: aclocal.h:543
ACPI_GPE_NOTIFY_INFO * NotifyList
Definition: aclocal.h:544
ACPI_NAMESPACE_NODE * MethodNode
Definition: aclocal.h:542
ACPI_OBJECT_DEVICE Device
Definition: acobject.h:529
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170