ia64/linux-2.6.18-xen.hg

view drivers/acpi/events/evgpe.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /******************************************************************************
2 *
3 * Module Name: evgpe - General Purpose Event handling and dispatch
4 *
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2006, R. Byron Moore
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 */
44 #include <acpi/acpi.h>
45 #include <acpi/acevents.h>
46 #include <acpi/acnamesp.h>
48 #define _COMPONENT ACPI_EVENTS
49 ACPI_MODULE_NAME("evgpe")
51 /* Local prototypes */
52 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
54 /*******************************************************************************
55 *
56 * FUNCTION: acpi_ev_set_gpe_type
57 *
58 * PARAMETERS: gpe_event_info - GPE to set
59 * Type - New type
60 *
61 * RETURN: Status
62 *
63 * DESCRIPTION: Sets the new type for the GPE (wake, run, or wake/run)
64 *
65 ******************************************************************************/
67 acpi_status
68 acpi_ev_set_gpe_type(struct acpi_gpe_event_info *gpe_event_info, u8 type)
69 {
70 acpi_status status;
72 ACPI_FUNCTION_TRACE(ev_set_gpe_type);
74 /* Validate type and update register enable masks */
76 switch (type) {
77 case ACPI_GPE_TYPE_WAKE:
78 case ACPI_GPE_TYPE_RUNTIME:
79 case ACPI_GPE_TYPE_WAKE_RUN:
80 break;
82 default:
83 return_ACPI_STATUS(AE_BAD_PARAMETER);
84 }
86 /* Disable the GPE if currently enabled */
88 status = acpi_ev_disable_gpe(gpe_event_info);
90 /* Type was validated above */
92 gpe_event_info->flags &= ~ACPI_GPE_TYPE_MASK; /* Clear type bits */
93 gpe_event_info->flags |= type; /* Insert type */
94 return_ACPI_STATUS(status);
95 }
97 /*******************************************************************************
98 *
99 * FUNCTION: acpi_ev_update_gpe_enable_masks
100 *
101 * PARAMETERS: gpe_event_info - GPE to update
102 * Type - What to do: ACPI_GPE_DISABLE or
103 * ACPI_GPE_ENABLE
104 *
105 * RETURN: Status
106 *
107 * DESCRIPTION: Updates GPE register enable masks based on the GPE type
108 *
109 ******************************************************************************/
111 acpi_status
112 acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
113 u8 type)
114 {
115 struct acpi_gpe_register_info *gpe_register_info;
116 u8 register_bit;
118 ACPI_FUNCTION_TRACE(ev_update_gpe_enable_masks);
120 gpe_register_info = gpe_event_info->register_info;
121 if (!gpe_register_info) {
122 return_ACPI_STATUS(AE_NOT_EXIST);
123 }
124 register_bit = gpe_event_info->register_bit;
126 /* 1) Disable case. Simply clear all enable bits */
128 if (type == ACPI_GPE_DISABLE) {
129 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
130 register_bit);
131 ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
132 return_ACPI_STATUS(AE_OK);
133 }
135 /* 2) Enable case. Set/Clear the appropriate enable bits */
137 switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
138 case ACPI_GPE_TYPE_WAKE:
139 ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
140 ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
141 break;
143 case ACPI_GPE_TYPE_RUNTIME:
144 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
145 register_bit);
146 ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
147 break;
149 case ACPI_GPE_TYPE_WAKE_RUN:
150 ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
151 ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
152 break;
154 default:
155 return_ACPI_STATUS(AE_BAD_PARAMETER);
156 }
158 return_ACPI_STATUS(AE_OK);
159 }
161 /*******************************************************************************
162 *
163 * FUNCTION: acpi_ev_enable_gpe
164 *
165 * PARAMETERS: gpe_event_info - GPE to enable
166 * write_to_hardware - Enable now, or just mark data structs
167 * (WAKE GPEs should be deferred)
168 *
169 * RETURN: Status
170 *
171 * DESCRIPTION: Enable a GPE based on the GPE type
172 *
173 ******************************************************************************/
175 acpi_status
176 acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info,
177 u8 write_to_hardware)
178 {
179 acpi_status status;
181 ACPI_FUNCTION_TRACE(ev_enable_gpe);
183 /* Make sure HW enable masks are updated */
185 status =
186 acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_ENABLE);
187 if (ACPI_FAILURE(status)) {
188 return_ACPI_STATUS(status);
189 }
191 /* Mark wake-enabled or HW enable, or both */
193 switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
194 case ACPI_GPE_TYPE_WAKE:
196 ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
197 break;
199 case ACPI_GPE_TYPE_WAKE_RUN:
201 ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
203 /*lint -fallthrough */
205 case ACPI_GPE_TYPE_RUNTIME:
207 ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED);
209 if (write_to_hardware) {
211 /* Clear the GPE (of stale events), then enable it */
213 status = acpi_hw_clear_gpe(gpe_event_info);
214 if (ACPI_FAILURE(status)) {
215 return_ACPI_STATUS(status);
216 }
218 /* Enable the requested runtime GPE */
220 status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
221 }
222 break;
224 default:
225 return_ACPI_STATUS(AE_BAD_PARAMETER);
226 }
228 return_ACPI_STATUS(AE_OK);
229 }
231 /*******************************************************************************
232 *
233 * FUNCTION: acpi_ev_disable_gpe
234 *
235 * PARAMETERS: gpe_event_info - GPE to disable
236 *
237 * RETURN: Status
238 *
239 * DESCRIPTION: Disable a GPE based on the GPE type
240 *
241 ******************************************************************************/
243 acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
244 {
245 acpi_status status;
247 ACPI_FUNCTION_TRACE(ev_disable_gpe);
249 if (!(gpe_event_info->flags & ACPI_GPE_ENABLE_MASK)) {
250 return_ACPI_STATUS(AE_OK);
251 }
253 /* Make sure HW enable masks are updated */
255 status =
256 acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_DISABLE);
257 if (ACPI_FAILURE(status)) {
258 return_ACPI_STATUS(status);
259 }
261 /* Mark wake-disabled or HW disable, or both */
263 switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
264 case ACPI_GPE_TYPE_WAKE:
265 ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
266 break;
268 case ACPI_GPE_TYPE_WAKE_RUN:
269 ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
271 /*lint -fallthrough */
273 case ACPI_GPE_TYPE_RUNTIME:
275 /* Disable the requested runtime GPE */
277 ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED);
278 status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
279 break;
281 default:
282 return_ACPI_STATUS(AE_BAD_PARAMETER);
283 }
285 return_ACPI_STATUS(AE_OK);
286 }
288 /*******************************************************************************
289 *
290 * FUNCTION: acpi_ev_get_gpe_event_info
291 *
292 * PARAMETERS: gpe_device - Device node. NULL for GPE0/GPE1
293 * gpe_number - Raw GPE number
294 *
295 * RETURN: A GPE event_info struct. NULL if not a valid GPE
296 *
297 * DESCRIPTION: Returns the event_info struct associated with this GPE.
298 * Validates the gpe_block and the gpe_number
299 *
300 * Should be called only when the GPE lists are semaphore locked
301 * and not subject to change.
302 *
303 ******************************************************************************/
305 struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
306 u32 gpe_number)
307 {
308 union acpi_operand_object *obj_desc;
309 struct acpi_gpe_block_info *gpe_block;
310 acpi_native_uint i;
312 ACPI_FUNCTION_ENTRY();
314 /* A NULL gpe_block means use the FADT-defined GPE block(s) */
316 if (!gpe_device) {
318 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
320 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) {
321 gpe_block = acpi_gbl_gpe_fadt_blocks[i];
322 if (gpe_block) {
323 if ((gpe_number >= gpe_block->block_base_number)
324 && (gpe_number <
325 gpe_block->block_base_number +
326 (gpe_block->register_count * 8))) {
327 return (&gpe_block->
328 event_info[gpe_number -
329 gpe_block->
330 block_base_number]);
331 }
332 }
333 }
335 /* The gpe_number was not in the range of either FADT GPE block */
337 return (NULL);
338 }
340 /* A Non-NULL gpe_device means this is a GPE Block Device */
342 obj_desc =
343 acpi_ns_get_attached_object((struct acpi_namespace_node *)
344 gpe_device);
345 if (!obj_desc || !obj_desc->device.gpe_block) {
346 return (NULL);
347 }
349 gpe_block = obj_desc->device.gpe_block;
351 if ((gpe_number >= gpe_block->block_base_number) &&
352 (gpe_number <
353 gpe_block->block_base_number + (gpe_block->register_count * 8))) {
354 return (&gpe_block->
355 event_info[gpe_number - gpe_block->block_base_number]);
356 }
358 return (NULL);
359 }
361 /*******************************************************************************
362 *
363 * FUNCTION: acpi_ev_gpe_detect
364 *
365 * PARAMETERS: gpe_xrupt_list - Interrupt block for this interrupt.
366 * Can have multiple GPE blocks attached.
367 *
368 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
369 *
370 * DESCRIPTION: Detect if any GP events have occurred. This function is
371 * executed at interrupt level.
372 *
373 ******************************************************************************/
375 u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
376 {
377 acpi_status status;
378 struct acpi_gpe_block_info *gpe_block;
379 struct acpi_gpe_register_info *gpe_register_info;
380 u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
381 u8 enabled_status_byte;
382 u32 status_reg;
383 u32 enable_reg;
384 acpi_cpu_flags flags;
385 acpi_native_uint i;
386 acpi_native_uint j;
388 ACPI_FUNCTION_NAME(ev_gpe_detect);
390 /* Check for the case where there are no GPEs */
392 if (!gpe_xrupt_list) {
393 return (int_status);
394 }
396 /*
397 * We need to obtain the GPE lock for both the data structs and registers
398 * Note: Not necessary to obtain the hardware lock, since the GPE registers
399 * are owned by the gpe_lock.
400 */
401 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
403 /* Examine all GPE blocks attached to this interrupt level */
405 gpe_block = gpe_xrupt_list->gpe_block_list_head;
406 while (gpe_block) {
407 /*
408 * Read all of the 8-bit GPE status and enable registers
409 * in this GPE block, saving all of them.
410 * Find all currently active GP events.
411 */
412 for (i = 0; i < gpe_block->register_count; i++) {
414 /* Get the next status/enable pair */
416 gpe_register_info = &gpe_block->register_info[i];
418 /* Read the Status Register */
420 status =
421 acpi_hw_low_level_read(ACPI_GPE_REGISTER_WIDTH,
422 &status_reg,
423 &gpe_register_info->
424 status_address);
425 if (ACPI_FAILURE(status)) {
426 goto unlock_and_exit;
427 }
429 /* Read the Enable Register */
431 status =
432 acpi_hw_low_level_read(ACPI_GPE_REGISTER_WIDTH,
433 &enable_reg,
434 &gpe_register_info->
435 enable_address);
436 if (ACPI_FAILURE(status)) {
437 goto unlock_and_exit;
438 }
440 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
441 "Read GPE Register at GPE%X: Status=%02X, Enable=%02X\n",
442 gpe_register_info->base_gpe_number,
443 status_reg, enable_reg));
445 /* Check if there is anything active at all in this register */
447 enabled_status_byte = (u8) (status_reg & enable_reg);
448 if (!enabled_status_byte) {
450 /* No active GPEs in this register, move on */
452 continue;
453 }
455 /* Now look at the individual GPEs in this byte register */
457 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
459 /* Examine one GPE bit */
461 if (enabled_status_byte &
462 acpi_gbl_decode_to8bit[j]) {
463 /*
464 * Found an active GPE. Dispatch the event to a handler
465 * or method.
466 */
467 int_status |=
468 acpi_ev_gpe_dispatch(&gpe_block->
469 event_info[(i *
470 ACPI_GPE_REGISTER_WIDTH)
471 +
472 j],
473 (u32) j +
474 gpe_register_info->
475 base_gpe_number);
476 }
477 }
478 }
480 gpe_block = gpe_block->next;
481 }
483 unlock_and_exit:
485 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
486 return (int_status);
487 }
489 /*******************************************************************************
490 *
491 * FUNCTION: acpi_ev_asynch_execute_gpe_method
492 *
493 * PARAMETERS: Context (gpe_event_info) - Info for this GPE
494 *
495 * RETURN: None
496 *
497 * DESCRIPTION: Perform the actual execution of a GPE control method. This
498 * function is called from an invocation of acpi_os_execute and
499 * therefore does NOT execute at interrupt level - so that
500 * the control method itself is not executed in the context of
501 * an interrupt handler.
502 *
503 ******************************************************************************/
505 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
506 {
507 struct acpi_gpe_event_info *gpe_event_info = (void *)context;
508 acpi_status status;
509 struct acpi_gpe_event_info local_gpe_event_info;
510 struct acpi_evaluate_info *info;
512 ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method);
514 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
515 if (ACPI_FAILURE(status)) {
516 return_VOID;
517 }
519 /* Must revalidate the gpe_number/gpe_block */
521 if (!acpi_ev_valid_gpe_event(gpe_event_info)) {
522 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
523 return_VOID;
524 }
526 /* Set the GPE flags for return to enabled state */
528 (void)acpi_ev_enable_gpe(gpe_event_info, FALSE);
530 /*
531 * Take a snapshot of the GPE info for this level - we copy the
532 * info to prevent a race condition with remove_handler/remove_block.
533 */
534 ACPI_MEMCPY(&local_gpe_event_info, gpe_event_info,
535 sizeof(struct acpi_gpe_event_info));
537 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
538 if (ACPI_FAILURE(status)) {
539 return_VOID;
540 }
542 /*
543 * Must check for control method type dispatch one more
544 * time to avoid race with ev_gpe_install_handler
545 */
546 if ((local_gpe_event_info.flags & ACPI_GPE_DISPATCH_MASK) ==
547 ACPI_GPE_DISPATCH_METHOD) {
549 /* Allocate the evaluation information block */
551 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
552 if (!info) {
553 status = AE_NO_MEMORY;
554 } else {
555 /*
556 * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the _Lxx/_Exx
557 * control method that corresponds to this GPE
558 */
559 info->prefix_node =
560 local_gpe_event_info.dispatch.method_node;
561 info->parameters =
562 ACPI_CAST_PTR(union acpi_operand_object *,
563 gpe_event_info);
564 info->parameter_type = ACPI_PARAM_GPE;
565 info->flags = ACPI_IGNORE_RETURN_VALUE;
567 status = acpi_ns_evaluate(info);
568 ACPI_FREE(info);
569 }
571 if (ACPI_FAILURE(status)) {
572 ACPI_EXCEPTION((AE_INFO, status,
573 "While evaluating GPE method [%4.4s]",
574 acpi_ut_get_node_name
575 (local_gpe_event_info.dispatch.
576 method_node)));
577 }
578 }
580 if ((local_gpe_event_info.flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
581 ACPI_GPE_LEVEL_TRIGGERED) {
582 /*
583 * GPE is level-triggered, we clear the GPE status bit after
584 * handling the event.
585 */
586 status = acpi_hw_clear_gpe(&local_gpe_event_info);
587 if (ACPI_FAILURE(status)) {
588 return_VOID;
589 }
590 }
592 /* Enable this GPE */
594 (void)acpi_hw_write_gpe_enable_reg(&local_gpe_event_info);
595 return_VOID;
596 }
598 /*******************************************************************************
599 *
600 * FUNCTION: acpi_ev_gpe_dispatch
601 *
602 * PARAMETERS: gpe_event_info - Info for this GPE
603 * gpe_number - Number relative to the parent GPE block
604 *
605 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
606 *
607 * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
608 * or method (e.g. _Lxx/_Exx) handler.
609 *
610 * This function executes at interrupt level.
611 *
612 ******************************************************************************/
614 u32
615 acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
616 {
617 acpi_status status;
619 ACPI_FUNCTION_TRACE(ev_gpe_dispatch);
621 /*
622 * If edge-triggered, clear the GPE status bit now. Note that
623 * level-triggered events are cleared after the GPE is serviced.
624 */
625 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
626 ACPI_GPE_EDGE_TRIGGERED) {
627 status = acpi_hw_clear_gpe(gpe_event_info);
628 if (ACPI_FAILURE(status)) {
629 ACPI_EXCEPTION((AE_INFO, status,
630 "Unable to clear GPE[%2X]",
631 gpe_number));
632 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
633 }
634 }
636 /* Save current system state */
638 if (acpi_gbl_system_awake_and_running) {
639 ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_SYSTEM_RUNNING);
640 } else {
641 ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_SYSTEM_RUNNING);
642 }
644 /*
645 * Dispatch the GPE to either an installed handler, or the control
646 * method associated with this GPE (_Lxx or _Exx).
647 * If a handler exists, we invoke it and do not attempt to run the method.
648 * If there is neither a handler nor a method, we disable the level to
649 * prevent further events from coming in here.
650 */
651 switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
652 case ACPI_GPE_DISPATCH_HANDLER:
654 /*
655 * Invoke the installed handler (at interrupt level)
656 * Ignore return status for now. TBD: leave GPE disabled on error?
657 */
658 (void)gpe_event_info->dispatch.handler->address(gpe_event_info->
659 dispatch.
660 handler->
661 context);
663 /* It is now safe to clear level-triggered events. */
665 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
666 ACPI_GPE_LEVEL_TRIGGERED) {
667 status = acpi_hw_clear_gpe(gpe_event_info);
668 if (ACPI_FAILURE(status)) {
669 ACPI_EXCEPTION((AE_INFO, status,
670 "Unable to clear GPE[%2X]",
671 gpe_number));
672 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
673 }
674 }
675 break;
677 case ACPI_GPE_DISPATCH_METHOD:
679 /*
680 * Disable GPE, so it doesn't keep firing before the method has a
681 * chance to run.
682 */
683 status = acpi_ev_disable_gpe(gpe_event_info);
684 if (ACPI_FAILURE(status)) {
685 ACPI_EXCEPTION((AE_INFO, status,
686 "Unable to disable GPE[%2X]",
687 gpe_number));
688 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
689 }
691 /*
692 * Execute the method associated with the GPE
693 * NOTE: Level-triggered GPEs are cleared after the method completes.
694 */
695 status = acpi_os_execute(OSL_GPE_HANDLER,
696 acpi_ev_asynch_execute_gpe_method,
697 gpe_event_info);
698 if (ACPI_FAILURE(status)) {
699 ACPI_EXCEPTION((AE_INFO, status,
700 "Unable to queue handler for GPE[%2X] - event disabled",
701 gpe_number));
702 }
703 break;
705 default:
707 /* No handler or method to run! */
709 ACPI_ERROR((AE_INFO,
710 "No handler or method for GPE[%2X], disabling event",
711 gpe_number));
713 /*
714 * Disable the GPE. The GPE will remain disabled until the ACPI
715 * Core Subsystem is restarted, or a handler is installed.
716 */
717 status = acpi_ev_disable_gpe(gpe_event_info);
718 if (ACPI_FAILURE(status)) {
719 ACPI_EXCEPTION((AE_INFO, status,
720 "Unable to disable GPE[%2X]",
721 gpe_number));
722 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
723 }
724 break;
725 }
727 return_UINT32(ACPI_INTERRUPT_HANDLED);
728 }
730 #ifdef ACPI_GPE_NOTIFY_CHECK
731 /*******************************************************************************
732 * TBD: NOT USED, PROTOTYPE ONLY AND WILL PROBABLY BE REMOVED
733 *
734 * FUNCTION: acpi_ev_check_for_wake_only_gpe
735 *
736 * PARAMETERS: gpe_event_info - info for this GPE
737 *
738 * RETURN: Status
739 *
740 * DESCRIPTION: Determine if a a GPE is "wake-only".
741 *
742 * Called from Notify() code in interpreter when a "DeviceWake"
743 * Notify comes in.
744 *
745 ******************************************************************************/
747 acpi_status
748 acpi_ev_check_for_wake_only_gpe(struct acpi_gpe_event_info *gpe_event_info)
749 {
750 acpi_status status;
752 ACPI_FUNCTION_TRACE(ev_check_for_wake_only_gpe);
754 if ((gpe_event_info) && /* Only >0 for _Lxx/_Exx */
755 ((gpe_event_info->flags & ACPI_GPE_SYSTEM_MASK) == ACPI_GPE_SYSTEM_RUNNING)) { /* System state at GPE time */
756 /* This must be a wake-only GPE, disable it */
758 status = acpi_ev_disable_gpe(gpe_event_info);
760 /* Set GPE to wake-only. Do not change wake disabled/enabled status */
762 acpi_ev_set_gpe_type(gpe_event_info, ACPI_GPE_TYPE_WAKE);
764 ACPI_INFO((AE_INFO,
765 "GPE %p was updated from wake/run to wake-only",
766 gpe_event_info));
768 /* This was a wake-only GPE */
770 return_ACPI_STATUS(AE_WAKE_ONLY_GPE);
771 }
773 return_ACPI_STATUS(AE_OK);
774 }
775 #endif