blob: 48f70013b488c7cdbb956b6ab316afe1c8396f03 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
2 *
3 * Module Name: evgpe - General Purpose Event handling and dispatch
4 *
5 *****************************************************************************/
6
7/*
Bob Moorefbb7a2d2014-02-08 09:42:25 +08008 * Copyright (C) 2000 - 2014, Intel Corp.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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>
Len Browne2f7a772009-01-09 00:30:03 -050045#include "accommon.h"
46#include "acevents.h"
47#include "acnamesp.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49#define _COMPONENT ACPI_EVENTS
Len Brown4be44fc2005-08-05 00:44:28 -040050ACPI_MODULE_NAME("evgpe")
Bob Moore33620c52012-02-14 18:14:27 +080051#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
Robert Moore44f6c012005-04-18 22:49:35 -040052/* Local prototypes */
Len Brown4be44fc2005-08-05 00:44:28 -040053static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Lin Ming5a284cd2010-12-13 13:39:07 +080055static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context);
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057/*******************************************************************************
58 *
Rafael J. Wysockia44061a2010-07-01 10:11:45 +080059 * FUNCTION: acpi_ev_update_gpe_enable_mask
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 *
61 * PARAMETERS: gpe_event_info - GPE to update
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 *
63 * RETURN: Status
64 *
Rafael J. Wysockia44061a2010-07-01 10:11:45 +080065 * DESCRIPTION: Updates GPE register enable mask based upon whether there are
66 * runtime references to this GPE
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 *
68 ******************************************************************************/
69
70acpi_status
Rafael J. Wysockia44061a2010-07-01 10:11:45 +080071acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
Len Brown4be44fc2005-08-05 00:44:28 -040073 struct acpi_gpe_register_info *gpe_register_info;
Rafael J. Wysockie4e9a732010-06-08 10:48:26 +020074 u32 register_bit;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Rafael J. Wysockia44061a2010-07-01 10:11:45 +080076 ACPI_FUNCTION_TRACE(ev_update_gpe_enable_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78 gpe_register_info = gpe_event_info->register_info;
79 if (!gpe_register_info) {
Len Brown4be44fc2005-08-05 00:44:28 -040080 return_ACPI_STATUS(AE_NOT_EXIST);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 }
Bob Moored4913dc2009-03-06 10:05:18 +080082
Feng Tang1d94e1e2012-08-17 11:10:02 +080083 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Rafael J. Wysockia44061a2010-07-01 10:11:45 +080085 /* Clear the run bit up front */
Lin Ming0f849d22010-04-06 14:52:37 +080086
Rafael J. Wysocki9630bdd2010-02-17 23:41:07 +010087 ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Rafael J. Wysockia44061a2010-07-01 10:11:45 +080089 /* Set the mask bit only if there are references to this GPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Lin Ming0f849d22010-04-06 14:52:37 +080091 if (gpe_event_info->runtime_count) {
Lv Zheng1f86e8c2012-10-31 02:25:45 +000092 ACPI_SET_BIT(gpe_register_info->enable_for_run,
93 (u8)register_bit);
Lin Ming0f849d22010-04-06 14:52:37 +080094 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Len Brown4be44fc2005-08-05 00:44:28 -040096 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097}
98
Rafael J. Wysocki3bd741b2010-07-01 11:01:12 +080099/*******************************************************************************
100 *
101 * FUNCTION: acpi_ev_enable_gpe
102 *
103 * PARAMETERS: gpe_event_info - GPE to enable
104 *
105 * RETURN: Status
106 *
Lin Mingda503372010-12-13 13:39:37 +0800107 * DESCRIPTION: Clear a GPE of stale events and enable it.
Rafael J. Wysocki3bd741b2010-07-01 11:01:12 +0800108 *
109 ******************************************************************************/
Lv Zheng1f86e8c2012-10-31 02:25:45 +0000110acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
Rafael J. Wysocki3bd741b2010-07-01 11:01:12 +0800111{
112 acpi_status status;
113
114 ACPI_FUNCTION_TRACE(ev_enable_gpe);
115
116 /*
Lin Mingbba63a22010-12-13 13:39:17 +0800117 * We will only allow a GPE to be enabled if it has either an associated
118 * method (_Lxx/_Exx) or a handler, or is using the implicit notify
119 * feature. Otherwise, the GPE will be immediately disabled by
120 * acpi_ev_gpe_dispatch the first time it fires.
Rafael J. Wysocki3bd741b2010-07-01 11:01:12 +0800121 */
Lin Mingbba63a22010-12-13 13:39:17 +0800122 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
123 ACPI_GPE_DISPATCH_NONE) {
Rafael J. Wysocki3bd741b2010-07-01 11:01:12 +0800124 return_ACPI_STATUS(AE_NO_HANDLER);
125 }
126
127 /* Clear the GPE (of stale events) */
128 status = acpi_hw_clear_gpe(gpe_event_info);
129 if (ACPI_FAILURE(status)) {
130 return_ACPI_STATUS(status);
131 }
132
133 /* Enable the requested GPE */
Rafael J. Wysocki3bd741b2010-07-01 11:01:12 +0800134
Lv Zheng1f86e8c2012-10-31 02:25:45 +0000135 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
Rafael J. Wysocki3bd741b2010-07-01 11:01:12 +0800136 return_ACPI_STATUS(status);
137}
138
Lin Ming0f849d22010-04-06 14:52:37 +0800139
140/*******************************************************************************
141 *
Lin Ming3a378982010-12-13 13:36:15 +0800142 * FUNCTION: acpi_ev_add_gpe_reference
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200143 *
Lin Mingda503372010-12-13 13:39:37 +0800144 * PARAMETERS: gpe_event_info - Add a reference to this GPE
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200145 *
146 * RETURN: Status
147 *
148 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
149 * hardware-enabled.
150 *
151 ******************************************************************************/
152
Lv Zheng1f86e8c2012-10-31 02:25:45 +0000153acpi_status
154acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200155{
156 acpi_status status = AE_OK;
157
Lin Ming3a378982010-12-13 13:36:15 +0800158 ACPI_FUNCTION_TRACE(ev_add_gpe_reference);
159
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200160 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) {
Lin Mingda503372010-12-13 13:39:37 +0800166
167 /* Enable on first reference */
168
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200169 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 *
Lin Ming3a378982010-12-13 13:36:15 +0800184 * FUNCTION: acpi_ev_remove_gpe_reference
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200185 *
Lin Mingda503372010-12-13 13:39:37 +0800186 * PARAMETERS: gpe_event_info - Remove a reference to this GPE
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200187 *
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
Lv Zheng1f86e8c2012-10-31 02:25:45 +0000195acpi_status
196acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200197{
198 acpi_status status = AE_OK;
199
Lin Ming3a378982010-12-13 13:36:15 +0800200 ACPI_FUNCTION_TRACE(ev_remove_gpe_reference);
201
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200202 if (!gpe_event_info->runtime_count) {
203 return_ACPI_STATUS(AE_LIMIT);
204 }
205
206 gpe_event_info->runtime_count--;
207 if (!gpe_event_info->runtime_count) {
Lin Mingda503372010-12-13 13:39:37 +0800208
209 /* Disable on last reference */
210
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200211 status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
212 if (ACPI_SUCCESS(status)) {
Lv Zheng1f86e8c2012-10-31 02:25:45 +0000213 status =
214 acpi_hw_low_set_gpe(gpe_event_info,
Rafael J. Wysocki28f4f8a2010-08-03 23:55:14 +0200215 ACPI_GPE_DISABLE);
216 }
217
218 if (ACPI_FAILURE(status)) {
219 gpe_event_info->runtime_count++;
220 }
221 }
222
223 return_ACPI_STATUS(status);
224}
225
226/*******************************************************************************
227 *
Lin Ming0f849d22010-04-06 14:52:37 +0800228 * FUNCTION: acpi_ev_low_get_gpe_info
229 *
230 * PARAMETERS: gpe_number - Raw GPE number
231 * gpe_block - A GPE info block
232 *
233 * RETURN: A GPE event_info struct. NULL if not a valid GPE (The gpe_number
234 * is not within the specified GPE block)
235 *
236 * DESCRIPTION: Returns the event_info struct associated with this GPE. This is
237 * the low-level implementation of ev_get_gpe_event_info.
238 *
239 ******************************************************************************/
240
241struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number,
242 struct acpi_gpe_block_info
243 *gpe_block)
244{
245 u32 gpe_index;
246
247 /*
248 * Validate that the gpe_number is within the specified gpe_block.
249 * (Two steps)
250 */
251 if (!gpe_block || (gpe_number < gpe_block->block_base_number)) {
252 return (NULL);
253 }
254
255 gpe_index = gpe_number - gpe_block->block_base_number;
256 if (gpe_index >= gpe_block->gpe_count) {
257 return (NULL);
258 }
259
260 return (&gpe_block->event_info[gpe_index]);
261}
262
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264/*******************************************************************************
265 *
266 * FUNCTION: acpi_ev_get_gpe_event_info
267 *
Bob Moore9f15fc62008-11-12 16:01:56 +0800268 * PARAMETERS: gpe_device - Device node. NULL for GPE0/GPE1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 * gpe_number - Raw GPE number
270 *
271 * RETURN: A GPE event_info struct. NULL if not a valid GPE
272 *
273 * DESCRIPTION: Returns the event_info struct associated with this GPE.
274 * Validates the gpe_block and the gpe_number
275 *
276 * Should be called only when the GPE lists are semaphore locked
277 * and not subject to change.
278 *
279 ******************************************************************************/
280
Len Brown4be44fc2005-08-05 00:44:28 -0400281struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
282 u32 gpe_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
Len Brown4be44fc2005-08-05 00:44:28 -0400284 union acpi_operand_object *obj_desc;
Lin Ming0f849d22010-04-06 14:52:37 +0800285 struct acpi_gpe_event_info *gpe_info;
Bob Moore67a119f2008-06-10 13:42:13 +0800286 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Len Brown4be44fc2005-08-05 00:44:28 -0400288 ACPI_FUNCTION_ENTRY();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Bob Moore186c3072010-04-27 11:32:28 +0800290 /* A NULL gpe_device means use the FADT-defined GPE block(s) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 if (!gpe_device) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
295
296 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) {
Lin Ming0f849d22010-04-06 14:52:37 +0800297 gpe_info = acpi_ev_low_get_gpe_info(gpe_number,
298 acpi_gbl_gpe_fadt_blocks
299 [i]);
300 if (gpe_info) {
301 return (gpe_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 }
303 }
304
305 /* The gpe_number was not in the range of either FADT GPE block */
306
307 return (NULL);
308 }
309
310 /* A Non-NULL gpe_device means this is a GPE Block Device */
311
Lv Zheng1f86e8c2012-10-31 02:25:45 +0000312 obj_desc =
313 acpi_ns_get_attached_object((struct acpi_namespace_node *)
Len Brownfd350942007-05-09 23:34:35 -0400314 gpe_device);
Len Brown4be44fc2005-08-05 00:44:28 -0400315 if (!obj_desc || !obj_desc->device.gpe_block) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 return (NULL);
317 }
318
Lin Ming0f849d22010-04-06 14:52:37 +0800319 return (acpi_ev_low_get_gpe_info
320 (gpe_number, obj_desc->device.gpe_block));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321}
322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323/*******************************************************************************
324 *
325 * FUNCTION: acpi_ev_gpe_detect
326 *
327 * PARAMETERS: gpe_xrupt_list - Interrupt block for this interrupt.
328 * Can have multiple GPE blocks attached.
329 *
330 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
331 *
Bob Moore9f15fc62008-11-12 16:01:56 +0800332 * DESCRIPTION: Detect if any GP events have occurred. This function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 * executed at interrupt level.
334 *
335 ******************************************************************************/
336
Len Brown4be44fc2005-08-05 00:44:28 -0400337u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
Len Brown4be44fc2005-08-05 00:44:28 -0400339 acpi_status status;
340 struct acpi_gpe_block_info *gpe_block;
Bob Moore08978312005-10-21 00:00:00 -0400341 struct acpi_gpe_register_info *gpe_register_info;
342 u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
343 u8 enabled_status_byte;
344 u32 status_reg;
345 u32 enable_reg;
Bob Mooreb8e4d892006-01-27 16:43:00 -0500346 acpi_cpu_flags flags;
Bob Moore67a119f2008-06-10 13:42:13 +0800347 u32 i;
348 u32 j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Bob Mooreb229cf92006-04-21 17:15:00 -0400350 ACPI_FUNCTION_NAME(ev_gpe_detect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 /* Check for the case where there are no GPEs */
353
354 if (!gpe_xrupt_list) {
355 return (int_status);
356 }
357
Bob Moore967440e32006-06-23 17:04:00 -0400358 /*
359 * We need to obtain the GPE lock for both the data structs and registers
Bob Moore9f15fc62008-11-12 16:01:56 +0800360 * Note: Not necessary to obtain the hardware lock, since the GPE
361 * registers are owned by the gpe_lock.
Bob Moore967440e32006-06-23 17:04:00 -0400362 */
Len Brown4be44fc2005-08-05 00:44:28 -0400363 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
Bob Moore4c90ece2006-06-08 16:29:00 -0400364
365 /* Examine all GPE blocks attached to this interrupt level */
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 gpe_block = gpe_xrupt_list->gpe_block_list_head;
368 while (gpe_block) {
369 /*
Bob Moore9f15fc62008-11-12 16:01:56 +0800370 * Read all of the 8-bit GPE status and enable registers in this GPE
371 * block, saving all of them. Find all currently active GP events.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 */
373 for (i = 0; i < gpe_block->register_count; i++) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 /* Get the next status/enable pair */
376
377 gpe_register_info = &gpe_block->register_info[i];
378
Lin Ming6dfad332011-02-14 15:29:34 +0800379 /*
380 * Optimization: If there are no GPEs enabled within this
381 * register, we can safely ignore the entire register.
382 */
383 if (!(gpe_register_info->enable_for_run |
384 gpe_register_info->enable_for_wake)) {
Bob Mooree1154eb2012-08-17 10:55:14 +0800385 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
Bob Moore7505da42014-04-30 10:06:15 +0800386 "Ignore disabled registers for GPE %02X-%02X: "
Bob Mooree1154eb2012-08-17 10:55:14 +0800387 "RunEnable=%02X, WakeEnable=%02X\n",
388 gpe_register_info->
389 base_gpe_number,
390 gpe_register_info->
391 base_gpe_number +
392 (ACPI_GPE_REGISTER_WIDTH - 1),
393 gpe_register_info->
394 enable_for_run,
395 gpe_register_info->
396 enable_for_wake));
Lin Ming6dfad332011-02-14 15:29:34 +0800397 continue;
398 }
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 /* Read the Status Register */
401
Len Brown4be44fc2005-08-05 00:44:28 -0400402 status =
Bob Moorec6b57742009-06-24 09:44:06 +0800403 acpi_hw_read(&status_reg,
404 &gpe_register_info->status_address);
Len Brown4be44fc2005-08-05 00:44:28 -0400405 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 goto unlock_and_exit;
407 }
408
409 /* Read the Enable Register */
410
Len Brown4be44fc2005-08-05 00:44:28 -0400411 status =
Bob Moorec6b57742009-06-24 09:44:06 +0800412 acpi_hw_read(&enable_reg,
413 &gpe_register_info->enable_address);
Len Brown4be44fc2005-08-05 00:44:28 -0400414 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 goto unlock_and_exit;
416 }
417
Len Brown4be44fc2005-08-05 00:44:28 -0400418 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
Bob Moore7505da42014-04-30 10:06:15 +0800419 "Read registers for GPE %02X-%02X: Status=%02X, Enable=%02X, "
Bob Mooree1154eb2012-08-17 10:55:14 +0800420 "RunEnable=%02X, WakeEnable=%02X\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400421 gpe_register_info->base_gpe_number,
Bob Mooree1154eb2012-08-17 10:55:14 +0800422 gpe_register_info->base_gpe_number +
423 (ACPI_GPE_REGISTER_WIDTH - 1),
424 status_reg, enable_reg,
425 gpe_register_info->enable_for_run,
426 gpe_register_info->enable_for_wake));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Robert Moore44f6c012005-04-18 22:49:35 -0400428 /* Check if there is anything active at all in this register */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
430 enabled_status_byte = (u8) (status_reg & enable_reg);
431 if (!enabled_status_byte) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 /* No active GPEs in this register, move on */
434
435 continue;
436 }
437
438 /* Now look at the individual GPEs in this byte register */
439
440 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 /* Examine one GPE bit */
443
Alexey Starikovskiy69874162007-02-02 19:48:19 +0300444 if (enabled_status_byte & (1 << j)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 /*
446 * Found an active GPE. Dispatch the event to a handler
447 * or method.
448 */
Len Brown4be44fc2005-08-05 00:44:28 -0400449 int_status |=
Lin Ming8b6cd8a2010-12-13 13:38:46 +0800450 acpi_ev_gpe_dispatch(gpe_block->
451 node,
452 &gpe_block->
Bob Moore67a119f2008-06-10 13:42:13 +0800453 event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 }
455 }
456 }
457
458 gpe_block = gpe_block->next;
459 }
460
Lv Zheng10622bf2013-10-29 09:30:02 +0800461unlock_and_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Len Brown4be44fc2005-08-05 00:44:28 -0400463 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 return (int_status);
465}
466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467/*******************************************************************************
468 *
469 * FUNCTION: acpi_ev_asynch_execute_gpe_method
470 *
471 * PARAMETERS: Context (gpe_event_info) - Info for this GPE
472 *
473 * RETURN: None
474 *
Bob Moore41195322006-05-26 16:36:00 -0400475 * DESCRIPTION: Perform the actual execution of a GPE control method. This
476 * function is called from an invocation of acpi_os_execute and
477 * therefore does NOT execute at interrupt level - so that
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 * the control method itself is not executed in the context of
479 * an interrupt handler.
480 *
481 ******************************************************************************/
482
Len Brown4be44fc2005-08-05 00:44:28 -0400483static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484{
Lin Ming5a284cd2010-12-13 13:39:07 +0800485 struct acpi_gpe_event_info *gpe_event_info = context;
Len Brown4be44fc2005-08-05 00:44:28 -0400486 acpi_status status;
Lin Ming5a284cd2010-12-13 13:39:07 +0800487 struct acpi_gpe_event_info *local_gpe_event_info;
Bob Moore41195322006-05-26 16:36:00 -0400488 struct acpi_evaluate_info *info;
Bob Moore5816b342012-06-29 10:04:17 +0800489 struct acpi_gpe_notify_info *notify;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Bob Mooreb229cf92006-04-21 17:15:00 -0400491 ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Lin Ming5a284cd2010-12-13 13:39:07 +0800493 /* Allocate a local GPE block */
494
495 local_gpe_event_info =
496 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_event_info));
497 if (!local_gpe_event_info) {
498 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, "while handling a GPE"));
499 return_VOID;
500 }
501
Len Brown4be44fc2005-08-05 00:44:28 -0400502 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
503 if (ACPI_FAILURE(status)) {
Jesper Juhlbe33b762011-01-16 20:37:52 +0100504 ACPI_FREE(local_gpe_event_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 return_VOID;
506 }
507
508 /* Must revalidate the gpe_number/gpe_block */
509
Len Brown4be44fc2005-08-05 00:44:28 -0400510 if (!acpi_ev_valid_gpe_event(gpe_event_info)) {
511 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
Jesper Juhlbe33b762011-01-16 20:37:52 +0100512 ACPI_FREE(local_gpe_event_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return_VOID;
514 }
515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 /*
Bob Moore9f15fc62008-11-12 16:01:56 +0800517 * Take a snapshot of the GPE info for this level - we copy the info to
518 * prevent a race condition with remove_handler/remove_block.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 */
Lin Ming5a284cd2010-12-13 13:39:07 +0800520 ACPI_MEMCPY(local_gpe_event_info, gpe_event_info,
Len Brown4be44fc2005-08-05 00:44:28 -0400521 sizeof(struct acpi_gpe_event_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Len Brown4be44fc2005-08-05 00:44:28 -0400523 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
524 if (ACPI_FAILURE(status)) {
Lv Zhengab3b2482013-10-29 09:29:40 +0800525 ACPI_FREE(local_gpe_event_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 return_VOID;
527 }
528
Lin Mingbba63a22010-12-13 13:39:17 +0800529 /* Do the correct dispatch - normal method or implicit notify */
530
531 switch (local_gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
532 case ACPI_GPE_DISPATCH_NOTIFY:
Lin Mingbba63a22010-12-13 13:39:17 +0800533 /*
534 * Implicit notify.
535 * Dispatch a DEVICE_WAKE notify to the appropriate handler.
536 * NOTE: the request is queued for execution after this method
537 * completes. The notify handlers are NOT invoked synchronously
538 * from this thread -- because handlers may in turn run other
539 * control methods.
Bob Moore5816b342012-06-29 10:04:17 +0800540 *
541 * June 2012: Expand implicit notify mechanism to support
542 * notifies on multiple device objects.
Lin Mingbba63a22010-12-13 13:39:17 +0800543 */
Bob Moore5816b342012-06-29 10:04:17 +0800544 notify = local_gpe_event_info->dispatch.notify_list;
545 while (ACPI_SUCCESS(status) && notify) {
546 status =
547 acpi_ev_queue_notify_request(notify->device_node,
548 ACPI_NOTIFY_DEVICE_WAKE);
Rafael J. Wysocki981858b2011-02-24 19:59:21 +0100549
Bob Moore5816b342012-06-29 10:04:17 +0800550 notify = notify->next;
Rafael J. Wysocki981858b2011-02-24 19:59:21 +0100551 }
552
Lin Mingbba63a22010-12-13 13:39:17 +0800553 break;
554
555 case ACPI_GPE_DISPATCH_METHOD:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Bob Moore41195322006-05-26 16:36:00 -0400557 /* Allocate the evaluation information block */
558
559 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
560 if (!info) {
561 status = AE_NO_MEMORY;
562 } else {
563 /*
Lv Zheng75c80442012-12-19 05:36:49 +0000564 * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the
565 * _Lxx/_Exx control method that corresponds to this GPE
Bob Moore41195322006-05-26 16:36:00 -0400566 */
567 info->prefix_node =
Lin Ming5a284cd2010-12-13 13:39:07 +0800568 local_gpe_event_info->dispatch.method_node;
Bob Moore41195322006-05-26 16:36:00 -0400569 info->flags = ACPI_IGNORE_RETURN_VALUE;
570
571 status = acpi_ns_evaluate(info);
572 ACPI_FREE(info);
573 }
574
Len Brown4be44fc2005-08-05 00:44:28 -0400575 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500576 ACPI_EXCEPTION((AE_INFO, status,
Bob Moore2e420052007-02-02 19:48:18 +0300577 "while evaluating GPE method [%4.4s]",
Bob Mooreb8e4d892006-01-27 16:43:00 -0500578 acpi_ut_get_node_name
Lin Ming5a284cd2010-12-13 13:39:07 +0800579 (local_gpe_event_info->dispatch.
Bob Moore4c90ece2006-06-08 16:29:00 -0400580 method_node)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
Lin Mingbba63a22010-12-13 13:39:17 +0800582 break;
583
584 default:
Chao Guan1d1ea1b2013-06-08 00:58:14 +0000585
586 return_VOID; /* Should never happen */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 }
Lin Ming5a284cd2010-12-13 13:39:07 +0800588
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300589 /* Defer enabling of GPE until all notify handlers are done */
Lin Ming5a284cd2010-12-13 13:39:07 +0800590
591 status = acpi_os_execute(OSL_NOTIFY_HANDLER,
592 acpi_ev_asynch_enable_gpe,
593 local_gpe_event_info);
594 if (ACPI_FAILURE(status)) {
595 ACPI_FREE(local_gpe_event_info);
596 }
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300597 return_VOID;
598}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Lin Mingbba63a22010-12-13 13:39:17 +0800600
Lin Ming5a284cd2010-12-13 13:39:07 +0800601/*******************************************************************************
602 *
603 * FUNCTION: acpi_ev_asynch_enable_gpe
604 *
605 * PARAMETERS: Context (gpe_event_info) - Info for this GPE
606 * Callback from acpi_os_execute
607 *
608 * RETURN: None
609 *
610 * DESCRIPTION: Asynchronous clear/enable for GPE. This allows the GPE to
Lin Mingbba63a22010-12-13 13:39:17 +0800611 * complete (i.e., finish execution of Notify)
Lin Ming5a284cd2010-12-13 13:39:07 +0800612 *
613 ******************************************************************************/
614
615static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context)
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300616{
617 struct acpi_gpe_event_info *gpe_event_info = context;
Lin Mingbba63a22010-12-13 13:39:17 +0800618
619 (void)acpi_ev_finish_gpe(gpe_event_info);
620
621 ACPI_FREE(gpe_event_info);
622 return;
623}
624
625
626/*******************************************************************************
627 *
628 * FUNCTION: acpi_ev_finish_gpe
629 *
630 * PARAMETERS: gpe_event_info - Info for this GPE
631 *
632 * RETURN: Status
633 *
634 * DESCRIPTION: Clear/Enable a GPE. Common code that is used after execution
635 * of a GPE method or a synchronous or asynchronous GPE handler.
636 *
637 ******************************************************************************/
638
639acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info)
640{
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300641 acpi_status status;
Lin Ming5a284cd2010-12-13 13:39:07 +0800642
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300643 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
Len Brown4be44fc2005-08-05 00:44:28 -0400644 ACPI_GPE_LEVEL_TRIGGERED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 /*
Lin Mingbba63a22010-12-13 13:39:17 +0800646 * GPE is level-triggered, we clear the GPE status bit after
647 * handling the event.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 */
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300649 status = acpi_hw_clear_gpe(gpe_event_info);
Len Brown4be44fc2005-08-05 00:44:28 -0400650 if (ACPI_FAILURE(status)) {
Lin Mingbba63a22010-12-13 13:39:17 +0800651 return (status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 }
653 }
654
Bob Moorede5668f2010-07-06 10:30:37 +0800655 /*
Lin Mingbba63a22010-12-13 13:39:17 +0800656 * Enable this GPE, conditionally. This means that the GPE will
657 * only be physically enabled if the enable_for_run bit is set
658 * in the event_info.
Bob Moorede5668f2010-07-06 10:30:37 +0800659 */
Lin Ming3a378982010-12-13 13:36:15 +0800660 (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_CONDITIONAL_ENABLE);
Lin Mingbba63a22010-12-13 13:39:17 +0800661 return (AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
663
Lin Mingbba63a22010-12-13 13:39:17 +0800664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665/*******************************************************************************
666 *
667 * FUNCTION: acpi_ev_gpe_dispatch
668 *
Lin Ming8b6cd8a2010-12-13 13:38:46 +0800669 * PARAMETERS: gpe_device - Device node. NULL for GPE0/GPE1
670 * gpe_event_info - Info for this GPE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 * gpe_number - Number relative to the parent GPE block
672 *
673 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
674 *
675 * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
676 * or method (e.g. _Lxx/_Exx) handler.
677 *
678 * This function executes at interrupt level.
679 *
680 ******************************************************************************/
681
682u32
Lin Ming8b6cd8a2010-12-13 13:38:46 +0800683acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
684 struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
Len Brown4be44fc2005-08-05 00:44:28 -0400686 acpi_status status;
Lin Mingbba63a22010-12-13 13:39:17 +0800687 u32 return_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Bob Mooreb229cf92006-04-21 17:15:00 -0400689 ACPI_FUNCTION_TRACE(ev_gpe_dispatch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Lin Minga0fcdb22010-12-13 13:39:26 +0800691 /* Invoke global event handler if present */
692
693 acpi_gpe_count++;
694 if (acpi_gbl_global_event_handler) {
695 acpi_gbl_global_event_handler(ACPI_EVENT_TYPE_GPE, gpe_device,
696 gpe_number,
697 acpi_gbl_global_event_handler_context);
698 }
Bob Moorefdffb722007-02-02 19:48:19 +0300699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 /*
Bob Moore9f15fc62008-11-12 16:01:56 +0800701 * If edge-triggered, clear the GPE status bit now. Note that
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 * level-triggered events are cleared after the GPE is serviced.
703 */
Robert Moore44f6c012005-04-18 22:49:35 -0400704 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
Len Brown4be44fc2005-08-05 00:44:28 -0400705 ACPI_GPE_EDGE_TRIGGERED) {
706 status = acpi_hw_clear_gpe(gpe_event_info);
707 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500708 ACPI_EXCEPTION((AE_INFO, status,
Bob Moore7505da42014-04-30 10:06:15 +0800709 "Unable to clear GPE %02X",
710 gpe_number));
Bob Moorefd1af712013-03-08 09:22:23 +0000711 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 }
713 }
714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 /*
Lin Mingbba63a22010-12-13 13:39:17 +0800716 * Always disable the GPE so that it does not keep firing before
717 * any asynchronous activity completes (either from the execution
718 * of a GPE method or an asynchronous GPE handler.)
719 *
720 * If there is no handler or method to run, just disable the
721 * GPE and leave it disabled permanently to prevent further such
722 * pointless events from firing.
723 */
724 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
725 if (ACPI_FAILURE(status)) {
726 ACPI_EXCEPTION((AE_INFO, status,
Bob Moore7505da42014-04-30 10:06:15 +0800727 "Unable to disable GPE %02X", gpe_number));
Bob Moorefd1af712013-03-08 09:22:23 +0000728 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
Lin Mingbba63a22010-12-13 13:39:17 +0800729 }
730
731 /*
732 * Dispatch the GPE to either an installed handler or the control
733 * method associated with this GPE (_Lxx or _Exx). If a handler
734 * exists, we invoke it and do not attempt to run the method.
735 * If there is neither a handler nor a method, leave the GPE
736 * disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 */
738 switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
739 case ACPI_GPE_DISPATCH_HANDLER:
740
Lin Mingbba63a22010-12-13 13:39:17 +0800741 /* Invoke the installed handler (at interrupt level) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Lin Mingbba63a22010-12-13 13:39:17 +0800743 return_value =
744 gpe_event_info->dispatch.handler->address(gpe_device,
745 gpe_number,
746 gpe_event_info->
747 dispatch.handler->
748 context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Lin Mingbba63a22010-12-13 13:39:17 +0800750 /* If requested, clear (if level-triggered) and reenable the GPE */
751
752 if (return_value & ACPI_REENABLE_GPE) {
753 (void)acpi_ev_finish_gpe(gpe_event_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 }
755 break;
756
757 case ACPI_GPE_DISPATCH_METHOD:
Lin Mingbba63a22010-12-13 13:39:17 +0800758 case ACPI_GPE_DISPATCH_NOTIFY:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 /*
760 * Execute the method associated with the GPE
761 * NOTE: Level-triggered GPEs are cleared after the method completes.
762 */
Bob Moore958dd242006-05-12 17:12:00 -0400763 status = acpi_os_execute(OSL_GPE_HANDLER,
764 acpi_ev_asynch_execute_gpe_method,
765 gpe_event_info);
Len Brown4be44fc2005-08-05 00:44:28 -0400766 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500767 ACPI_EXCEPTION((AE_INFO, status,
Bob Moore7505da42014-04-30 10:06:15 +0800768 "Unable to queue handler for GPE %02X - event disabled",
Bob Mooreb8e4d892006-01-27 16:43:00 -0500769 gpe_number));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
771 break;
772
773 default:
Lin Ming0f849d22010-04-06 14:52:37 +0800774 /*
775 * No handler or method to run!
776 * 03/2010: This case should no longer be possible. We will not allow
777 * a GPE to be enabled if it has no handler or method.
778 */
Bob Mooreb8e4d892006-01-27 16:43:00 -0500779 ACPI_ERROR((AE_INFO,
Bob Moore7505da42014-04-30 10:06:15 +0800780 "No handler or method for GPE %02X, disabling event",
Bob Mooreb8e4d892006-01-27 16:43:00 -0500781 gpe_number));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 break;
784 }
785
Bob Moorefd1af712013-03-08 09:22:23 +0000786 return_UINT32(ACPI_INTERRUPT_HANDLED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
Bob Moore33620c52012-02-14 18:14:27 +0800788
789#endif /* !ACPI_REDUCED_HARDWARE */