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