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