1 /******************************************************************************
2 *
3 * Module Name: evgpe - General Purpose Event handling and dispatch
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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
57 AcpiEvAsynchExecuteGpeMethod (
58 void *Context);
59
60 static void ACPI_SYSTEM_XFACE
61 AcpiEvAsynchEnableGpe (
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
78 ACPI_STATUS
79 AcpiEvUpdateGpeEnableMask (
80 ACPI_GPE_EVENT_INFO *GpeEventInfo)
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 {
92 return_ACPI_STATUS (AE_NOT_EXIST);
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
103 if (GpeEventInfo->RuntimeCount)
104 {
105 ACPI_SET_BIT (GpeRegisterInfo->EnableForRun, (UINT8) RegisterBit);
106 }
107
108 return_ACPI_STATUS (AE_OK);
109 }
110
111
112 /*******************************************************************************
113 *
114 * FUNCTION: AcpiEvEnableGpe
115 *
116 * PARAMETERS: GpeEventInfo - GPE to enable
117 *
118 * RETURN: Status
119 *
120 * DESCRIPTION: Clear a GPE of stale events and enable it.
121 *
122 ******************************************************************************/
123
124 ACPI_STATUS
125 AcpiEvEnableGpe (
126 ACPI_GPE_EVENT_INFO *GpeEventInfo)
127 {
128 ACPI_STATUS Status;
129
130
131 ACPI_FUNCTION_TRACE (EvEnableGpe);
132
133
134 /*
135 * We will only allow a GPE to be enabled if it has either an associated
136 * method (_Lxx/_Exx) or a handler, or is using the implicit notify
137 * feature. Otherwise, the GPE will be immediately disabled by
138 * AcpiEvGpeDispatch the first time it fires.
139 */
140 if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==
141 ACPI_GPE_DISPATCH_NONE)
142 {
143 return_ACPI_STATUS (AE_NO_HANDLER);
144 }
145
146 /* Clear the GPE (of stale events) */
147
148 Status = AcpiHwClearGpe (GpeEventInfo);
149 if (ACPI_FAILURE (Status))
150 {
151 return_ACPI_STATUS (Status);
152 }
153
154 /* Enable the requested GPE */
155
156 Status = AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_ENABLE);
157 return_ACPI_STATUS (Status);
158 }
159
160
161 /*******************************************************************************
162 *
163 * FUNCTION: AcpiEvAddGpeReference
164 *
165 * PARAMETERS: GpeEventInfo - Add a reference to this GPE
166 *
167 * RETURN: Status
168 *
169 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
170 * hardware-enabled.
171 *
172 ******************************************************************************/
173
174 ACPI_STATUS
175 AcpiEvAddGpeReference (
176 ACPI_GPE_EVENT_INFO *GpeEventInfo)
177 {
178 ACPI_STATUS Status = AE_OK;
179
180
181 ACPI_FUNCTION_TRACE (EvAddGpeReference);
182
183
184 if (GpeEventInfo->RuntimeCount == ACPI_UINT8_MAX)
185 {
186 return_ACPI_STATUS (AE_LIMIT);
187 }
188
189 GpeEventInfo->RuntimeCount++;
190 if (GpeEventInfo->RuntimeCount == 1)
191 {
192 /* Enable on first reference */
193
194 Status = AcpiEvUpdateGpeEnableMask (GpeEventInfo);
195 if (ACPI_SUCCESS (Status))
196 {
197 Status = AcpiEvEnableGpe (GpeEventInfo);
198 }
199
200 if (ACPI_FAILURE (Status))
201 {
202 GpeEventInfo->RuntimeCount--;
203 }
204 }
205
206 return_ACPI_STATUS (Status);
207 }
208
209
210 /*******************************************************************************
211 *
212 * FUNCTION: AcpiEvRemoveGpeReference
213 *
214 * PARAMETERS: GpeEventInfo - Remove a reference to this GPE
215 *
216 * RETURN: Status
217 *
218 * DESCRIPTION: Remove a reference to a GPE. When the last reference is
219 * removed, the GPE is hardware-disabled.
220 *
221 ******************************************************************************/
222
223 ACPI_STATUS
224 AcpiEvRemoveGpeReference (
225 ACPI_GPE_EVENT_INFO *GpeEventInfo)
226 {
227 ACPI_STATUS Status = AE_OK;
228
229
230 ACPI_FUNCTION_TRACE (EvRemoveGpeReference);
231
232
233 if (!GpeEventInfo->RuntimeCount)
234 {
235 return_ACPI_STATUS (AE_LIMIT);
236 }
237
238 GpeEventInfo->RuntimeCount--;
239 if (!GpeEventInfo->RuntimeCount)
240 {
241 /* Disable on last reference */
242
243 Status = AcpiEvUpdateGpeEnableMask (GpeEventInfo);
244 if (ACPI_SUCCESS (Status))
245 {
246 Status = AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_DISABLE);
247 }
248
249 if (ACPI_FAILURE (Status))
250 {
251 GpeEventInfo->RuntimeCount++;
252 }
253 }
254
255 return_ACPI_STATUS (Status);
256 }
257
258
259 /*******************************************************************************
260 *
261 * FUNCTION: AcpiEvLowGetGpeInfo
262 *
263 * PARAMETERS: GpeNumber - Raw GPE number
264 * GpeBlock - A GPE info block
265 *
266 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE (The GpeNumber
267 * is not within the specified GPE block)
268 *
269 * DESCRIPTION: Returns the EventInfo struct associated with this GPE. This is
270 * the low-level implementation of EvGetGpeEventInfo.
271 *
272 ******************************************************************************/
273
274 ACPI_GPE_EVENT_INFO *
275 AcpiEvLowGetGpeInfo (
276 UINT32 GpeNumber,
277 ACPI_GPE_BLOCK_INFO *GpeBlock)
278 {
279 UINT32 GpeIndex;
280
281
282 /*
283 * Validate that the GpeNumber is within the specified GpeBlock.
284 * (Two steps)
285 */
286 if (!GpeBlock ||
287 (GpeNumber < GpeBlock->BlockBaseNumber))
288 {
289 return (NULL);
290 }
291
292 GpeIndex = GpeNumber - GpeBlock->BlockBaseNumber;
293 if (GpeIndex >= GpeBlock->GpeCount)
294 {
295 return (NULL);
296 }
297
298 return (&GpeBlock->EventInfo[GpeIndex]);
299 }
300
301
302 /*******************************************************************************
303 *
304 * FUNCTION: AcpiEvGetGpeEventInfo
305 *
306 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
307 * GpeNumber - Raw GPE number
308 *
309 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE
310 *
311 * DESCRIPTION: Returns the EventInfo struct associated with this GPE.
312 * Validates the GpeBlock and the GpeNumber
313 *
314 * Should be called only when the GPE lists are semaphore locked
315 * and not subject to change.
316 *
317 ******************************************************************************/
318
319 ACPI_GPE_EVENT_INFO *
320 AcpiEvGetGpeEventInfo (
321 ACPI_HANDLE GpeDevice,
322 UINT32 GpeNumber)
323 {
324 ACPI_OPERAND_OBJECT *ObjDesc;
325 ACPI_GPE_EVENT_INFO *GpeInfo;
326 UINT32 i;
327
328
329 ACPI_FUNCTION_ENTRY ();
330
331
332 /* A NULL GpeDevice means use the FADT-defined GPE block(s) */
333
334 if (!GpeDevice)
335 {
336 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
337
338 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++)
339 {
340 GpeInfo = AcpiEvLowGetGpeInfo (GpeNumber,
341 AcpiGbl_GpeFadtBlocks[i]);
342 if (GpeInfo)
343 {
344 return (GpeInfo);
345 }
346 }
347
348 /* The GpeNumber was not in the range of either FADT GPE block */
349
350 return (NULL);
351 }
352
353 /* A Non-NULL GpeDevice means this is a GPE Block Device */
354
355 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) GpeDevice);
356 if (!ObjDesc ||
357 !ObjDesc->Device.GpeBlock)
358 {
359 return (NULL);
360 }
361
362 return (AcpiEvLowGetGpeInfo (GpeNumber, ObjDesc->Device.GpeBlock));
363 }
364
365
366 /*******************************************************************************
367 *
368 * FUNCTION: AcpiEvGpeDetect
369 *
370 * PARAMETERS: GpeXruptList - Interrupt block for this interrupt.
371 * Can have multiple GPE blocks attached.
372 *
373 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
374 *
375 * DESCRIPTION: Detect if any GP events have occurred. This function is
376 * executed at interrupt level.
377 *
378 ******************************************************************************/
379
380 UINT32
381 AcpiEvGpeDetect (
382 ACPI_GPE_XRUPT_INFO *GpeXruptList)
383 {
384 ACPI_STATUS Status;
385 ACPI_GPE_BLOCK_INFO *GpeBlock;
386 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
387 UINT32 IntStatus = ACPI_INTERRUPT_NOT_HANDLED;
388 UINT8 EnabledStatusByte;
389 UINT32 StatusReg;
390 UINT32 EnableReg;
391 ACPI_CPU_FLAGS Flags;
392 UINT32 i;
393 UINT32 j;
394
395
396 ACPI_FUNCTION_NAME (EvGpeDetect);
397
398 /* Check for the case where there are no GPEs */
399
400 if (!GpeXruptList)
401 {
402 return (IntStatus);
403 }
404
405 /*
406 * We need to obtain the GPE lock for both the data structs and registers
407 * Note: Not necessary to obtain the hardware lock, since the GPE
408 * registers are owned by the GpeLock.
409 */
410 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
411
412 /* Examine all GPE blocks attached to this interrupt level */
413
414 GpeBlock = GpeXruptList->GpeBlockListHead;
415 while (GpeBlock)
416 {
417 /*
418 * Read all of the 8-bit GPE status and enable registers in this GPE
419 * block, saving all of them. Find all currently active GP events.
420 */
421 for (i = 0; i < GpeBlock->RegisterCount; i++)
422 {
423 /* Get the next status/enable pair */
424
425 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
426
427 /*
428 * Optimization: If there are no GPEs enabled within this
429 * register, we can safely ignore the entire register.
430 */
431 if (!(GpeRegisterInfo->EnableForRun |
432 GpeRegisterInfo->EnableForWake))
433 {
434 ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS,
435 "Ignore disabled registers for GPE%02X-GPE%02X: "
436 "RunEnable=%02X, WakeEnable=%02X\n",
437 GpeRegisterInfo->BaseGpeNumber,
438 GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
439 GpeRegisterInfo->EnableForRun,
440 GpeRegisterInfo->EnableForWake));
441 continue;
442 }
443
444 /* Read the Status Register */
445
446 Status = AcpiHwRead (&StatusReg, &GpeRegisterInfo->StatusAddress);
447 if (ACPI_FAILURE (Status))
448 {
449 goto UnlockAndExit;
450 }
451
452 /* Read the Enable Register */
453
454 Status = AcpiHwRead (&EnableReg, &GpeRegisterInfo->EnableAddress);
455 if (ACPI_FAILURE (Status))
456 {
457 goto UnlockAndExit;
458 }
459
460 ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS,
461 "Read registers for GPE%02X-GPE%02X: Status=%02X, Enable=%02X, "
462 "RunEnable=%02X, WakeEnable=%02X\n",
463 GpeRegisterInfo->BaseGpeNumber,
464 GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
465 StatusReg, EnableReg,
466 GpeRegisterInfo->EnableForRun,
467 GpeRegisterInfo->EnableForWake));
468
469 /* Check if there is anything active at all in this register */
470
471 EnabledStatusByte = (UINT8) (StatusReg & EnableReg);
472 if (!EnabledStatusByte)
473 {
474 /* No active GPEs in this register, move on */
475
476 continue;
477 }
478
479 /* Now look at the individual GPEs in this byte register */
480
481 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
482 {
483 /* Examine one GPE bit */
484
485 if (EnabledStatusByte & (1 << j))
486 {
487 /*
488 * Found an active GPE. Dispatch the event to a handler
489 * or method.
490 */
491 IntStatus |= AcpiEvGpeDispatch (GpeBlock->Node,
492 &GpeBlock->EventInfo[((ACPI_SIZE) i *
493 ACPI_GPE_REGISTER_WIDTH) + j],
494 j + GpeRegisterInfo->BaseGpeNumber);
495 }
496 }
497 }
498
499 GpeBlock = GpeBlock->Next;
500 }
501
502 UnlockAndExit:
503
504 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
505 return (IntStatus);
506 }
507
508
509 /*******************************************************************************
510 *
511 * FUNCTION: AcpiEvAsynchExecuteGpeMethod
512 *
513 * PARAMETERS: Context (GpeEventInfo) - Info for this GPE
514 *
515 * RETURN: None
516 *
517 * DESCRIPTION: Perform the actual execution of a GPE control method. This
518 * function is called from an invocation of AcpiOsExecute and
519 * therefore does NOT execute at interrupt level - so that
520 * the control method itself is not executed in the context of
521 * an interrupt handler.
522 *
523 ******************************************************************************/
524
525 static void ACPI_SYSTEM_XFACE
526 AcpiEvAsynchExecuteGpeMethod (
527 void *Context)
528 {
529 ACPI_GPE_EVENT_INFO *GpeEventInfo = Context;
530 ACPI_STATUS Status;
531 ACPI_GPE_EVENT_INFO *LocalGpeEventInfo;
532 ACPI_EVALUATE_INFO *Info;
533 ACPI_GPE_NOTIFY_INFO *Notify;
534
535
536 ACPI_FUNCTION_TRACE (EvAsynchExecuteGpeMethod);
537
538
539 /* Allocate a local GPE block */
540
541 LocalGpeEventInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_EVENT_INFO));
542 if (!LocalGpeEventInfo)
543 {
544 ACPI_EXCEPTION ((AE_INFO, AE_NO_MEMORY,
545 "while handling a GPE"));
546 return_VOID;
547 }
548
549 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
550 if (ACPI_FAILURE (Status))
551 {
552 ACPI_FREE (LocalGpeEventInfo);
553 return_VOID;
554 }
555
556 /* Must revalidate the GpeNumber/GpeBlock */
557
558 if (!AcpiEvValidGpeEvent (GpeEventInfo))
559 {
560 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
561 ACPI_FREE (LocalGpeEventInfo);
562 return_VOID;
563 }
564
565 /*
566 * Take a snapshot of the GPE info for this level - we copy the info to
567 * prevent a race condition with RemoveHandler/RemoveBlock.
568 */
569 ACPI_MEMCPY (LocalGpeEventInfo, GpeEventInfo,
570 sizeof (ACPI_GPE_EVENT_INFO));
571
572 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
573 if (ACPI_FAILURE (Status))
574 {
575 ACPI_FREE (LocalGpeEventInfo);
576 return_VOID;
577 }
578
579 /* Do the correct dispatch - normal method or implicit notify */
580
581 switch (LocalGpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)
582 {
583 case ACPI_GPE_DISPATCH_NOTIFY:
584 /*
585 * Implicit notify.
586 * Dispatch a DEVICE_WAKE notify to the appropriate handler.
587 * NOTE: the request is queued for execution after this method
588 * completes. The notify handlers are NOT invoked synchronously
589 * from this thread -- because handlers may in turn run other
590 * control methods.
591 *
592 * June 2012: Expand implicit notify mechanism to support
593 * notifies on multiple device objects.
594 */
595 Notify = LocalGpeEventInfo->Dispatch.NotifyList;
596 while (ACPI_SUCCESS (Status) && Notify)
597 {
598 Status = AcpiEvQueueNotifyRequest (Notify->DeviceNode,
599 ACPI_NOTIFY_DEVICE_WAKE);
600
601 Notify = Notify->Next;
602 }
603 break;
604
605 case ACPI_GPE_DISPATCH_METHOD:
606
607 /* Allocate the evaluation information block */
608
609 Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
610 if (!Info)
611 {
612 Status = AE_NO_MEMORY;
613 }
614 else
615 {
616 /*
617 * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the
618 * _Lxx/_Exx control method that corresponds to this GPE
619 */
620 Info->PrefixNode = LocalGpeEventInfo->Dispatch.MethodNode;
621 Info->Flags = ACPI_IGNORE_RETURN_VALUE;
622
623 Status = AcpiNsEvaluate (Info);
624 ACPI_FREE (Info);
625 }
626
627 if (ACPI_FAILURE (Status))
628 {
629 ACPI_EXCEPTION ((AE_INFO, Status,
630 "while evaluating GPE method [%4.4s]",
631 AcpiUtGetNodeName (LocalGpeEventInfo->Dispatch.MethodNode)));
632 }
633 break;
634
635 default:
636
637 return_VOID; /* Should never happen */
638 }
639
640 /* Defer enabling of GPE until all notify handlers are done */
641
642 Status = AcpiOsExecute (OSL_NOTIFY_HANDLER,
643 AcpiEvAsynchEnableGpe, LocalGpeEventInfo);
644 if (ACPI_FAILURE (Status))
645 {
646 ACPI_FREE (LocalGpeEventInfo);
647 }
648 return_VOID;
649 }
650
651
652 /*******************************************************************************
653 *
654 * FUNCTION: AcpiEvAsynchEnableGpe
655 *
656 * PARAMETERS: Context (GpeEventInfo) - Info for this GPE
657 * Callback from AcpiOsExecute
658 *
659 * RETURN: None
660 *
661 * DESCRIPTION: Asynchronous clear/enable for GPE. This allows the GPE to
662 * complete (i.e., finish execution of Notify)
663 *
664 ******************************************************************************/
665
666 static void ACPI_SYSTEM_XFACE
667 AcpiEvAsynchEnableGpe (
668 void *Context)
669 {
670 ACPI_GPE_EVENT_INFO *GpeEventInfo = Context;
671
672
673 (void) AcpiEvFinishGpe (GpeEventInfo);
674
675 ACPI_FREE (GpeEventInfo);
676 return;
677 }
678
679
680 /*******************************************************************************
681 *
682 * FUNCTION: AcpiEvFinishGpe
683 *
684 * PARAMETERS: GpeEventInfo - Info for this GPE
685 *
686 * RETURN: Status
687 *
688 * DESCRIPTION: Clear/Enable a GPE. Common code that is used after execution
689 * of a GPE method or a synchronous or asynchronous GPE handler.
690 *
691 ******************************************************************************/
692
693 ACPI_STATUS
694 AcpiEvFinishGpe (
695 ACPI_GPE_EVENT_INFO *GpeEventInfo)
696 {
697 ACPI_STATUS Status;
698
699
700 if ((GpeEventInfo->Flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
701 ACPI_GPE_LEVEL_TRIGGERED)
702 {
703 /*
704 * GPE is level-triggered, we clear the GPE status bit after
705 * handling the event.
706 */
707 Status = AcpiHwClearGpe (GpeEventInfo);
708 if (ACPI_FAILURE (Status))
709 {
710 return (Status);
711 }
712 }
713
714 /*
715 * Enable this GPE, conditionally. This means that the GPE will
716 * only be physically enabled if the EnableForRun bit is set
717 * in the EventInfo.
718 */
719 (void) AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_CONDITIONAL_ENABLE);
720 return (AE_OK);
721 }
722
723
724 /*******************************************************************************
725 *
726 * FUNCTION: AcpiEvGpeDispatch
727 *
728 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
729 * GpeEventInfo - Info for this GPE
730 * GpeNumber - Number relative to the parent GPE block
731 *
732 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
733 *
734 * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
735 * or method (e.g. _Lxx/_Exx) handler.
736 *
737 * This function executes at interrupt level.
738 *
739 ******************************************************************************/
740
741 UINT32
742 AcpiEvGpeDispatch (
743 ACPI_NAMESPACE_NODE *GpeDevice,
744 ACPI_GPE_EVENT_INFO *GpeEventInfo,
745 UINT32 GpeNumber)
746 {
747 ACPI_STATUS Status;
748 UINT32 ReturnValue;
749
750
751 ACPI_FUNCTION_TRACE (EvGpeDispatch);
752
753
754 /* Invoke global event handler if present */
755
756 AcpiGpeCount++;
757 if (AcpiGbl_GlobalEventHandler)
758 {
759 AcpiGbl_GlobalEventHandler (ACPI_EVENT_TYPE_GPE, GpeDevice,
760 GpeNumber, AcpiGbl_GlobalEventHandlerContext);
761 }
762
763 /*
764 * If edge-triggered, clear the GPE status bit now. Note that
765 * level-triggered events are cleared after the GPE is serviced.
766 */
767 if ((GpeEventInfo->Flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
768 ACPI_GPE_EDGE_TRIGGERED)
769 {
770 Status = AcpiHwClearGpe (GpeEventInfo);
771 if (ACPI_FAILURE (Status))
772 {
773 ACPI_EXCEPTION ((AE_INFO, Status,
774 "Unable to clear GPE%02X", GpeNumber));
775 return_UINT32 (ACPI_INTERRUPT_NOT_HANDLED);
776 }
777 }
778
779 /*
780 * Always disable the GPE so that it does not keep firing before
781 * any asynchronous activity completes (either from the execution
782 * of a GPE method or an asynchronous GPE handler.)
783 *
784 * If there is no handler or method to run, just disable the
785 * GPE and leave it disabled permanently to prevent further such
786 * pointless events from firing.
787 */
788 Status = AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_DISABLE);
789 if (ACPI_FAILURE (Status))
790 {
791 ACPI_EXCEPTION ((AE_INFO, Status,
792 "Unable to disable GPE%02X", GpeNumber));
793 return_UINT32 (ACPI_INTERRUPT_NOT_HANDLED);
794 }
795
796 /*
797 * Dispatch the GPE to either an installed handler or the control
798 * method associated with this GPE (_Lxx or _Exx). If a handler
799 * exists, we invoke it and do not attempt to run the method.
800 * If there is neither a handler nor a method, leave the GPE
801 * disabled.
802 */
803 switch (GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)
804 {
805 case ACPI_GPE_DISPATCH_HANDLER:
806
807 /* Invoke the installed handler (at interrupt level) */
808
809 ReturnValue = GpeEventInfo->Dispatch.Handler->Address (
810 GpeDevice, GpeNumber,
811 GpeEventInfo->Dispatch.Handler->Context);
812
813 /* If requested, clear (if level-triggered) and reenable the GPE */
814
815 if (ReturnValue & ACPI_REENABLE_GPE)
816 {
817 (void) AcpiEvFinishGpe (GpeEventInfo);
818 }
819 break;
820
821 case ACPI_GPE_DISPATCH_METHOD:
822 case ACPI_GPE_DISPATCH_NOTIFY:
823 /*
824 * Execute the method associated with the GPE
825 * NOTE: Level-triggered GPEs are cleared after the method completes.
826 */
827 Status = AcpiOsExecute (OSL_GPE_HANDLER,
828 AcpiEvAsynchExecuteGpeMethod, GpeEventInfo);
829 if (ACPI_FAILURE (Status))
830 {
831 ACPI_EXCEPTION ((AE_INFO, Status,
832 "Unable to queue handler for GPE%02X - event disabled",
833 GpeNumber));
834 }
835 break;
836
837 default:
838 /*
839 * No handler or method to run!
840 * 03/2010: This case should no longer be possible. We will not allow
841 * a GPE to be enabled if it has no handler or method.
842 */
843 ACPI_ERROR ((AE_INFO,
844 "No handler or method for GPE%02X, disabling event",
845 GpeNumber));
846 break;
847 }
848
849 return_UINT32 (ACPI_INTERRUPT_HANDLED);
850 }
851
852 #endif /* !ACPI_REDUCED_HARDWARE */