Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: evgpe - General Purpose Event handling and dispatch | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
a8357b0c | 8 | * Copyright (C) 2000 - 2010, Intel Corp. |
1da177e4 LT |
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> | |
e2f7a777 LB |
45 | #include "accommon.h" |
46 | #include "acevents.h" | |
47 | #include "acnamesp.h" | |
1da177e4 LT |
48 | |
49 | #define _COMPONENT ACPI_EVENTS | |
4be44fcd | 50 | ACPI_MODULE_NAME("evgpe") |
1da177e4 | 51 | |
44f6c012 | 52 | /* Local prototypes */ |
4be44fcd | 53 | static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context); |
1da177e4 | 54 | |
1da177e4 LT |
55 | /******************************************************************************* |
56 | * | |
57 | * FUNCTION: acpi_ev_update_gpe_enable_masks | |
58 | * | |
59 | * PARAMETERS: gpe_event_info - GPE to update | |
1da177e4 LT |
60 | * |
61 | * RETURN: Status | |
62 | * | |
0f849d2c LM |
63 | * DESCRIPTION: Updates GPE register enable masks based upon whether there are |
64 | * references (either wake or run) to this GPE | |
1da177e4 LT |
65 | * |
66 | ******************************************************************************/ | |
67 | ||
68 | acpi_status | |
9630bdd9 | 69 | acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info) |
1da177e4 | 70 | { |
4be44fcd LB |
71 | struct acpi_gpe_register_info *gpe_register_info; |
72 | u8 register_bit; | |
1da177e4 | 73 | |
b229cf92 | 74 | ACPI_FUNCTION_TRACE(ev_update_gpe_enable_masks); |
1da177e4 LT |
75 | |
76 | gpe_register_info = gpe_event_info->register_info; | |
77 | if (!gpe_register_info) { | |
4be44fcd | 78 | return_ACPI_STATUS(AE_NOT_EXIST); |
1da177e4 | 79 | } |
d4913dc6 | 80 | |
69874165 AS |
81 | register_bit = (u8) |
82 | (1 << | |
83 | (gpe_event_info->gpe_number - gpe_register_info->base_gpe_number)); | |
1da177e4 | 84 | |
0f849d2c LM |
85 | /* Clear the wake/run bits up front */ |
86 | ||
9630bdd9 RW |
87 | ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit); |
88 | ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit); | |
1da177e4 | 89 | |
0f849d2c LM |
90 | /* Set the mask bits only if there are references to this GPE */ |
91 | ||
92 | if (gpe_event_info->runtime_count) { | |
4be44fcd | 93 | ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit); |
0f849d2c | 94 | } |
1da177e4 | 95 | |
0f849d2c | 96 | if (gpe_event_info->wakeup_count) { |
4be44fcd | 97 | ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit); |
0f849d2c | 98 | } |
1da177e4 | 99 | |
4be44fcd | 100 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
101 | } |
102 | ||
1da177e4 LT |
103 | /******************************************************************************* |
104 | * | |
105 | * FUNCTION: acpi_ev_enable_gpe | |
106 | * | |
107 | * PARAMETERS: gpe_event_info - GPE to enable | |
1da177e4 LT |
108 | * |
109 | * RETURN: Status | |
110 | * | |
0f849d2c LM |
111 | * DESCRIPTION: Hardware-enable a GPE. Always enables the GPE, regardless |
112 | * of type or number of references. | |
113 | * | |
114 | * Note: The GPE lock should be already acquired when this function is called. | |
1da177e4 LT |
115 | * |
116 | ******************************************************************************/ | |
117 | ||
cbbc0de7 | 118 | acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info) |
1da177e4 | 119 | { |
4be44fcd | 120 | acpi_status status; |
1da177e4 | 121 | |
0f849d2c | 122 | |
b229cf92 | 123 | ACPI_FUNCTION_TRACE(ev_enable_gpe); |
1da177e4 | 124 | |
0f849d2c LM |
125 | |
126 | /* | |
127 | * We will only allow a GPE to be enabled if it has either an | |
128 | * associated method (_Lxx/_Exx) or a handler. Otherwise, the | |
129 | * GPE will be immediately disabled by acpi_ev_gpe_dispatch the | |
130 | * first time it fires. | |
131 | */ | |
132 | if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)) { | |
133 | return_ACPI_STATUS(AE_NO_HANDLER); | |
134 | } | |
135 | ||
136 | /* Ensure the HW enable masks are current */ | |
1da177e4 | 137 | |
9630bdd9 | 138 | status = acpi_ev_update_gpe_enable_masks(gpe_event_info); |
0f849d2c | 139 | if (ACPI_FAILURE(status)) { |
4be44fcd | 140 | return_ACPI_STATUS(status); |
0f849d2c LM |
141 | } |
142 | ||
143 | /* Clear the GPE (of stale events) */ | |
1da177e4 | 144 | |
bf02bd25 | 145 | status = acpi_hw_clear_gpe(gpe_event_info); |
0f849d2c | 146 | if (ACPI_FAILURE(status)) { |
bf02bd25 | 147 | return_ACPI_STATUS(status); |
0f849d2c | 148 | } |
1da177e4 | 149 | |
bf02bd25 | 150 | /* Enable the requested GPE */ |
0f849d2c | 151 | |
bf02bd25 RW |
152 | status = acpi_hw_write_gpe_enable_reg(gpe_event_info); |
153 | return_ACPI_STATUS(status); | |
1da177e4 LT |
154 | } |
155 | ||
1da177e4 LT |
156 | /******************************************************************************* |
157 | * | |
158 | * FUNCTION: acpi_ev_disable_gpe | |
159 | * | |
160 | * PARAMETERS: gpe_event_info - GPE to disable | |
161 | * | |
162 | * RETURN: Status | |
163 | * | |
0f849d2c LM |
164 | * DESCRIPTION: Hardware-disable a GPE. Always disables the requested GPE, |
165 | * regardless of the type or number of references. | |
166 | * | |
167 | * Note: The GPE lock should be already acquired when this function is called. | |
1da177e4 LT |
168 | * |
169 | ******************************************************************************/ | |
170 | ||
4be44fcd | 171 | acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info) |
1da177e4 | 172 | { |
4be44fcd | 173 | acpi_status status; |
1da177e4 | 174 | |
b229cf92 | 175 | ACPI_FUNCTION_TRACE(ev_disable_gpe); |
1da177e4 | 176 | |
0f849d2c LM |
177 | |
178 | /* | |
179 | * Note: Always disable the GPE, even if we think that that it is already | |
180 | * disabled. It is possible that the AML or some other code has enabled | |
181 | * the GPE behind our back. | |
182 | */ | |
183 | ||
184 | /* Ensure the HW enable masks are current */ | |
1da177e4 | 185 | |
9630bdd9 | 186 | status = acpi_ev_update_gpe_enable_masks(gpe_event_info); |
0f849d2c | 187 | if (ACPI_FAILURE(status)) { |
4be44fcd | 188 | return_ACPI_STATUS(status); |
0f849d2c | 189 | } |
1da177e4 | 190 | |
e38e8a07 | 191 | /* |
0f849d2c LM |
192 | * Always H/W disable this GPE, even if we don't know the GPE type. |
193 | * Simply clear the enable bit for this particular GPE, but do not | |
194 | * write out the current GPE enable mask since this may inadvertently | |
195 | * enable GPEs too early. An example is a rogue GPE that has arrived | |
196 | * during ACPICA initialization - possibly because AML or other code | |
197 | * has enabled the GPE. | |
e38e8a07 BM |
198 | */ |
199 | status = acpi_hw_low_disable_gpe(gpe_event_info); | |
200 | return_ACPI_STATUS(status); | |
1da177e4 LT |
201 | } |
202 | ||
0f849d2c LM |
203 | |
204 | /******************************************************************************* | |
205 | * | |
206 | * FUNCTION: acpi_ev_low_get_gpe_info | |
207 | * | |
208 | * PARAMETERS: gpe_number - Raw GPE number | |
209 | * gpe_block - A GPE info block | |
210 | * | |
211 | * RETURN: A GPE event_info struct. NULL if not a valid GPE (The gpe_number | |
212 | * is not within the specified GPE block) | |
213 | * | |
214 | * DESCRIPTION: Returns the event_info struct associated with this GPE. This is | |
215 | * the low-level implementation of ev_get_gpe_event_info. | |
216 | * | |
217 | ******************************************************************************/ | |
218 | ||
219 | struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number, | |
220 | struct acpi_gpe_block_info | |
221 | *gpe_block) | |
222 | { | |
223 | u32 gpe_index; | |
224 | ||
225 | /* | |
226 | * Validate that the gpe_number is within the specified gpe_block. | |
227 | * (Two steps) | |
228 | */ | |
229 | if (!gpe_block || (gpe_number < gpe_block->block_base_number)) { | |
230 | return (NULL); | |
231 | } | |
232 | ||
233 | gpe_index = gpe_number - gpe_block->block_base_number; | |
234 | if (gpe_index >= gpe_block->gpe_count) { | |
235 | return (NULL); | |
236 | } | |
237 | ||
238 | return (&gpe_block->event_info[gpe_index]); | |
239 | } | |
240 | ||
241 | ||
1da177e4 LT |
242 | /******************************************************************************* |
243 | * | |
244 | * FUNCTION: acpi_ev_get_gpe_event_info | |
245 | * | |
9f15fc66 | 246 | * PARAMETERS: gpe_device - Device node. NULL for GPE0/GPE1 |
1da177e4 LT |
247 | * gpe_number - Raw GPE number |
248 | * | |
249 | * RETURN: A GPE event_info struct. NULL if not a valid GPE | |
250 | * | |
251 | * DESCRIPTION: Returns the event_info struct associated with this GPE. | |
252 | * Validates the gpe_block and the gpe_number | |
253 | * | |
254 | * Should be called only when the GPE lists are semaphore locked | |
255 | * and not subject to change. | |
256 | * | |
257 | ******************************************************************************/ | |
258 | ||
4be44fcd LB |
259 | struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device, |
260 | u32 gpe_number) | |
1da177e4 | 261 | { |
4be44fcd | 262 | union acpi_operand_object *obj_desc; |
0f849d2c | 263 | struct acpi_gpe_event_info *gpe_info; |
67a119f9 | 264 | u32 i; |
1da177e4 | 265 | |
4be44fcd | 266 | ACPI_FUNCTION_ENTRY(); |
1da177e4 LT |
267 | |
268 | /* A NULL gpe_block means use the FADT-defined GPE block(s) */ | |
269 | ||
270 | if (!gpe_device) { | |
52fc0b02 | 271 | |
1da177e4 LT |
272 | /* Examine GPE Block 0 and 1 (These blocks are permanent) */ |
273 | ||
274 | for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) { | |
0f849d2c LM |
275 | gpe_info = acpi_ev_low_get_gpe_info(gpe_number, |
276 | acpi_gbl_gpe_fadt_blocks | |
277 | [i]); | |
278 | if (gpe_info) { | |
279 | return (gpe_info); | |
1da177e4 LT |
280 | } |
281 | } | |
282 | ||
283 | /* The gpe_number was not in the range of either FADT GPE block */ | |
284 | ||
285 | return (NULL); | |
286 | } | |
287 | ||
288 | /* A Non-NULL gpe_device means this is a GPE Block Device */ | |
289 | ||
fd350943 LB |
290 | obj_desc = acpi_ns_get_attached_object((struct acpi_namespace_node *) |
291 | gpe_device); | |
4be44fcd | 292 | if (!obj_desc || !obj_desc->device.gpe_block) { |
1da177e4 LT |
293 | return (NULL); |
294 | } | |
295 | ||
0f849d2c LM |
296 | return (acpi_ev_low_get_gpe_info |
297 | (gpe_number, obj_desc->device.gpe_block)); | |
1da177e4 LT |
298 | } |
299 | ||
1da177e4 LT |
300 | /******************************************************************************* |
301 | * | |
302 | * FUNCTION: acpi_ev_gpe_detect | |
303 | * | |
304 | * PARAMETERS: gpe_xrupt_list - Interrupt block for this interrupt. | |
305 | * Can have multiple GPE blocks attached. | |
306 | * | |
307 | * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED | |
308 | * | |
9f15fc66 | 309 | * DESCRIPTION: Detect if any GP events have occurred. This function is |
1da177e4 LT |
310 | * executed at interrupt level. |
311 | * | |
312 | ******************************************************************************/ | |
313 | ||
4be44fcd | 314 | u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list) |
1da177e4 | 315 | { |
0897831b BM |
316 | acpi_status status; |
317 | struct acpi_gpe_block_info *gpe_block; | |
318 | struct acpi_gpe_register_info *gpe_register_info; | |
4be44fcd LB |
319 | u32 int_status = ACPI_INTERRUPT_NOT_HANDLED; |
320 | u8 enabled_status_byte; | |
4be44fcd LB |
321 | u32 status_reg; |
322 | u32 enable_reg; | |
b8e4d893 | 323 | acpi_cpu_flags flags; |
67a119f9 BM |
324 | u32 i; |
325 | u32 j; | |
4be44fcd | 326 | |
b229cf92 | 327 | ACPI_FUNCTION_NAME(ev_gpe_detect); |
1da177e4 LT |
328 | |
329 | /* Check for the case where there are no GPEs */ | |
330 | ||
331 | if (!gpe_xrupt_list) { | |
332 | return (int_status); | |
333 | } | |
334 | ||
967440e3 BM |
335 | /* |
336 | * We need to obtain the GPE lock for both the data structs and registers | |
9f15fc66 BM |
337 | * Note: Not necessary to obtain the hardware lock, since the GPE |
338 | * registers are owned by the gpe_lock. | |
967440e3 | 339 | */ |
4be44fcd | 340 | flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); |
4c90ece2 BM |
341 | |
342 | /* Examine all GPE blocks attached to this interrupt level */ | |
343 | ||
1da177e4 LT |
344 | gpe_block = gpe_xrupt_list->gpe_block_list_head; |
345 | while (gpe_block) { | |
346 | /* | |
9f15fc66 BM |
347 | * Read all of the 8-bit GPE status and enable registers in this GPE |
348 | * block, saving all of them. Find all currently active GP events. | |
1da177e4 LT |
349 | */ |
350 | for (i = 0; i < gpe_block->register_count; i++) { | |
52fc0b02 | 351 | |
1da177e4 LT |
352 | /* Get the next status/enable pair */ |
353 | ||
354 | gpe_register_info = &gpe_block->register_info[i]; | |
355 | ||
356 | /* Read the Status Register */ | |
357 | ||
4be44fcd | 358 | status = |
c6b5774c BM |
359 | acpi_hw_read(&status_reg, |
360 | &gpe_register_info->status_address); | |
4be44fcd | 361 | if (ACPI_FAILURE(status)) { |
1da177e4 LT |
362 | goto unlock_and_exit; |
363 | } | |
364 | ||
365 | /* Read the Enable Register */ | |
366 | ||
4be44fcd | 367 | status = |
c6b5774c BM |
368 | acpi_hw_read(&enable_reg, |
369 | &gpe_register_info->enable_address); | |
4be44fcd | 370 | if (ACPI_FAILURE(status)) { |
1da177e4 LT |
371 | goto unlock_and_exit; |
372 | } | |
373 | ||
4be44fcd LB |
374 | ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS, |
375 | "Read GPE Register at GPE%X: Status=%02X, Enable=%02X\n", | |
376 | gpe_register_info->base_gpe_number, | |
377 | status_reg, enable_reg)); | |
1da177e4 | 378 | |
44f6c012 | 379 | /* Check if there is anything active at all in this register */ |
1da177e4 LT |
380 | |
381 | enabled_status_byte = (u8) (status_reg & enable_reg); | |
382 | if (!enabled_status_byte) { | |
52fc0b02 | 383 | |
1da177e4 LT |
384 | /* No active GPEs in this register, move on */ |
385 | ||
386 | continue; | |
387 | } | |
388 | ||
389 | /* Now look at the individual GPEs in this byte register */ | |
390 | ||
391 | for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) { | |
52fc0b02 | 392 | |
1da177e4 LT |
393 | /* Examine one GPE bit */ |
394 | ||
69874165 | 395 | if (enabled_status_byte & (1 << j)) { |
1da177e4 LT |
396 | /* |
397 | * Found an active GPE. Dispatch the event to a handler | |
398 | * or method. | |
399 | */ | |
4be44fcd LB |
400 | int_status |= |
401 | acpi_ev_gpe_dispatch(&gpe_block-> | |
67a119f9 | 402 | event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number); |
1da177e4 LT |
403 | } |
404 | } | |
405 | } | |
406 | ||
407 | gpe_block = gpe_block->next; | |
408 | } | |
409 | ||
4be44fcd | 410 | unlock_and_exit: |
1da177e4 | 411 | |
4be44fcd | 412 | acpi_os_release_lock(acpi_gbl_gpe_lock, flags); |
1da177e4 LT |
413 | return (int_status); |
414 | } | |
415 | ||
1da177e4 LT |
416 | /******************************************************************************* |
417 | * | |
418 | * FUNCTION: acpi_ev_asynch_execute_gpe_method | |
419 | * | |
420 | * PARAMETERS: Context (gpe_event_info) - Info for this GPE | |
421 | * | |
422 | * RETURN: None | |
423 | * | |
4119532c BM |
424 | * DESCRIPTION: Perform the actual execution of a GPE control method. This |
425 | * function is called from an invocation of acpi_os_execute and | |
426 | * therefore does NOT execute at interrupt level - so that | |
1da177e4 LT |
427 | * the control method itself is not executed in the context of |
428 | * an interrupt handler. | |
429 | * | |
430 | ******************************************************************************/ | |
17bc54ee | 431 | static void acpi_ev_asynch_enable_gpe(void *context); |
1da177e4 | 432 | |
4be44fcd | 433 | static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context) |
1da177e4 | 434 | { |
4be44fcd | 435 | struct acpi_gpe_event_info *gpe_event_info = (void *)context; |
4be44fcd LB |
436 | acpi_status status; |
437 | struct acpi_gpe_event_info local_gpe_event_info; | |
4119532c | 438 | struct acpi_evaluate_info *info; |
1da177e4 | 439 | |
b229cf92 | 440 | ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method); |
1da177e4 | 441 | |
4be44fcd LB |
442 | status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); |
443 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
444 | return_VOID; |
445 | } | |
446 | ||
447 | /* Must revalidate the gpe_number/gpe_block */ | |
448 | ||
4be44fcd LB |
449 | if (!acpi_ev_valid_gpe_event(gpe_event_info)) { |
450 | status = acpi_ut_release_mutex(ACPI_MTX_EVENTS); | |
1da177e4 LT |
451 | return_VOID; |
452 | } | |
453 | ||
0f849d2c | 454 | /* Update the GPE register masks for return to enabled state */ |
1da177e4 | 455 | |
cbbc0de7 | 456 | (void)acpi_ev_update_gpe_enable_masks(gpe_event_info); |
1da177e4 LT |
457 | |
458 | /* | |
9f15fc66 BM |
459 | * Take a snapshot of the GPE info for this level - we copy the info to |
460 | * prevent a race condition with remove_handler/remove_block. | |
1da177e4 | 461 | */ |
4be44fcd LB |
462 | ACPI_MEMCPY(&local_gpe_event_info, gpe_event_info, |
463 | sizeof(struct acpi_gpe_event_info)); | |
1da177e4 | 464 | |
4be44fcd LB |
465 | status = acpi_ut_release_mutex(ACPI_MTX_EVENTS); |
466 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
467 | return_VOID; |
468 | } | |
469 | ||
470 | /* | |
9f15fc66 BM |
471 | * Must check for control method type dispatch one more time to avoid a |
472 | * race with ev_gpe_install_handler | |
1da177e4 | 473 | */ |
44f6c012 | 474 | if ((local_gpe_event_info.flags & ACPI_GPE_DISPATCH_MASK) == |
4be44fcd | 475 | ACPI_GPE_DISPATCH_METHOD) { |
1da177e4 | 476 | |
4119532c BM |
477 | /* Allocate the evaluation information block */ |
478 | ||
479 | info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); | |
480 | if (!info) { | |
481 | status = AE_NO_MEMORY; | |
482 | } else { | |
483 | /* | |
484 | * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the _Lxx/_Exx | |
485 | * control method that corresponds to this GPE | |
486 | */ | |
487 | info->prefix_node = | |
488 | local_gpe_event_info.dispatch.method_node; | |
4119532c BM |
489 | info->flags = ACPI_IGNORE_RETURN_VALUE; |
490 | ||
491 | status = acpi_ns_evaluate(info); | |
492 | ACPI_FREE(info); | |
493 | } | |
494 | ||
4be44fcd | 495 | if (ACPI_FAILURE(status)) { |
b8e4d893 | 496 | ACPI_EXCEPTION((AE_INFO, status, |
2e42005b | 497 | "while evaluating GPE method [%4.4s]", |
b8e4d893 BM |
498 | acpi_ut_get_node_name |
499 | (local_gpe_event_info.dispatch. | |
4c90ece2 | 500 | method_node))); |
1da177e4 LT |
501 | } |
502 | } | |
17bc54ee AS |
503 | /* Defer enabling of GPE until all notify handlers are done */ |
504 | acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_ev_asynch_enable_gpe, | |
505 | gpe_event_info); | |
506 | return_VOID; | |
507 | } | |
1da177e4 | 508 | |
17bc54ee AS |
509 | static void acpi_ev_asynch_enable_gpe(void *context) |
510 | { | |
511 | struct acpi_gpe_event_info *gpe_event_info = context; | |
512 | acpi_status status; | |
513 | if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) == | |
4be44fcd | 514 | ACPI_GPE_LEVEL_TRIGGERED) { |
1da177e4 | 515 | /* |
9f15fc66 BM |
516 | * GPE is level-triggered, we clear the GPE status bit after handling |
517 | * the event. | |
1da177e4 | 518 | */ |
17bc54ee | 519 | status = acpi_hw_clear_gpe(gpe_event_info); |
4be44fcd | 520 | if (ACPI_FAILURE(status)) { |
1da177e4 LT |
521 | return_VOID; |
522 | } | |
523 | } | |
524 | ||
525 | /* Enable this GPE */ | |
17bc54ee | 526 | (void)acpi_hw_write_gpe_enable_reg(gpe_event_info); |
1da177e4 LT |
527 | return_VOID; |
528 | } | |
529 | ||
1da177e4 LT |
530 | /******************************************************************************* |
531 | * | |
532 | * FUNCTION: acpi_ev_gpe_dispatch | |
533 | * | |
44f6c012 | 534 | * PARAMETERS: gpe_event_info - Info for this GPE |
1da177e4 LT |
535 | * gpe_number - Number relative to the parent GPE block |
536 | * | |
537 | * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED | |
538 | * | |
539 | * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC) | |
540 | * or method (e.g. _Lxx/_Exx) handler. | |
541 | * | |
542 | * This function executes at interrupt level. | |
543 | * | |
544 | ******************************************************************************/ | |
545 | ||
546 | u32 | |
4be44fcd | 547 | acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number) |
1da177e4 | 548 | { |
4be44fcd | 549 | acpi_status status; |
1da177e4 | 550 | |
b229cf92 | 551 | ACPI_FUNCTION_TRACE(ev_gpe_dispatch); |
1da177e4 | 552 | |
5229e87d | 553 | acpi_os_gpe_count(gpe_number); |
fdffb72d | 554 | |
1da177e4 | 555 | /* |
9f15fc66 | 556 | * If edge-triggered, clear the GPE status bit now. Note that |
1da177e4 LT |
557 | * level-triggered events are cleared after the GPE is serviced. |
558 | */ | |
44f6c012 | 559 | if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) == |
4be44fcd LB |
560 | ACPI_GPE_EDGE_TRIGGERED) { |
561 | status = acpi_hw_clear_gpe(gpe_event_info); | |
562 | if (ACPI_FAILURE(status)) { | |
b8e4d893 | 563 | ACPI_EXCEPTION((AE_INFO, status, |
f6a22b0b | 564 | "Unable to clear GPE[0x%2X]", |
b8e4d893 | 565 | gpe_number)); |
50eca3eb | 566 | return_UINT32(ACPI_INTERRUPT_NOT_HANDLED); |
1da177e4 LT |
567 | } |
568 | } | |
569 | ||
1da177e4 | 570 | /* |
c5a71569 BM |
571 | * Dispatch the GPE to either an installed handler, or the control method |
572 | * associated with this GPE (_Lxx or _Exx). If a handler exists, we invoke | |
573 | * it and do not attempt to run the method. If there is neither a handler | |
574 | * nor a method, we disable this GPE to prevent further such pointless | |
575 | * events from firing. | |
1da177e4 LT |
576 | */ |
577 | switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) { | |
578 | case ACPI_GPE_DISPATCH_HANDLER: | |
579 | ||
580 | /* | |
581 | * Invoke the installed handler (at interrupt level) | |
9f15fc66 BM |
582 | * Ignore return status for now. |
583 | * TBD: leave GPE disabled on error? | |
1da177e4 | 584 | */ |
4be44fcd LB |
585 | (void)gpe_event_info->dispatch.handler->address(gpe_event_info-> |
586 | dispatch. | |
587 | handler-> | |
588 | context); | |
1da177e4 LT |
589 | |
590 | /* It is now safe to clear level-triggered events. */ | |
591 | ||
44f6c012 | 592 | if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) == |
4be44fcd LB |
593 | ACPI_GPE_LEVEL_TRIGGERED) { |
594 | status = acpi_hw_clear_gpe(gpe_event_info); | |
595 | if (ACPI_FAILURE(status)) { | |
b8e4d893 | 596 | ACPI_EXCEPTION((AE_INFO, status, |
f6a22b0b | 597 | "Unable to clear GPE[0x%2X]", |
b8e4d893 | 598 | gpe_number)); |
50eca3eb | 599 | return_UINT32(ACPI_INTERRUPT_NOT_HANDLED); |
1da177e4 LT |
600 | } |
601 | } | |
602 | break; | |
603 | ||
604 | case ACPI_GPE_DISPATCH_METHOD: | |
605 | ||
606 | /* | |
c5a71569 BM |
607 | * Disable the GPE, so it doesn't keep firing before the method has a |
608 | * chance to run (it runs asynchronously with interrupts enabled). | |
1da177e4 | 609 | */ |
4be44fcd LB |
610 | status = acpi_ev_disable_gpe(gpe_event_info); |
611 | if (ACPI_FAILURE(status)) { | |
b8e4d893 | 612 | ACPI_EXCEPTION((AE_INFO, status, |
f6a22b0b | 613 | "Unable to disable GPE[0x%2X]", |
b8e4d893 | 614 | gpe_number)); |
50eca3eb | 615 | return_UINT32(ACPI_INTERRUPT_NOT_HANDLED); |
1da177e4 LT |
616 | } |
617 | ||
618 | /* | |
619 | * Execute the method associated with the GPE | |
620 | * NOTE: Level-triggered GPEs are cleared after the method completes. | |
621 | */ | |
958dd242 BM |
622 | status = acpi_os_execute(OSL_GPE_HANDLER, |
623 | acpi_ev_asynch_execute_gpe_method, | |
624 | gpe_event_info); | |
4be44fcd | 625 | if (ACPI_FAILURE(status)) { |
b8e4d893 | 626 | ACPI_EXCEPTION((AE_INFO, status, |
f6a22b0b | 627 | "Unable to queue handler for GPE[0x%2X] - event disabled", |
b8e4d893 | 628 | gpe_number)); |
1da177e4 LT |
629 | } |
630 | break; | |
631 | ||
632 | default: | |
633 | ||
0f849d2c LM |
634 | /* |
635 | * No handler or method to run! | |
636 | * 03/2010: This case should no longer be possible. We will not allow | |
637 | * a GPE to be enabled if it has no handler or method. | |
638 | */ | |
b8e4d893 | 639 | ACPI_ERROR((AE_INFO, |
f6a22b0b | 640 | "No handler or method for GPE[0x%2X], disabling event", |
b8e4d893 | 641 | gpe_number)); |
1da177e4 LT |
642 | |
643 | /* | |
0f849d2c LM |
644 | * Disable the GPE. The GPE will remain disabled a handler |
645 | * is installed or ACPICA is restarted. | |
1da177e4 | 646 | */ |
4be44fcd LB |
647 | status = acpi_ev_disable_gpe(gpe_event_info); |
648 | if (ACPI_FAILURE(status)) { | |
b8e4d893 | 649 | ACPI_EXCEPTION((AE_INFO, status, |
f6a22b0b | 650 | "Unable to disable GPE[0x%2X]", |
b8e4d893 | 651 | gpe_number)); |
50eca3eb | 652 | return_UINT32(ACPI_INTERRUPT_NOT_HANDLED); |
1da177e4 LT |
653 | } |
654 | break; | |
655 | } | |
656 | ||
50eca3eb | 657 | return_UINT32(ACPI_INTERRUPT_HANDLED); |
1da177e4 | 658 | } |