5 *
6 *****************************************************************************/
7
8/******************************************************************************
9 *
10 * 1. Copyright Notice
11 *
12 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
13 * All rights reserved.
14 *
15 * 2. License
16 *
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights. You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
20 * property rights.
21 *
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
28 *
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code. No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
37 *
38 * The above copyright and patent license is granted only if the following
39 * conditions are met:
40 *
41 * 3. Conditions
42 *
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision. In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change. Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee. Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
54 *
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution. In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
65 * make.
66 *
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
71 * distribution.
72 *
73 * 3.4. Intel retains all right, title, and interest in and to the Original
74 * Intel Code.
75 *
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
80 *
81 * 4. Disclaimer and Export Compliance
82 *
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89 * PARTICULAR PURPOSE.
90 *
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98 * LIMITED REMEDY.
99 *
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
114 *
115 *****************************************************************************/
116
117#include "acpi.h"
118#include "acevents.h"
119#include "acnamesp.h"
120
121#define _COMPONENT ACPI_EVENTS
122 ACPI_MODULE_NAME ("evgpe")
123
124
125/*******************************************************************************
126 *
127 * FUNCTION: AcpiEvGetGpeEventInfo
128 *
129 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
130 * GpeNumber - Raw GPE number
131 *
132 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE
133 *
134 * DESCRIPTION: Returns the EventInfo struct associated with this GPE.
135 * Validates the GpeBlock and the GpeNumber
136 *
137 * Should be called only when the GPE lists are semaphore locked
138 * and not subject to change.
139 *
140 ******************************************************************************/
141
142ACPI_GPE_EVENT_INFO *
143AcpiEvGetGpeEventInfo (
144 ACPI_HANDLE GpeDevice,
145 UINT32 GpeNumber)
146{
147 ACPI_OPERAND_OBJECT *ObjDesc;
148 ACPI_GPE_BLOCK_INFO *GpeBlock;
149 ACPI_NATIVE_UINT i;
150
151
152 ACPI_FUNCTION_ENTRY ();
153
154
155 /* A NULL GpeBlock means use the FADT-defined GPE block(s) */
156
157 if (!GpeDevice)
158 {
159 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
160
161 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++)
162 {
163 GpeBlock = AcpiGbl_GpeFadtBlocks[i];
164 if (GpeBlock)
165 {
166 if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
167 (GpeNumber < GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8)))
168 {
169 return (&GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber]);
170 }
171 }
172 }
173
174 /* The GpeNumber was not in the range of either FADT GPE block */
175
176 return (NULL);
177 }
178
179 /*
180 * A Non-null GpeDevice means this is a GPE Block Device.
181 */
182 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) GpeDevice);
183 if (!ObjDesc ||
184 !ObjDesc->Device.GpeBlock)
185 {
186 return (NULL);
187 }
188
189 GpeBlock = ObjDesc->Device.GpeBlock;
190
191 if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
192 (GpeNumber < GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8)))
193 {
194 return (&GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber]);
195 }
196
197 return (NULL);
198}
199
200
201/*******************************************************************************
202 *
203 * FUNCTION: AcpiEvGpeDetect
204 *
205 * PARAMETERS: GpeXruptList - Interrupt block for this interrupt.
206 * Can have multiple GPE blocks attached.
207 *
208 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
209 *
210 * DESCRIPTION: Detect if any GP events have occurred. This function is
211 * executed at interrupt level.
212 *
213 ******************************************************************************/
214
215UINT32
216AcpiEvGpeDetect (
217 ACPI_GPE_XRUPT_INFO *GpeXruptList)
218{
219 UINT32 IntStatus = ACPI_INTERRUPT_NOT_HANDLED;
220 UINT8 EnabledStatusByte;
221 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
222 UINT32 InValue;
223 ACPI_STATUS Status;
224 ACPI_GPE_BLOCK_INFO *GpeBlock;
225 UINT32 i;
226 UINT32 j;
227
228
229 ACPI_FUNCTION_NAME ("EvGpeDetect");
230
| 5 *
6 *****************************************************************************/
7
8/******************************************************************************
9 *
10 * 1. Copyright Notice
11 *
12 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
13 * All rights reserved.
14 *
15 * 2. License
16 *
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights. You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
20 * property rights.
21 *
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
28 *
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code. No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
37 *
38 * The above copyright and patent license is granted only if the following
39 * conditions are met:
40 *
41 * 3. Conditions
42 *
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision. In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change. Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee. Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
54 *
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution. In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
65 * make.
66 *
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
71 * distribution.
72 *
73 * 3.4. Intel retains all right, title, and interest in and to the Original
74 * Intel Code.
75 *
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
80 *
81 * 4. Disclaimer and Export Compliance
82 *
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89 * PARTICULAR PURPOSE.
90 *
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98 * LIMITED REMEDY.
99 *
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
114 *
115 *****************************************************************************/
116
117#include "acpi.h"
118#include "acevents.h"
119#include "acnamesp.h"
120
121#define _COMPONENT ACPI_EVENTS
122 ACPI_MODULE_NAME ("evgpe")
123
124
125/*******************************************************************************
126 *
127 * FUNCTION: AcpiEvGetGpeEventInfo
128 *
129 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
130 * GpeNumber - Raw GPE number
131 *
132 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE
133 *
134 * DESCRIPTION: Returns the EventInfo struct associated with this GPE.
135 * Validates the GpeBlock and the GpeNumber
136 *
137 * Should be called only when the GPE lists are semaphore locked
138 * and not subject to change.
139 *
140 ******************************************************************************/
141
142ACPI_GPE_EVENT_INFO *
143AcpiEvGetGpeEventInfo (
144 ACPI_HANDLE GpeDevice,
145 UINT32 GpeNumber)
146{
147 ACPI_OPERAND_OBJECT *ObjDesc;
148 ACPI_GPE_BLOCK_INFO *GpeBlock;
149 ACPI_NATIVE_UINT i;
150
151
152 ACPI_FUNCTION_ENTRY ();
153
154
155 /* A NULL GpeBlock means use the FADT-defined GPE block(s) */
156
157 if (!GpeDevice)
158 {
159 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
160
161 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++)
162 {
163 GpeBlock = AcpiGbl_GpeFadtBlocks[i];
164 if (GpeBlock)
165 {
166 if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
167 (GpeNumber < GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8)))
168 {
169 return (&GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber]);
170 }
171 }
172 }
173
174 /* The GpeNumber was not in the range of either FADT GPE block */
175
176 return (NULL);
177 }
178
179 /*
180 * A Non-null GpeDevice means this is a GPE Block Device.
181 */
182 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) GpeDevice);
183 if (!ObjDesc ||
184 !ObjDesc->Device.GpeBlock)
185 {
186 return (NULL);
187 }
188
189 GpeBlock = ObjDesc->Device.GpeBlock;
190
191 if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
192 (GpeNumber < GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8)))
193 {
194 return (&GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber]);
195 }
196
197 return (NULL);
198}
199
200
201/*******************************************************************************
202 *
203 * FUNCTION: AcpiEvGpeDetect
204 *
205 * PARAMETERS: GpeXruptList - Interrupt block for this interrupt.
206 * Can have multiple GPE blocks attached.
207 *
208 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
209 *
210 * DESCRIPTION: Detect if any GP events have occurred. This function is
211 * executed at interrupt level.
212 *
213 ******************************************************************************/
214
215UINT32
216AcpiEvGpeDetect (
217 ACPI_GPE_XRUPT_INFO *GpeXruptList)
218{
219 UINT32 IntStatus = ACPI_INTERRUPT_NOT_HANDLED;
220 UINT8 EnabledStatusByte;
221 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
222 UINT32 InValue;
223 ACPI_STATUS Status;
224 ACPI_GPE_BLOCK_INFO *GpeBlock;
225 UINT32 i;
226 UINT32 j;
227
228
229 ACPI_FUNCTION_NAME ("EvGpeDetect");
230
|
232 /* Examine all GPE blocks attached to this interrupt level */
233
234 AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_ISR);
235 GpeBlock = GpeXruptList->GpeBlockListHead;
236 while (GpeBlock)
237 {
238 /*
239 * Read all of the 8-bit GPE status and enable registers
240 * in this GPE block, saving all of them.
241 * Find all currently active GP events.
242 */
243 for (i = 0; i < GpeBlock->RegisterCount; i++)
244 {
245 /* Get the next status/enable pair */
246
247 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
248
249 /* Read the Status Register */
250
251 Status = AcpiHwLowLevelRead (ACPI_GPE_REGISTER_WIDTH, &InValue,
252 &GpeRegisterInfo->StatusAddress);
253 GpeRegisterInfo->Status = (UINT8) InValue;
254 if (ACPI_FAILURE (Status))
255 {
256 goto UnlockAndExit;
257 }
258
259 /* Read the Enable Register */
260
261 Status = AcpiHwLowLevelRead (ACPI_GPE_REGISTER_WIDTH, &InValue,
262 &GpeRegisterInfo->EnableAddress);
263 GpeRegisterInfo->Enable = (UINT8) InValue;
264 if (ACPI_FAILURE (Status))
265 {
266 goto UnlockAndExit;
267 }
268
269 ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS,
270 "GPE pair: Status %8.8X%8.8X = %02X, Enable %8.8X%8.8X = %02X\n",
271 ACPI_FORMAT_UINT64 (ACPI_GET_ADDRESS (GpeRegisterInfo->StatusAddress.Address)),
272 GpeRegisterInfo->Status,
273 ACPI_FORMAT_UINT64 (ACPI_GET_ADDRESS (GpeRegisterInfo->EnableAddress.Address)),
274 GpeRegisterInfo->Enable));
275
276 /* First check if there is anything active at all in this register */
277
278 EnabledStatusByte = (UINT8) (GpeRegisterInfo->Status &
279 GpeRegisterInfo->Enable);
280 if (!EnabledStatusByte)
281 {
282 /* No active GPEs in this register, move on */
283
284 continue;
285 }
286
287 /* Now look at the individual GPEs in this byte register */
288
289 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
290 {
291 /* Examine one GPE bit */
292
293 if (EnabledStatusByte & AcpiGbl_DecodeTo8bit[j])
294 {
295 /*
296 * Found an active GPE. Dispatch the event to a handler
297 * or method.
298 */
299 IntStatus |= AcpiEvGpeDispatch (
300 &GpeBlock->EventInfo[(i * ACPI_GPE_REGISTER_WIDTH) + j],
301 j + GpeRegisterInfo->BaseGpeNumber);
302 }
303 }
304 }
305
306 GpeBlock = GpeBlock->Next;
307 }
308
309UnlockAndExit:
310
311 AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_ISR);
312 return (IntStatus);
313}
314
315
316/*******************************************************************************
317 *
318 * FUNCTION: AcpiEvAsynchExecuteGpeMethod
319 *
320 * PARAMETERS: Context (GpeEventInfo) - Info for this GPE
321 *
322 * RETURN: None
323 *
324 * DESCRIPTION: Perform the actual execution of a GPE control method. This
325 * function is called from an invocation of AcpiOsQueueForExecution
326 * (and therefore does NOT execute at interrupt level) so that
327 * the control method itself is not executed in the context of
328 * an interrupt handler.
329 *
330 ******************************************************************************/
331
332static void ACPI_SYSTEM_XFACE
333AcpiEvAsynchExecuteGpeMethod (
334 void *Context)
335{
336 ACPI_GPE_EVENT_INFO *GpeEventInfo = (void *) Context;
337 UINT32 GpeNumber = 0;
338 ACPI_STATUS Status;
339 ACPI_GPE_EVENT_INFO LocalGpeEventInfo;
340
341
342 ACPI_FUNCTION_TRACE ("EvAsynchExecuteGpeMethod");
343
344
345 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
346 if (ACPI_FAILURE (Status))
347 {
348 return_VOID;
349 }
350
351 /* Must revalidate the GpeNumber/GpeBlock */
352
353 if (!AcpiEvValidGpeEvent (GpeEventInfo))
354 {
355 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
356 return_VOID;
357 }
358
359 /*
360 * Take a snapshot of the GPE info for this level - we copy the
361 * info to prevent a race condition with RemoveHandler/RemoveBlock.
362 */
363 ACPI_MEMCPY (&LocalGpeEventInfo, GpeEventInfo, sizeof (ACPI_GPE_EVENT_INFO));
364
365 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
366 if (ACPI_FAILURE (Status))
367 {
368 return_VOID;
369 }
370
371 if (LocalGpeEventInfo.MethodNode)
372 {
373 /*
374 * Invoke the GPE Method (_Lxx, _Exx):
375 * (Evaluate the _Lxx/_Exx control method that corresponds to this GPE.)
376 */
377 Status = AcpiNsEvaluateByHandle (LocalGpeEventInfo.MethodNode, NULL, NULL);
378 if (ACPI_FAILURE (Status))
379 {
380 ACPI_REPORT_ERROR (("%s while evaluating method [%4.4s] for GPE[%2X]\n",
381 AcpiFormatException (Status),
382 AcpiUtGetNodeName (LocalGpeEventInfo.MethodNode), GpeNumber));
383 }
384 }
385
386 if (LocalGpeEventInfo.Flags & ACPI_EVENT_LEVEL_TRIGGERED)
387 {
388 /*
389 * GPE is level-triggered, we clear the GPE status bit after handling
390 * the event.
391 */
392 Status = AcpiHwClearGpe (&LocalGpeEventInfo);
393 if (ACPI_FAILURE (Status))
394 {
395 return_VOID;
396 }
397 }
398
399 /* Enable this GPE */
400
401 (void) AcpiHwEnableGpe (&LocalGpeEventInfo);
402 return_VOID;
403}
404
405
406/*******************************************************************************
407 *
408 * FUNCTION: AcpiEvGpeDispatch
409 *
410 * PARAMETERS: GpeEventInfo - info for this GPE
411 * GpeNumber - Number relative to the parent GPE block
412 *
413 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
414 *
415 * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
416 * or method (e.g. _Lxx/_Exx) handler.
417 *
418 * This function executes at interrupt level.
419 *
420 ******************************************************************************/
421
422UINT32
423AcpiEvGpeDispatch (
424 ACPI_GPE_EVENT_INFO *GpeEventInfo,
425 UINT32 GpeNumber)
426{
427 ACPI_STATUS Status;
428
429
430 ACPI_FUNCTION_TRACE ("EvGpeDispatch");
431
432
433 /*
434 * If edge-triggered, clear the GPE status bit now. Note that
435 * level-triggered events are cleared after the GPE is serviced.
436 */
437 if (GpeEventInfo->Flags & ACPI_EVENT_EDGE_TRIGGERED)
438 {
439 Status = AcpiHwClearGpe (GpeEventInfo);
440 if (ACPI_FAILURE (Status))
441 {
442 ACPI_REPORT_ERROR (("AcpiEvGpeDispatch: Unable to clear GPE[%2X]\n",
443 GpeNumber));
444 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
445 }
446 }
447
448 /*
449 * Dispatch the GPE to either an installed handler, or the control
450 * method associated with this GPE (_Lxx or _Exx).
451 * If a handler exists, we invoke it and do not attempt to run the method.
452 * If there is neither a handler nor a method, we disable the level to
453 * prevent further events from coming in here.
454 */
455 if (GpeEventInfo->Handler)
456 {
457 /* Invoke the installed handler (at interrupt level) */
458
459 GpeEventInfo->Handler (GpeEventInfo->Context);
460
461 /* It is now safe to clear level-triggered events. */
462
463 if (GpeEventInfo->Flags & ACPI_EVENT_LEVEL_TRIGGERED)
464 {
465 Status = AcpiHwClearGpe (GpeEventInfo);
466 if (ACPI_FAILURE (Status))
467 {
468 ACPI_REPORT_ERROR ((
469 "AcpiEvGpeDispatch: Unable to clear GPE[%2X]\n",
470 GpeNumber));
471 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
472 }
473 }
474 }
475 else if (GpeEventInfo->MethodNode)
476 {
477 /*
478 * Disable GPE, so it doesn't keep firing before the method has a
479 * chance to run.
480 */
481 Status = AcpiHwDisableGpe (GpeEventInfo);
482 if (ACPI_FAILURE (Status))
483 {
484 ACPI_REPORT_ERROR ((
485 "AcpiEvGpeDispatch: Unable to disable GPE[%2X]\n",
486 GpeNumber));
487 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
488 }
489
490 /*
491 * Execute the method associated with the GPE
492 * NOTE: Level-triggered GPEs are cleared after the method completes.
493 */
494 if (ACPI_FAILURE (AcpiOsQueueForExecution (OSD_PRIORITY_GPE,
495 AcpiEvAsynchExecuteGpeMethod,
496 GpeEventInfo)))
497 {
498 ACPI_REPORT_ERROR ((
499 "AcpiEvGpeDispatch: Unable to queue handler for GPE[%2X], event is disabled\n",
500 GpeNumber));
501 }
502 }
503 else
504 {
505 /* No handler or method to run! */
506
507 ACPI_REPORT_ERROR ((
508 "AcpiEvGpeDispatch: No handler or method for GPE[%2X], disabling event\n",
509 GpeNumber));
510
511 /*
512 * Disable the GPE. The GPE will remain disabled until the ACPI
513 * Core Subsystem is restarted, or a handler is installed.
514 */
515 Status = AcpiHwDisableGpe (GpeEventInfo);
516 if (ACPI_FAILURE (Status))
517 {
518 ACPI_REPORT_ERROR ((
519 "AcpiEvGpeDispatch: Unable to disable GPE[%2X]\n",
520 GpeNumber));
521 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
522 }
523 }
524
525 return_VALUE (ACPI_INTERRUPT_HANDLED);
526}
527
| 238 /* Examine all GPE blocks attached to this interrupt level */
239
240 AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_ISR);
241 GpeBlock = GpeXruptList->GpeBlockListHead;
242 while (GpeBlock)
243 {
244 /*
245 * Read all of the 8-bit GPE status and enable registers
246 * in this GPE block, saving all of them.
247 * Find all currently active GP events.
248 */
249 for (i = 0; i < GpeBlock->RegisterCount; i++)
250 {
251 /* Get the next status/enable pair */
252
253 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
254
255 /* Read the Status Register */
256
257 Status = AcpiHwLowLevelRead (ACPI_GPE_REGISTER_WIDTH, &InValue,
258 &GpeRegisterInfo->StatusAddress);
259 GpeRegisterInfo->Status = (UINT8) InValue;
260 if (ACPI_FAILURE (Status))
261 {
262 goto UnlockAndExit;
263 }
264
265 /* Read the Enable Register */
266
267 Status = AcpiHwLowLevelRead (ACPI_GPE_REGISTER_WIDTH, &InValue,
268 &GpeRegisterInfo->EnableAddress);
269 GpeRegisterInfo->Enable = (UINT8) InValue;
270 if (ACPI_FAILURE (Status))
271 {
272 goto UnlockAndExit;
273 }
274
275 ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS,
276 "GPE pair: Status %8.8X%8.8X = %02X, Enable %8.8X%8.8X = %02X\n",
277 ACPI_FORMAT_UINT64 (ACPI_GET_ADDRESS (GpeRegisterInfo->StatusAddress.Address)),
278 GpeRegisterInfo->Status,
279 ACPI_FORMAT_UINT64 (ACPI_GET_ADDRESS (GpeRegisterInfo->EnableAddress.Address)),
280 GpeRegisterInfo->Enable));
281
282 /* First check if there is anything active at all in this register */
283
284 EnabledStatusByte = (UINT8) (GpeRegisterInfo->Status &
285 GpeRegisterInfo->Enable);
286 if (!EnabledStatusByte)
287 {
288 /* No active GPEs in this register, move on */
289
290 continue;
291 }
292
293 /* Now look at the individual GPEs in this byte register */
294
295 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
296 {
297 /* Examine one GPE bit */
298
299 if (EnabledStatusByte & AcpiGbl_DecodeTo8bit[j])
300 {
301 /*
302 * Found an active GPE. Dispatch the event to a handler
303 * or method.
304 */
305 IntStatus |= AcpiEvGpeDispatch (
306 &GpeBlock->EventInfo[(i * ACPI_GPE_REGISTER_WIDTH) + j],
307 j + GpeRegisterInfo->BaseGpeNumber);
308 }
309 }
310 }
311
312 GpeBlock = GpeBlock->Next;
313 }
314
315UnlockAndExit:
316
317 AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_ISR);
318 return (IntStatus);
319}
320
321
322/*******************************************************************************
323 *
324 * FUNCTION: AcpiEvAsynchExecuteGpeMethod
325 *
326 * PARAMETERS: Context (GpeEventInfo) - Info for this GPE
327 *
328 * RETURN: None
329 *
330 * DESCRIPTION: Perform the actual execution of a GPE control method. This
331 * function is called from an invocation of AcpiOsQueueForExecution
332 * (and therefore does NOT execute at interrupt level) so that
333 * the control method itself is not executed in the context of
334 * an interrupt handler.
335 *
336 ******************************************************************************/
337
338static void ACPI_SYSTEM_XFACE
339AcpiEvAsynchExecuteGpeMethod (
340 void *Context)
341{
342 ACPI_GPE_EVENT_INFO *GpeEventInfo = (void *) Context;
343 UINT32 GpeNumber = 0;
344 ACPI_STATUS Status;
345 ACPI_GPE_EVENT_INFO LocalGpeEventInfo;
346
347
348 ACPI_FUNCTION_TRACE ("EvAsynchExecuteGpeMethod");
349
350
351 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
352 if (ACPI_FAILURE (Status))
353 {
354 return_VOID;
355 }
356
357 /* Must revalidate the GpeNumber/GpeBlock */
358
359 if (!AcpiEvValidGpeEvent (GpeEventInfo))
360 {
361 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
362 return_VOID;
363 }
364
365 /*
366 * Take a snapshot of the GPE info for this level - we copy the
367 * info to prevent a race condition with RemoveHandler/RemoveBlock.
368 */
369 ACPI_MEMCPY (&LocalGpeEventInfo, GpeEventInfo, sizeof (ACPI_GPE_EVENT_INFO));
370
371 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
372 if (ACPI_FAILURE (Status))
373 {
374 return_VOID;
375 }
376
377 if (LocalGpeEventInfo.MethodNode)
378 {
379 /*
380 * Invoke the GPE Method (_Lxx, _Exx):
381 * (Evaluate the _Lxx/_Exx control method that corresponds to this GPE.)
382 */
383 Status = AcpiNsEvaluateByHandle (LocalGpeEventInfo.MethodNode, NULL, NULL);
384 if (ACPI_FAILURE (Status))
385 {
386 ACPI_REPORT_ERROR (("%s while evaluating method [%4.4s] for GPE[%2X]\n",
387 AcpiFormatException (Status),
388 AcpiUtGetNodeName (LocalGpeEventInfo.MethodNode), GpeNumber));
389 }
390 }
391
392 if (LocalGpeEventInfo.Flags & ACPI_EVENT_LEVEL_TRIGGERED)
393 {
394 /*
395 * GPE is level-triggered, we clear the GPE status bit after handling
396 * the event.
397 */
398 Status = AcpiHwClearGpe (&LocalGpeEventInfo);
399 if (ACPI_FAILURE (Status))
400 {
401 return_VOID;
402 }
403 }
404
405 /* Enable this GPE */
406
407 (void) AcpiHwEnableGpe (&LocalGpeEventInfo);
408 return_VOID;
409}
410
411
412/*******************************************************************************
413 *
414 * FUNCTION: AcpiEvGpeDispatch
415 *
416 * PARAMETERS: GpeEventInfo - info for this GPE
417 * GpeNumber - Number relative to the parent GPE block
418 *
419 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
420 *
421 * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
422 * or method (e.g. _Lxx/_Exx) handler.
423 *
424 * This function executes at interrupt level.
425 *
426 ******************************************************************************/
427
428UINT32
429AcpiEvGpeDispatch (
430 ACPI_GPE_EVENT_INFO *GpeEventInfo,
431 UINT32 GpeNumber)
432{
433 ACPI_STATUS Status;
434
435
436 ACPI_FUNCTION_TRACE ("EvGpeDispatch");
437
438
439 /*
440 * If edge-triggered, clear the GPE status bit now. Note that
441 * level-triggered events are cleared after the GPE is serviced.
442 */
443 if (GpeEventInfo->Flags & ACPI_EVENT_EDGE_TRIGGERED)
444 {
445 Status = AcpiHwClearGpe (GpeEventInfo);
446 if (ACPI_FAILURE (Status))
447 {
448 ACPI_REPORT_ERROR (("AcpiEvGpeDispatch: Unable to clear GPE[%2X]\n",
449 GpeNumber));
450 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
451 }
452 }
453
454 /*
455 * Dispatch the GPE to either an installed handler, or the control
456 * method associated with this GPE (_Lxx or _Exx).
457 * If a handler exists, we invoke it and do not attempt to run the method.
458 * If there is neither a handler nor a method, we disable the level to
459 * prevent further events from coming in here.
460 */
461 if (GpeEventInfo->Handler)
462 {
463 /* Invoke the installed handler (at interrupt level) */
464
465 GpeEventInfo->Handler (GpeEventInfo->Context);
466
467 /* It is now safe to clear level-triggered events. */
468
469 if (GpeEventInfo->Flags & ACPI_EVENT_LEVEL_TRIGGERED)
470 {
471 Status = AcpiHwClearGpe (GpeEventInfo);
472 if (ACPI_FAILURE (Status))
473 {
474 ACPI_REPORT_ERROR ((
475 "AcpiEvGpeDispatch: Unable to clear GPE[%2X]\n",
476 GpeNumber));
477 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
478 }
479 }
480 }
481 else if (GpeEventInfo->MethodNode)
482 {
483 /*
484 * Disable GPE, so it doesn't keep firing before the method has a
485 * chance to run.
486 */
487 Status = AcpiHwDisableGpe (GpeEventInfo);
488 if (ACPI_FAILURE (Status))
489 {
490 ACPI_REPORT_ERROR ((
491 "AcpiEvGpeDispatch: Unable to disable GPE[%2X]\n",
492 GpeNumber));
493 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
494 }
495
496 /*
497 * Execute the method associated with the GPE
498 * NOTE: Level-triggered GPEs are cleared after the method completes.
499 */
500 if (ACPI_FAILURE (AcpiOsQueueForExecution (OSD_PRIORITY_GPE,
501 AcpiEvAsynchExecuteGpeMethod,
502 GpeEventInfo)))
503 {
504 ACPI_REPORT_ERROR ((
505 "AcpiEvGpeDispatch: Unable to queue handler for GPE[%2X], event is disabled\n",
506 GpeNumber));
507 }
508 }
509 else
510 {
511 /* No handler or method to run! */
512
513 ACPI_REPORT_ERROR ((
514 "AcpiEvGpeDispatch: No handler or method for GPE[%2X], disabling event\n",
515 GpeNumber));
516
517 /*
518 * Disable the GPE. The GPE will remain disabled until the ACPI
519 * Core Subsystem is restarted, or a handler is installed.
520 */
521 Status = AcpiHwDisableGpe (GpeEventInfo);
522 if (ACPI_FAILURE (Status))
523 {
524 ACPI_REPORT_ERROR ((
525 "AcpiEvGpeDispatch: Unable to disable GPE[%2X]\n",
526 GpeNumber));
527 return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
528 }
529 }
530
531 return_VALUE (ACPI_INTERRUPT_HANDLED);
532}
533
|