xref: /openbmc/linux/drivers/acpi/acpica/evgpe.c (revision b34e08d5)
1 /******************************************************************************
2  *
3  * Module Name: evgpe - General Purpose Event handling and dispatch
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2014, 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/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 #if (!ACPI_REDUCED_HARDWARE)	/* Entire module */
52 /* Local prototypes */
53 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
54 
55 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context);
56 
57 /*******************************************************************************
58  *
59  * FUNCTION:    acpi_ev_update_gpe_enable_mask
60  *
61  * PARAMETERS:  gpe_event_info          - GPE to update
62  *
63  * RETURN:      Status
64  *
65  * DESCRIPTION: Updates GPE register enable mask based upon whether there are
66  *              runtime references to this GPE
67  *
68  ******************************************************************************/
69 
70 acpi_status
71 acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info)
72 {
73 	struct acpi_gpe_register_info *gpe_register_info;
74 	u32 register_bit;
75 
76 	ACPI_FUNCTION_TRACE(ev_update_gpe_enable_mask);
77 
78 	gpe_register_info = gpe_event_info->register_info;
79 	if (!gpe_register_info) {
80 		return_ACPI_STATUS(AE_NOT_EXIST);
81 	}
82 
83 	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
84 
85 	/* Clear the run bit up front */
86 
87 	ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
88 
89 	/* Set the mask bit only if there are references to this GPE */
90 
91 	if (gpe_event_info->runtime_count) {
92 		ACPI_SET_BIT(gpe_register_info->enable_for_run,
93 			     (u8)register_bit);
94 	}
95 
96 	return_ACPI_STATUS(AE_OK);
97 }
98 
99 /*******************************************************************************
100  *
101  * FUNCTION:    acpi_ev_enable_gpe
102  *
103  * PARAMETERS:  gpe_event_info  - GPE to enable
104  *
105  * RETURN:      Status
106  *
107  * DESCRIPTION: Clear a GPE of stale events and enable it.
108  *
109  ******************************************************************************/
110 acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
111 {
112 	acpi_status status;
113 
114 	ACPI_FUNCTION_TRACE(ev_enable_gpe);
115 
116 	/*
117 	 * We will only allow a GPE to be enabled if it has either an associated
118 	 * method (_Lxx/_Exx) or a handler, or is using the implicit notify
119 	 * feature. Otherwise, the GPE will be immediately disabled by
120 	 * acpi_ev_gpe_dispatch the first time it fires.
121 	 */
122 	if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
123 	    ACPI_GPE_DISPATCH_NONE) {
124 		return_ACPI_STATUS(AE_NO_HANDLER);
125 	}
126 
127 	/* Clear the GPE (of stale events) */
128 	status = acpi_hw_clear_gpe(gpe_event_info);
129 	if (ACPI_FAILURE(status)) {
130 		return_ACPI_STATUS(status);
131 	}
132 
133 	/* Enable the requested GPE */
134 
135 	status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
136 	return_ACPI_STATUS(status);
137 }
138 
139 
140 /*******************************************************************************
141  *
142  * FUNCTION:    acpi_ev_add_gpe_reference
143  *
144  * PARAMETERS:  gpe_event_info          - Add a reference to this GPE
145  *
146  * RETURN:      Status
147  *
148  * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
149  *              hardware-enabled.
150  *
151  ******************************************************************************/
152 
153 acpi_status
154 acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
155 {
156 	acpi_status status = AE_OK;
157 
158 	ACPI_FUNCTION_TRACE(ev_add_gpe_reference);
159 
160 	if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
161 		return_ACPI_STATUS(AE_LIMIT);
162 	}
163 
164 	gpe_event_info->runtime_count++;
165 	if (gpe_event_info->runtime_count == 1) {
166 
167 		/* Enable on first reference */
168 
169 		status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
170 		if (ACPI_SUCCESS(status)) {
171 			status = acpi_ev_enable_gpe(gpe_event_info);
172 		}
173 
174 		if (ACPI_FAILURE(status)) {
175 			gpe_event_info->runtime_count--;
176 		}
177 	}
178 
179 	return_ACPI_STATUS(status);
180 }
181 
182 /*******************************************************************************
183  *
184  * FUNCTION:    acpi_ev_remove_gpe_reference
185  *
186  * PARAMETERS:  gpe_event_info          - Remove a reference to this GPE
187  *
188  * RETURN:      Status
189  *
190  * DESCRIPTION: Remove a reference to a GPE. When the last reference is
191  *              removed, the GPE is hardware-disabled.
192  *
193  ******************************************************************************/
194 
195 acpi_status
196 acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
197 {
198 	acpi_status status = AE_OK;
199 
200 	ACPI_FUNCTION_TRACE(ev_remove_gpe_reference);
201 
202 	if (!gpe_event_info->runtime_count) {
203 		return_ACPI_STATUS(AE_LIMIT);
204 	}
205 
206 	gpe_event_info->runtime_count--;
207 	if (!gpe_event_info->runtime_count) {
208 
209 		/* Disable on last reference */
210 
211 		status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
212 		if (ACPI_SUCCESS(status)) {
213 			status =
214 			    acpi_hw_low_set_gpe(gpe_event_info,
215 						     ACPI_GPE_DISABLE);
216 		}
217 
218 		if (ACPI_FAILURE(status)) {
219 			gpe_event_info->runtime_count++;
220 		}
221 	}
222 
223 	return_ACPI_STATUS(status);
224 }
225 
226 /*******************************************************************************
227  *
228  * FUNCTION:    acpi_ev_low_get_gpe_info
229  *
230  * PARAMETERS:  gpe_number          - Raw GPE number
231  *              gpe_block           - A GPE info block
232  *
233  * RETURN:      A GPE event_info struct. NULL if not a valid GPE (The gpe_number
234  *              is not within the specified GPE block)
235  *
236  * DESCRIPTION: Returns the event_info struct associated with this GPE. This is
237  *              the low-level implementation of ev_get_gpe_event_info.
238  *
239  ******************************************************************************/
240 
241 struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number,
242 						     struct acpi_gpe_block_info
243 						     *gpe_block)
244 {
245 	u32 gpe_index;
246 
247 	/*
248 	 * Validate that the gpe_number is within the specified gpe_block.
249 	 * (Two steps)
250 	 */
251 	if (!gpe_block || (gpe_number < gpe_block->block_base_number)) {
252 		return (NULL);
253 	}
254 
255 	gpe_index = gpe_number - gpe_block->block_base_number;
256 	if (gpe_index >= gpe_block->gpe_count) {
257 		return (NULL);
258 	}
259 
260 	return (&gpe_block->event_info[gpe_index]);
261 }
262 
263 
264 /*******************************************************************************
265  *
266  * FUNCTION:    acpi_ev_get_gpe_event_info
267  *
268  * PARAMETERS:  gpe_device          - Device node. NULL for GPE0/GPE1
269  *              gpe_number          - Raw GPE number
270  *
271  * RETURN:      A GPE event_info struct. NULL if not a valid GPE
272  *
273  * DESCRIPTION: Returns the event_info struct associated with this GPE.
274  *              Validates the gpe_block and the gpe_number
275  *
276  *              Should be called only when the GPE lists are semaphore locked
277  *              and not subject to change.
278  *
279  ******************************************************************************/
280 
281 struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
282 						       u32 gpe_number)
283 {
284 	union acpi_operand_object *obj_desc;
285 	struct acpi_gpe_event_info *gpe_info;
286 	u32 i;
287 
288 	ACPI_FUNCTION_ENTRY();
289 
290 	/* A NULL gpe_device means use the FADT-defined GPE block(s) */
291 
292 	if (!gpe_device) {
293 
294 		/* Examine GPE Block 0 and 1 (These blocks are permanent) */
295 
296 		for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) {
297 			gpe_info = acpi_ev_low_get_gpe_info(gpe_number,
298 							    acpi_gbl_gpe_fadt_blocks
299 							    [i]);
300 			if (gpe_info) {
301 				return (gpe_info);
302 			}
303 		}
304 
305 		/* The gpe_number was not in the range of either FADT GPE block */
306 
307 		return (NULL);
308 	}
309 
310 	/* A Non-NULL gpe_device means this is a GPE Block Device */
311 
312 	obj_desc =
313 	    acpi_ns_get_attached_object((struct acpi_namespace_node *)
314 					       gpe_device);
315 	if (!obj_desc || !obj_desc->device.gpe_block) {
316 		return (NULL);
317 	}
318 
319 	return (acpi_ev_low_get_gpe_info
320 		(gpe_number, obj_desc->device.gpe_block));
321 }
322 
323 /*******************************************************************************
324  *
325  * FUNCTION:    acpi_ev_gpe_detect
326  *
327  * PARAMETERS:  gpe_xrupt_list      - Interrupt block for this interrupt.
328  *                                    Can have multiple GPE blocks attached.
329  *
330  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
331  *
332  * DESCRIPTION: Detect if any GP events have occurred. This function is
333  *              executed at interrupt level.
334  *
335  ******************************************************************************/
336 
337 u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
338 {
339 	acpi_status status;
340 	struct acpi_gpe_block_info *gpe_block;
341 	struct acpi_gpe_register_info *gpe_register_info;
342 	u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
343 	u8 enabled_status_byte;
344 	u32 status_reg;
345 	u32 enable_reg;
346 	acpi_cpu_flags flags;
347 	u32 i;
348 	u32 j;
349 
350 	ACPI_FUNCTION_NAME(ev_gpe_detect);
351 
352 	/* Check for the case where there are no GPEs */
353 
354 	if (!gpe_xrupt_list) {
355 		return (int_status);
356 	}
357 
358 	/*
359 	 * We need to obtain the GPE lock for both the data structs and registers
360 	 * Note: Not necessary to obtain the hardware lock, since the GPE
361 	 * registers are owned by the gpe_lock.
362 	 */
363 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
364 
365 	/* Examine all GPE blocks attached to this interrupt level */
366 
367 	gpe_block = gpe_xrupt_list->gpe_block_list_head;
368 	while (gpe_block) {
369 		/*
370 		 * Read all of the 8-bit GPE status and enable registers in this GPE
371 		 * block, saving all of them. Find all currently active GP events.
372 		 */
373 		for (i = 0; i < gpe_block->register_count; i++) {
374 
375 			/* Get the next status/enable pair */
376 
377 			gpe_register_info = &gpe_block->register_info[i];
378 
379 			/*
380 			 * Optimization: If there are no GPEs enabled within this
381 			 * register, we can safely ignore the entire register.
382 			 */
383 			if (!(gpe_register_info->enable_for_run |
384 			      gpe_register_info->enable_for_wake)) {
385 				ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
386 						  "Ignore disabled registers for GPE%02X-GPE%02X: "
387 						  "RunEnable=%02X, WakeEnable=%02X\n",
388 						  gpe_register_info->
389 						  base_gpe_number,
390 						  gpe_register_info->
391 						  base_gpe_number +
392 						  (ACPI_GPE_REGISTER_WIDTH - 1),
393 						  gpe_register_info->
394 						  enable_for_run,
395 						  gpe_register_info->
396 						  enable_for_wake));
397 				continue;
398 			}
399 
400 			/* Read the Status Register */
401 
402 			status =
403 			    acpi_hw_read(&status_reg,
404 					 &gpe_register_info->status_address);
405 			if (ACPI_FAILURE(status)) {
406 				goto unlock_and_exit;
407 			}
408 
409 			/* Read the Enable Register */
410 
411 			status =
412 			    acpi_hw_read(&enable_reg,
413 					 &gpe_register_info->enable_address);
414 			if (ACPI_FAILURE(status)) {
415 				goto unlock_and_exit;
416 			}
417 
418 			ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
419 					  "Read registers for GPE%02X-GPE%02X: Status=%02X, Enable=%02X, "
420 					  "RunEnable=%02X, WakeEnable=%02X\n",
421 					  gpe_register_info->base_gpe_number,
422 					  gpe_register_info->base_gpe_number +
423 					  (ACPI_GPE_REGISTER_WIDTH - 1),
424 					  status_reg, enable_reg,
425 					  gpe_register_info->enable_for_run,
426 					  gpe_register_info->enable_for_wake));
427 
428 			/* Check if there is anything active at all in this register */
429 
430 			enabled_status_byte = (u8) (status_reg & enable_reg);
431 			if (!enabled_status_byte) {
432 
433 				/* No active GPEs in this register, move on */
434 
435 				continue;
436 			}
437 
438 			/* Now look at the individual GPEs in this byte register */
439 
440 			for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
441 
442 				/* Examine one GPE bit */
443 
444 				if (enabled_status_byte & (1 << j)) {
445 					/*
446 					 * Found an active GPE. Dispatch the event to a handler
447 					 * or method.
448 					 */
449 					int_status |=
450 					    acpi_ev_gpe_dispatch(gpe_block->
451 								 node,
452 								 &gpe_block->
453 						event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number);
454 				}
455 			}
456 		}
457 
458 		gpe_block = gpe_block->next;
459 	}
460 
461 unlock_and_exit:
462 
463 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
464 	return (int_status);
465 }
466 
467 /*******************************************************************************
468  *
469  * FUNCTION:    acpi_ev_asynch_execute_gpe_method
470  *
471  * PARAMETERS:  Context (gpe_event_info) - Info for this GPE
472  *
473  * RETURN:      None
474  *
475  * DESCRIPTION: Perform the actual execution of a GPE control method. This
476  *              function is called from an invocation of acpi_os_execute and
477  *              therefore does NOT execute at interrupt level - so that
478  *              the control method itself is not executed in the context of
479  *              an interrupt handler.
480  *
481  ******************************************************************************/
482 
483 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
484 {
485 	struct acpi_gpe_event_info *gpe_event_info = context;
486 	acpi_status status;
487 	struct acpi_gpe_event_info *local_gpe_event_info;
488 	struct acpi_evaluate_info *info;
489 	struct acpi_gpe_notify_info *notify;
490 
491 	ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method);
492 
493 	/* Allocate a local GPE block */
494 
495 	local_gpe_event_info =
496 	    ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_event_info));
497 	if (!local_gpe_event_info) {
498 		ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, "while handling a GPE"));
499 		return_VOID;
500 	}
501 
502 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
503 	if (ACPI_FAILURE(status)) {
504 		ACPI_FREE(local_gpe_event_info);
505 		return_VOID;
506 	}
507 
508 	/* Must revalidate the gpe_number/gpe_block */
509 
510 	if (!acpi_ev_valid_gpe_event(gpe_event_info)) {
511 		status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
512 		ACPI_FREE(local_gpe_event_info);
513 		return_VOID;
514 	}
515 
516 	/*
517 	 * Take a snapshot of the GPE info for this level - we copy the info to
518 	 * prevent a race condition with remove_handler/remove_block.
519 	 */
520 	ACPI_MEMCPY(local_gpe_event_info, gpe_event_info,
521 		    sizeof(struct acpi_gpe_event_info));
522 
523 	status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
524 	if (ACPI_FAILURE(status)) {
525 		ACPI_FREE(local_gpe_event_info);
526 		return_VOID;
527 	}
528 
529 	/* Do the correct dispatch - normal method or implicit notify */
530 
531 	switch (local_gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
532 	case ACPI_GPE_DISPATCH_NOTIFY:
533 		/*
534 		 * Implicit notify.
535 		 * Dispatch a DEVICE_WAKE notify to the appropriate handler.
536 		 * NOTE: the request is queued for execution after this method
537 		 * completes. The notify handlers are NOT invoked synchronously
538 		 * from this thread -- because handlers may in turn run other
539 		 * control methods.
540 		 *
541 		 * June 2012: Expand implicit notify mechanism to support
542 		 * notifies on multiple device objects.
543 		 */
544 		notify = local_gpe_event_info->dispatch.notify_list;
545 		while (ACPI_SUCCESS(status) && notify) {
546 			status =
547 			    acpi_ev_queue_notify_request(notify->device_node,
548 							 ACPI_NOTIFY_DEVICE_WAKE);
549 
550 			notify = notify->next;
551 		}
552 
553 		break;
554 
555 	case ACPI_GPE_DISPATCH_METHOD:
556 
557 		/* Allocate the evaluation information block */
558 
559 		info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
560 		if (!info) {
561 			status = AE_NO_MEMORY;
562 		} else {
563 			/*
564 			 * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the
565 			 * _Lxx/_Exx control method that corresponds to this GPE
566 			 */
567 			info->prefix_node =
568 			    local_gpe_event_info->dispatch.method_node;
569 			info->flags = ACPI_IGNORE_RETURN_VALUE;
570 
571 			status = acpi_ns_evaluate(info);
572 			ACPI_FREE(info);
573 		}
574 
575 		if (ACPI_FAILURE(status)) {
576 			ACPI_EXCEPTION((AE_INFO, status,
577 					"while evaluating GPE method [%4.4s]",
578 					acpi_ut_get_node_name
579 					(local_gpe_event_info->dispatch.
580 					 method_node)));
581 		}
582 		break;
583 
584 	default:
585 
586 		return_VOID;	/* Should never happen */
587 	}
588 
589 	/* Defer enabling of GPE until all notify handlers are done */
590 
591 	status = acpi_os_execute(OSL_NOTIFY_HANDLER,
592 				 acpi_ev_asynch_enable_gpe,
593 				 local_gpe_event_info);
594 	if (ACPI_FAILURE(status)) {
595 		ACPI_FREE(local_gpe_event_info);
596 	}
597 	return_VOID;
598 }
599 
600 
601 /*******************************************************************************
602  *
603  * FUNCTION:    acpi_ev_asynch_enable_gpe
604  *
605  * PARAMETERS:  Context (gpe_event_info) - Info for this GPE
606  *              Callback from acpi_os_execute
607  *
608  * RETURN:      None
609  *
610  * DESCRIPTION: Asynchronous clear/enable for GPE. This allows the GPE to
611  *              complete (i.e., finish execution of Notify)
612  *
613  ******************************************************************************/
614 
615 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context)
616 {
617 	struct acpi_gpe_event_info *gpe_event_info = context;
618 
619 	(void)acpi_ev_finish_gpe(gpe_event_info);
620 
621 	ACPI_FREE(gpe_event_info);
622 	return;
623 }
624 
625 
626 /*******************************************************************************
627  *
628  * FUNCTION:    acpi_ev_finish_gpe
629  *
630  * PARAMETERS:  gpe_event_info      - Info for this GPE
631  *
632  * RETURN:      Status
633  *
634  * DESCRIPTION: Clear/Enable a GPE. Common code that is used after execution
635  *              of a GPE method or a synchronous or asynchronous GPE handler.
636  *
637  ******************************************************************************/
638 
639 acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info)
640 {
641 	acpi_status status;
642 
643 	if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
644 	    ACPI_GPE_LEVEL_TRIGGERED) {
645 		/*
646 		 * GPE is level-triggered, we clear the GPE status bit after
647 		 * handling the event.
648 		 */
649 		status = acpi_hw_clear_gpe(gpe_event_info);
650 		if (ACPI_FAILURE(status)) {
651 			return (status);
652 		}
653 	}
654 
655 	/*
656 	 * Enable this GPE, conditionally. This means that the GPE will
657 	 * only be physically enabled if the enable_for_run bit is set
658 	 * in the event_info.
659 	 */
660 	(void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_CONDITIONAL_ENABLE);
661 	return (AE_OK);
662 }
663 
664 
665 /*******************************************************************************
666  *
667  * FUNCTION:    acpi_ev_gpe_dispatch
668  *
669  * PARAMETERS:  gpe_device      - Device node. NULL for GPE0/GPE1
670  *              gpe_event_info  - Info for this GPE
671  *              gpe_number      - Number relative to the parent GPE block
672  *
673  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
674  *
675  * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
676  *              or method (e.g. _Lxx/_Exx) handler.
677  *
678  *              This function executes at interrupt level.
679  *
680  ******************************************************************************/
681 
682 u32
683 acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
684 		    struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
685 {
686 	acpi_status status;
687 	u32 return_value;
688 
689 	ACPI_FUNCTION_TRACE(ev_gpe_dispatch);
690 
691 	/* Invoke global event handler if present */
692 
693 	acpi_gpe_count++;
694 	if (acpi_gbl_global_event_handler) {
695 		acpi_gbl_global_event_handler(ACPI_EVENT_TYPE_GPE, gpe_device,
696 					      gpe_number,
697 					      acpi_gbl_global_event_handler_context);
698 	}
699 
700 	/*
701 	 * If edge-triggered, clear the GPE status bit now. Note that
702 	 * level-triggered events are cleared after the GPE is serviced.
703 	 */
704 	if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
705 	    ACPI_GPE_EDGE_TRIGGERED) {
706 		status = acpi_hw_clear_gpe(gpe_event_info);
707 		if (ACPI_FAILURE(status)) {
708 			ACPI_EXCEPTION((AE_INFO, status,
709 					"Unable to clear GPE%02X", gpe_number));
710 			return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
711 		}
712 	}
713 
714 	/*
715 	 * Always disable the GPE so that it does not keep firing before
716 	 * any asynchronous activity completes (either from the execution
717 	 * of a GPE method or an asynchronous GPE handler.)
718 	 *
719 	 * If there is no handler or method to run, just disable the
720 	 * GPE and leave it disabled permanently to prevent further such
721 	 * pointless events from firing.
722 	 */
723 	status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
724 	if (ACPI_FAILURE(status)) {
725 		ACPI_EXCEPTION((AE_INFO, status,
726 				"Unable to disable GPE%02X", gpe_number));
727 		return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
728 	}
729 
730 	/*
731 	 * Dispatch the GPE to either an installed handler or the control
732 	 * method associated with this GPE (_Lxx or _Exx). If a handler
733 	 * exists, we invoke it and do not attempt to run the method.
734 	 * If there is neither a handler nor a method, leave the GPE
735 	 * disabled.
736 	 */
737 	switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
738 	case ACPI_GPE_DISPATCH_HANDLER:
739 
740 		/* Invoke the installed handler (at interrupt level) */
741 
742 		return_value =
743 		    gpe_event_info->dispatch.handler->address(gpe_device,
744 							      gpe_number,
745 							      gpe_event_info->
746 							      dispatch.handler->
747 							      context);
748 
749 		/* If requested, clear (if level-triggered) and reenable the GPE */
750 
751 		if (return_value & ACPI_REENABLE_GPE) {
752 			(void)acpi_ev_finish_gpe(gpe_event_info);
753 		}
754 		break;
755 
756 	case ACPI_GPE_DISPATCH_METHOD:
757 	case ACPI_GPE_DISPATCH_NOTIFY:
758 		/*
759 		 * Execute the method associated with the GPE
760 		 * NOTE: Level-triggered GPEs are cleared after the method completes.
761 		 */
762 		status = acpi_os_execute(OSL_GPE_HANDLER,
763 					 acpi_ev_asynch_execute_gpe_method,
764 					 gpe_event_info);
765 		if (ACPI_FAILURE(status)) {
766 			ACPI_EXCEPTION((AE_INFO, status,
767 					"Unable to queue handler for GPE%02X - event disabled",
768 					gpe_number));
769 		}
770 		break;
771 
772 	default:
773 		/*
774 		 * No handler or method to run!
775 		 * 03/2010: This case should no longer be possible. We will not allow
776 		 * a GPE to be enabled if it has no handler or method.
777 		 */
778 		ACPI_ERROR((AE_INFO,
779 			    "No handler or method for GPE%02X, disabling event",
780 			    gpe_number));
781 
782 		break;
783 	}
784 
785 	return_UINT32(ACPI_INTERRUPT_HANDLED);
786 }
787 
788 #endif				/* !ACPI_REDUCED_HARDWARE */
789