ReactOS  0.4.14-dev-358-gbef841c
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 - 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 #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 
56 static void ACPI_SYSTEM_XFACE
58  void *Context);
59 
60 static 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 
95  RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
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 
173  RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
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);
195  if (GpeEventInfo->RuntimeCount &&
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  {
392  GpeInfo = AcpiEvLowGetGpeInfo (GpeNumber,
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 
432 UINT32
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 
537 static 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  {
617  return_VOID;
618  }
619 
620 ErrorExit:
622  return_VOID;
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 
640 static 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 
721 UINT32
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 
758  RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
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 
835 ErrorExit:
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 
856 UINT32
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 */
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
struct acpi_gpe_block_info * Next
Definition: aclocal.h:585
#define ACPI_GPE_CONDITIONAL_ENABLE
Definition: actypes.h:795
BOOL WINAPI SHIM_OBJ_NAME() Notify(DWORD fdwReason, PVOID ptr)
ACPI_GPE_NOTIFY_INFO * NotifyList
Definition: aclocal.h:544
#define ACPI_FREE(a)
Definition: actypes.h:386
#define ACPI_ALLOCATE_ZEROED(a)
Definition: actypes.h:385
#define TRUE
Definition: types.h:120
ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
Definition: osl.c:498
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define ACPI_NOTIFY_DEVICE_WAKE
Definition: actypes.h:649
ACPI_STATUS AcpiEvMaskGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo, BOOLEAN IsMasked)
Definition: evgpe.c:156
#define AE_NO_MEMORY
Definition: acexcep.h:112
BOOLEAN DisableForDispatch
Definition: aclocal.h:559
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
#define ACPI_MAX_GPE_BLOCKS
Definition: actypes.h:403
#define ACPI_SET_BIT(target, bit)
Definition: actypes.h:533
#define return_UINT32(s)
Definition: acoutput.h:501
#define ACPI_GPE_DISPATCH_TYPE(flags)
Definition: actypes.h:815
ACPI_STATUS AcpiNsEvaluate(ACPI_EVALUATE_INFO *Info)
Definition: nseval.c:82
ACPI_STATUS AcpiEvUpdateGpeEnableMask(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:79
ACPI_GPE_EVENT_INFO * GpeEventInfo
Definition: acevents.h:195
ACPI_STATUS AcpiEvAddGpeReference(ACPI_GPE_EVENT_INFO *GpeEventInfo, BOOLEAN ClearOnEnable)
Definition: evgpe.c:221
#define ACPI_CPU_FLAGS
Definition: actypes.h:252
ACPI_GPE_EVENT_INFO * AcpiEvGetGpeEventInfo(ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
Definition: evgpe.c:372
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_GPE_DISPATCH_RAW_HANDLER
Definition: actypes.h:813
ACPI_GPE_HANDLER_INFO * Handler
Definition: aclocal.h:543
#define AE_LIMIT
Definition: acexcep.h:124
struct TraceInfo Info
static void ACPI_SYSTEM_XFACE AcpiEvAsynchExecuteGpeMethod(void *Context)
Definition: evgpe.c:538
#define ACPI_DB_INTERRUPTS
Definition: acoutput.h:178
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#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_GPE_DISPATCH_NOTIFY
Definition: actypes.h:812
UINT32 void void ** ReturnValue
Definition: acevents.h:214
ACPI_GENERIC_ADDRESS EnableAddress
Definition: aclocal.h:568
unsigned int UINT32
union acpi_gpe_dispatch_info Dispatch
Definition: aclocal.h:554
#define ACPI_GPE_DISPATCH_HANDLER
Definition: actypes.h:811
UINT32 AcpiEvGpeDispatch(ACPI_NAMESPACE_NODE *GpeDevice, ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 GpeNumber)
Definition: evgpe.c:857
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
ACPI_GPE_EVENT_INFO * AcpiEvLowGetGpeInfo(UINT32 GpeNumber, ACPI_GPE_BLOCK_INFO *GpeBlock)
Definition: evgpe.c:327
#define ACPI_GPE_DISPATCH_METHOD
Definition: actypes.h:810
unsigned char BOOLEAN
#define ACPI_UINT8_MAX
Definition: actypes.h:64
#define AE_INFO
Definition: acoutput.h:230
smooth NULL
Definition: ftsmooth.c:416
#define ACPI_REENABLE_GPE
Definition: actypes.h:1243
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484
ACPI_STATUS AcpiEvRemoveGpeReference(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:276
UINT32 AcpiHwGetGpeRegisterBit(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: hwgpe.c:81
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
ACPI_GPE_HANDLER Address
Definition: aclocal.h:519
#define ACPI_GPE_XRUPT_TYPE_MASK
Definition: actypes.h:819
#define ACPI_INTERRUPT_HANDLED
Definition: actypes.h:1239
struct acpi_gpe_register_info * RegisterInfo
Definition: aclocal.h:555
ACPI_STATUS AcpiEvEnableGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:126
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_NOTIFY_INFO ACPI_GPE_BLOCK_INFO * GpeBlock
Definition: acobject.h:270
#define ACPI_SYSTEM_XFACE
Definition: acenv.h:311
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define ACPI_CLEAR_BIT(target, bit)
Definition: actypes.h:534
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
ACPI_GENERIC_ADDRESS StatusAddress
Definition: aclocal.h:567
#define return_VOID
Definition: acoutput.h:495
#define ACPI_GPE_LEVEL_TRIGGERED
Definition: actypes.h:817
ACPI_STATUS AcpiHwRead(UINT64 *Value, ACPI_GENERIC_ADDRESS *Reg)
Definition: hwregs.c:259
#define AE_NOT_EXIST
Definition: acexcep.h:114
ACPI_GPE_BLOCK_INFO * GpeBlockListHead
Definition: aclocal.h:604
ACPI_GPE_EVENT_INFO UINT32 GpeNumber
Definition: acevents.h:195
#define ACPI_INTERRUPT_NOT_HANDLED
Definition: actypes.h:1238
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
#define ACPI_EVENT_TYPE_GPE
Definition: actypes.h:1132
UINT32 RegisterCount
Definition: aclocal.h:590
Status
Definition: gdiplustypes.h:24
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
static VOID ErrorExit(LPTSTR lpszMessage)
Definition: telnetd.c:647
UINT32 AcpiEvDetectGpe(ACPI_NAMESPACE_NODE *GpeDevice, ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 GpeNumber)
Definition: evgpe.c:722
ACPI_STATUS AcpiEvFinishGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo)
Definition: evgpe.c:670
ACPI_OBJECT_DEVICE Device
Definition: acobject.h:526
ACPI_STATUS AcpiEvQueueNotifyRequest(ACPI_NAMESPACE_NODE *Node, UINT32 NotifyValue)
Definition: evmisc.c:111
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
static void ACPI_SYSTEM_XFACE AcpiEvAsynchEnableGpe(void *Context)
Definition: evgpe.c:641
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:305
#define ACPI_GPE_DISABLE
Definition: actypes.h:794
#define ACPI_GPE_EDGE_TRIGGERED
Definition: actypes.h:818
void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
Definition: osl.c:516
struct tagContext Context
Definition: acpixf.h:1030
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
#define ACPI_IGNORE_RETURN_VALUE
Definition: acstruct.h:231
unsigned long long UINT64
#define ACPI_GPE_REGISTER_WIDTH
Definition: actypes.h:407
ACPI_NAMESPACE_NODE * MethodNode
Definition: aclocal.h:542
unsigned char UINT8
ACPI_STATUS AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function, void *Context)
Definition: osl.c:224
#define AE_OK
Definition: acexcep.h:97
ACPI_GPE_EVENT_INFO * EventInfo
Definition: aclocal.h:588
ACPI_NAMESPACE_NODE * Node
Definition: aclocal.h:583
UINT16 BlockBaseNumber
Definition: aclocal.h:592
ACPI_STATUS AcpiHwLowSetGpe(ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 Action)
Definition: hwgpe.c:106
UINT32 AcpiEvGpeDetect(ACPI_GPE_XRUPT_INFO *GpeXruptList)
Definition: evgpe.c:433