Deleted Added
sdiff udiff text old ( 204773 ) new ( 206117 )
full compact
evgpe.c (204773) evgpe.c (206117)
1/******************************************************************************
2 *
3 * Module Name: evgpe - General Purpose Event handling and dispatch
4 *
5 *****************************************************************************/
6
7/******************************************************************************
8 *

--- 120 unchanged lines hidden (view full) ---

129
130static void ACPI_SYSTEM_XFACE
131AcpiEvAsynchEnableGpe (
132 void *Context);
133
134
135/*******************************************************************************
136 *
1/******************************************************************************
2 *
3 * Module Name: evgpe - General Purpose Event handling and dispatch
4 *
5 *****************************************************************************/
6
7/******************************************************************************
8 *

--- 120 unchanged lines hidden (view full) ---

129
130static void ACPI_SYSTEM_XFACE
131AcpiEvAsynchEnableGpe (
132 void *Context);
133
134
135/*******************************************************************************
136 *
137 * FUNCTION: AcpiEvSetGpeType
138 *
139 * PARAMETERS: GpeEventInfo - GPE to set
140 * Type - New type
141 *
142 * RETURN: Status
143 *
144 * DESCRIPTION: Sets the new type for the GPE (wake, run, or wake/run)
145 *
146 ******************************************************************************/
147
148ACPI_STATUS
149AcpiEvSetGpeType (
150 ACPI_GPE_EVENT_INFO *GpeEventInfo,
151 UINT8 Type)
152{
153 ACPI_STATUS Status;
154
155
156 ACPI_FUNCTION_TRACE (EvSetGpeType);
157
158
159 /* Validate type and update register enable masks */
160
161 switch (Type)
162 {
163 case ACPI_GPE_TYPE_WAKE:
164 case ACPI_GPE_TYPE_RUNTIME:
165 case ACPI_GPE_TYPE_WAKE_RUN:
166 break;
167
168 default:
169 return_ACPI_STATUS (AE_BAD_PARAMETER);
170 }
171
172 /* Disable the GPE if currently enabled */
173
174 Status = AcpiEvDisableGpe (GpeEventInfo);
175
176 /* Clear the type bits and insert the new Type */
177
178 GpeEventInfo->Flags &= ~ACPI_GPE_TYPE_MASK;
179 GpeEventInfo->Flags |= Type;
180 return_ACPI_STATUS (Status);
181}
182
183
184/*******************************************************************************
185 *
186 * FUNCTION: AcpiEvUpdateGpeEnableMasks
187 *
188 * PARAMETERS: GpeEventInfo - GPE to update
137 * FUNCTION: AcpiEvUpdateGpeEnableMasks
138 *
139 * PARAMETERS: GpeEventInfo - GPE to update
189 * Type - What to do: ACPI_GPE_DISABLE or
190 * ACPI_GPE_ENABLE
191 *
192 * RETURN: Status
193 *
140 *
141 * RETURN: Status
142 *
194 * DESCRIPTION: Updates GPE register enable masks based on the GPE type
143 * DESCRIPTION: Updates GPE register enable masks based upon whether there are
144 * references (either wake or run) to this GPE
195 *
196 ******************************************************************************/
197
198ACPI_STATUS
199AcpiEvUpdateGpeEnableMasks (
145 *
146 ******************************************************************************/
147
148ACPI_STATUS
149AcpiEvUpdateGpeEnableMasks (
200 ACPI_GPE_EVENT_INFO *GpeEventInfo,
201 UINT8 Type)
150 ACPI_GPE_EVENT_INFO *GpeEventInfo)
202{
203 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
204 UINT8 RegisterBit;
205
206
207 ACPI_FUNCTION_TRACE (EvUpdateGpeEnableMasks);
208
209
210 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
211 if (!GpeRegisterInfo)
212 {
213 return_ACPI_STATUS (AE_NOT_EXIST);
214 }
215
216 RegisterBit = (UINT8)
217 (1 << (GpeEventInfo->GpeNumber - GpeRegisterInfo->BaseGpeNumber));
218
151{
152 ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
153 UINT8 RegisterBit;
154
155
156 ACPI_FUNCTION_TRACE (EvUpdateGpeEnableMasks);
157
158
159 GpeRegisterInfo = GpeEventInfo->RegisterInfo;
160 if (!GpeRegisterInfo)
161 {
162 return_ACPI_STATUS (AE_NOT_EXIST);
163 }
164
165 RegisterBit = (UINT8)
166 (1 << (GpeEventInfo->GpeNumber - GpeRegisterInfo->BaseGpeNumber));
167
219 /* 1) Disable case. Simply clear all enable bits */
168 /* Clear the wake/run bits up front */
220
169
221 if (Type == ACPI_GPE_DISABLE)
222 {
223 ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
224 ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
225 return_ACPI_STATUS (AE_OK);
226 }
170 ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
171 ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
227
172
228 /* 2) Enable case. Set/Clear the appropriate enable bits */
173 /* Set the mask bits only if there are references to this GPE */
229
174
230 switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
175 if (GpeEventInfo->RuntimeCount)
231 {
176 {
232 case ACPI_GPE_TYPE_WAKE:
233 ACPI_SET_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
234 ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
235 break;
177 ACPI_SET_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
178 }
236
179
237 case ACPI_GPE_TYPE_RUNTIME:
238 ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
239 ACPI_SET_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
240 break;
241
242 case ACPI_GPE_TYPE_WAKE_RUN:
243 ACPI_SET_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
244 ACPI_SET_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
245 break;
246
247 default:
248 return_ACPI_STATUS (AE_BAD_PARAMETER);
180 if (GpeEventInfo->WakeupCount)
181 {
182 ACPI_SET_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
249 }
250
251 return_ACPI_STATUS (AE_OK);
252}
253
254
255/*******************************************************************************
256 *
257 * FUNCTION: AcpiEvEnableGpe
258 *
259 * PARAMETERS: GpeEventInfo - GPE to enable
183 }
184
185 return_ACPI_STATUS (AE_OK);
186}
187
188
189/*******************************************************************************
190 *
191 * FUNCTION: AcpiEvEnableGpe
192 *
193 * PARAMETERS: GpeEventInfo - GPE to enable
260 * WriteToHardware - Enable now, or just mark data structs
261 * (WAKE GPEs should be deferred)
262 *
263 * RETURN: Status
264 *
194 *
195 * RETURN: Status
196 *
265 * DESCRIPTION: Enable a GPE based on the GPE type
197 * DESCRIPTION: Hardware-enable a GPE. Always enables the GPE, regardless
198 * of type or number of references.
266 *
199 *
200 * Note: The GPE lock should be already acquired when this function is called.
201 *
267 ******************************************************************************/
268
269ACPI_STATUS
270AcpiEvEnableGpe (
202 ******************************************************************************/
203
204ACPI_STATUS
205AcpiEvEnableGpe (
271 ACPI_GPE_EVENT_INFO *GpeEventInfo,
272 BOOLEAN WriteToHardware)
206 ACPI_GPE_EVENT_INFO *GpeEventInfo)
273{
274 ACPI_STATUS Status;
275
276
277 ACPI_FUNCTION_TRACE (EvEnableGpe);
278
279
207{
208 ACPI_STATUS Status;
209
210
211 ACPI_FUNCTION_TRACE (EvEnableGpe);
212
213
280 /* Make sure HW enable masks are updated */
214 /*
215 * We will only allow a GPE to be enabled if it has either an
216 * associated method (_Lxx/_Exx) or a handler. Otherwise, the
217 * GPE will be immediately disabled by AcpiEvGpeDispatch the
218 * first time it fires.
219 */
220 if (!(GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK))
221 {
222 return_ACPI_STATUS (AE_NO_HANDLER);
223 }
281
224
282 Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo, ACPI_GPE_ENABLE);
225 /* Ensure the HW enable masks are current */
226
227 Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
283 if (ACPI_FAILURE (Status))
284 {
285 return_ACPI_STATUS (Status);
286 }
287
228 if (ACPI_FAILURE (Status))
229 {
230 return_ACPI_STATUS (Status);
231 }
232
288 /* Mark wake-enabled or HW enable, or both */
233 /* Clear the GPE (of stale events) */
289
234
290 switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
235 Status = AcpiHwClearGpe (GpeEventInfo);
236 if (ACPI_FAILURE (Status))
291 {
237 {
292 case ACPI_GPE_TYPE_WAKE:
293
294 ACPI_SET_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
295 break;
296
297 case ACPI_GPE_TYPE_WAKE_RUN:
298
299 ACPI_SET_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
300
301 /*lint -fallthrough */
302
303 case ACPI_GPE_TYPE_RUNTIME:
304
305 ACPI_SET_BIT (GpeEventInfo->Flags, ACPI_GPE_RUN_ENABLED);
306
307 if (WriteToHardware)
308 {
309 /* Clear the GPE (of stale events), then enable it */
310
311 Status = AcpiHwClearGpe (GpeEventInfo);
312 if (ACPI_FAILURE (Status))
313 {
314 return_ACPI_STATUS (Status);
315 }
316
317 /* Enable the requested runtime GPE */
318
319 Status = AcpiHwWriteGpeEnableReg (GpeEventInfo);
320 }
321 break;
322
323 default:
324 return_ACPI_STATUS (AE_BAD_PARAMETER);
238 return_ACPI_STATUS (Status);
325 }
326
239 }
240
327 return_ACPI_STATUS (AE_OK);
241 /* Enable the requested GPE */
242
243 Status = AcpiHwWriteGpeEnableReg (GpeEventInfo);
244 return_ACPI_STATUS (Status);
328}
329
330
331/*******************************************************************************
332 *
333 * FUNCTION: AcpiEvDisableGpe
334 *
335 * PARAMETERS: GpeEventInfo - GPE to disable
336 *
337 * RETURN: Status
338 *
245}
246
247
248/*******************************************************************************
249 *
250 * FUNCTION: AcpiEvDisableGpe
251 *
252 * PARAMETERS: GpeEventInfo - GPE to disable
253 *
254 * RETURN: Status
255 *
339 * DESCRIPTION: Disable a GPE based on the GPE type
256 * DESCRIPTION: Hardware-disable a GPE. Always disables the requested GPE,
257 * regardless of the type or number of references.
340 *
258 *
259 * Note: The GPE lock should be already acquired when this function is called.
260 *
341 ******************************************************************************/
342
343ACPI_STATUS
344AcpiEvDisableGpe (
345 ACPI_GPE_EVENT_INFO *GpeEventInfo)
346{
347 ACPI_STATUS Status;
348
349
350 ACPI_FUNCTION_TRACE (EvDisableGpe);
351
352
353 /*
354 * Note: Always disable the GPE, even if we think that that it is already
355 * disabled. It is possible that the AML or some other code has enabled
356 * the GPE behind our back.
357 */
358
261 ******************************************************************************/
262
263ACPI_STATUS
264AcpiEvDisableGpe (
265 ACPI_GPE_EVENT_INFO *GpeEventInfo)
266{
267 ACPI_STATUS Status;
268
269
270 ACPI_FUNCTION_TRACE (EvDisableGpe);
271
272
273 /*
274 * Note: Always disable the GPE, even if we think that that it is already
275 * disabled. It is possible that the AML or some other code has enabled
276 * the GPE behind our back.
277 */
278
359 /* Make sure HW enable masks are updated */
279 /* Ensure the HW enable masks are current */
360
280
361 Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo, ACPI_GPE_DISABLE);
281 Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
362 if (ACPI_FAILURE (Status))
363 {
364 return_ACPI_STATUS (Status);
365 }
366
282 if (ACPI_FAILURE (Status))
283 {
284 return_ACPI_STATUS (Status);
285 }
286
367 /* Clear the appropriate enabled flags for this GPE */
368
369 switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
370 {
371 case ACPI_GPE_TYPE_WAKE:
372
373 ACPI_CLEAR_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
374 break;
375
376 case ACPI_GPE_TYPE_WAKE_RUN:
377
378 ACPI_CLEAR_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
379
380 /*lint -fallthrough */
381
382 case ACPI_GPE_TYPE_RUNTIME:
383
384 /* Disable the requested runtime GPE */
385
386 ACPI_CLEAR_BIT (GpeEventInfo->Flags, ACPI_GPE_RUN_ENABLED);
387 break;
388
389 default:
390 break;
391 }
392
393 /*
394 * Always H/W disable this GPE, even if we don't know the GPE type.
395 * Simply clear the enable bit for this particular GPE, but do not
396 * write out the current GPE enable mask since this may inadvertently
397 * enable GPEs too early. An example is a rogue GPE that has arrived
398 * during ACPICA initialization - possibly because AML or other code
399 * has enabled the GPE.
400 */
401 Status = AcpiHwLowDisableGpe (GpeEventInfo);
402 return_ACPI_STATUS (Status);
403}
404
405
406/*******************************************************************************
407 *
287 /*
288 * Always H/W disable this GPE, even if we don't know the GPE type.
289 * Simply clear the enable bit for this particular GPE, but do not
290 * write out the current GPE enable mask since this may inadvertently
291 * enable GPEs too early. An example is a rogue GPE that has arrived
292 * during ACPICA initialization - possibly because AML or other code
293 * has enabled the GPE.
294 */
295 Status = AcpiHwLowDisableGpe (GpeEventInfo);
296 return_ACPI_STATUS (Status);
297}
298
299
300/*******************************************************************************
301 *
302 * FUNCTION: AcpiEvLowGetGpeInfo
303 *
304 * PARAMETERS: GpeNumber - Raw GPE number
305 * GpeBlock - A GPE info block
306 *
307 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE (The GpeNumber
308 * is not within the specified GPE block)
309 *
310 * DESCRIPTION: Returns the EventInfo struct associated with this GPE. This is
311 * the low-level implementation of EvGetGpeEventInfo.
312 *
313 ******************************************************************************/
314
315ACPI_GPE_EVENT_INFO *
316AcpiEvLowGetGpeInfo (
317 UINT32 GpeNumber,
318 ACPI_GPE_BLOCK_INFO *GpeBlock)
319{
320 UINT32 GpeIndex;
321
322
323 /*
324 * Validate that the GpeNumber is within the specified GpeBlock.
325 * (Two steps)
326 */
327 if (!GpeBlock ||
328 (GpeNumber < GpeBlock->BlockBaseNumber))
329 {
330 return (NULL);
331 }
332
333 GpeIndex = GpeNumber - GpeBlock->BlockBaseNumber;
334 if (GpeIndex >= GpeBlock->GpeCount)
335 {
336 return (NULL);
337 }
338
339 return (&GpeBlock->EventInfo[GpeIndex]);
340}
341
342
343/*******************************************************************************
344 *
408 * FUNCTION: AcpiEvGetGpeEventInfo
409 *
410 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
411 * GpeNumber - Raw GPE number
412 *
413 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE
414 *
415 * DESCRIPTION: Returns the EventInfo struct associated with this GPE.

--- 5 unchanged lines hidden (view full) ---

421 ******************************************************************************/
422
423ACPI_GPE_EVENT_INFO *
424AcpiEvGetGpeEventInfo (
425 ACPI_HANDLE GpeDevice,
426 UINT32 GpeNumber)
427{
428 ACPI_OPERAND_OBJECT *ObjDesc;
345 * FUNCTION: AcpiEvGetGpeEventInfo
346 *
347 * PARAMETERS: GpeDevice - Device node. NULL for GPE0/GPE1
348 * GpeNumber - Raw GPE number
349 *
350 * RETURN: A GPE EventInfo struct. NULL if not a valid GPE
351 *
352 * DESCRIPTION: Returns the EventInfo struct associated with this GPE.

--- 5 unchanged lines hidden (view full) ---

358 ******************************************************************************/
359
360ACPI_GPE_EVENT_INFO *
361AcpiEvGetGpeEventInfo (
362 ACPI_HANDLE GpeDevice,
363 UINT32 GpeNumber)
364{
365 ACPI_OPERAND_OBJECT *ObjDesc;
429 ACPI_GPE_BLOCK_INFO *GpeBlock;
366 ACPI_GPE_EVENT_INFO *GpeInfo;
430 UINT32 i;
431
432
433 ACPI_FUNCTION_ENTRY ();
434
435
436 /* A NULL GpeBlock means use the FADT-defined GPE block(s) */
437
438 if (!GpeDevice)
439 {
440 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
441
442 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++)
443 {
367 UINT32 i;
368
369
370 ACPI_FUNCTION_ENTRY ();
371
372
373 /* A NULL GpeBlock means use the FADT-defined GPE block(s) */
374
375 if (!GpeDevice)
376 {
377 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
378
379 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++)
380 {
444 GpeBlock = AcpiGbl_GpeFadtBlocks[i];
445 if (GpeBlock)
381 GpeInfo = AcpiEvLowGetGpeInfo (GpeNumber,
382 AcpiGbl_GpeFadtBlocks[i]);
383 if (GpeInfo)
446 {
384 {
447 if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
448 (GpeNumber < GpeBlock->BlockBaseNumber +
449 (GpeBlock->RegisterCount * 8)))
450 {
451 return (&GpeBlock->EventInfo[GpeNumber -
452 GpeBlock->BlockBaseNumber]);
453 }
385 return (GpeInfo);
454 }
455 }
456
457 /* The GpeNumber was not in the range of either FADT GPE block */
458
459 return (NULL);
460 }
461
462 /* A Non-NULL GpeDevice means this is a GPE Block Device */
463
464 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) GpeDevice);
465 if (!ObjDesc ||
466 !ObjDesc->Device.GpeBlock)
467 {
468 return (NULL);
469 }
470
386 }
387 }
388
389 /* The GpeNumber was not in the range of either FADT GPE block */
390
391 return (NULL);
392 }
393
394 /* A Non-NULL GpeDevice means this is a GPE Block Device */
395
396 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) GpeDevice);
397 if (!ObjDesc ||
398 !ObjDesc->Device.GpeBlock)
399 {
400 return (NULL);
401 }
402
471 GpeBlock = ObjDesc->Device.GpeBlock;
472
473 if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
474 (GpeNumber < GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8)))
475 {
476 return (&GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber]);
477 }
478
479 return (NULL);
403 return (AcpiEvLowGetGpeInfo (GpeNumber, ObjDesc->Device.GpeBlock));
480}
481
482
483/*******************************************************************************
484 *
485 * FUNCTION: AcpiEvGpeDetect
486 *
487 * PARAMETERS: GpeXruptList - Interrupt block for this interrupt.

--- 161 unchanged lines hidden (view full) ---

649 /* Must revalidate the GpeNumber/GpeBlock */
650
651 if (!AcpiEvValidGpeEvent (GpeEventInfo))
652 {
653 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
654 return_VOID;
655 }
656
404}
405
406
407/*******************************************************************************
408 *
409 * FUNCTION: AcpiEvGpeDetect
410 *
411 * PARAMETERS: GpeXruptList - Interrupt block for this interrupt.

--- 161 unchanged lines hidden (view full) ---

573 /* Must revalidate the GpeNumber/GpeBlock */
574
575 if (!AcpiEvValidGpeEvent (GpeEventInfo))
576 {
577 Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
578 return_VOID;
579 }
580
657 /* Set the GPE flags for return to enabled state */
581 /* Update the GPE register masks for return to enabled state */
658
582
659 (void) AcpiEvEnableGpe (GpeEventInfo, FALSE);
583 (void) AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
660
661 /*
662 * Take a snapshot of the GPE info for this level - we copy the info to
663 * prevent a race condition with RemoveHandler/RemoveBlock.
664 */
665 ACPI_MEMCPY (LocalGpeEventInfo, GpeEventInfo,
666 sizeof (ACPI_GPE_EVENT_INFO));
667

--- 199 unchanged lines hidden (view full) ---

867 ACPI_EXCEPTION ((AE_INFO, Status,
868 "Unable to queue handler for GPE[0x%2X] - event disabled",
869 GpeNumber));
870 }
871 break;
872
873 default:
874
584
585 /*
586 * Take a snapshot of the GPE info for this level - we copy the info to
587 * prevent a race condition with RemoveHandler/RemoveBlock.
588 */
589 ACPI_MEMCPY (LocalGpeEventInfo, GpeEventInfo,
590 sizeof (ACPI_GPE_EVENT_INFO));
591

--- 199 unchanged lines hidden (view full) ---

791 ACPI_EXCEPTION ((AE_INFO, Status,
792 "Unable to queue handler for GPE[0x%2X] - event disabled",
793 GpeNumber));
794 }
795 break;
796
797 default:
798
875 /* No handler or method to run! */
876
799 /*
800 * No handler or method to run!
801 * 03/2010: This case should no longer be possible. We will not allow
802 * a GPE to be enabled if it has no handler or method.
803 */
877 ACPI_ERROR ((AE_INFO,
878 "No handler or method for GPE[0x%2X], disabling event",
879 GpeNumber));
880
881 /*
804 ACPI_ERROR ((AE_INFO,
805 "No handler or method for GPE[0x%2X], disabling event",
806 GpeNumber));
807
808 /*
882 * Disable the GPE. The GPE will remain disabled until the ACPICA
883 * Core Subsystem is restarted, or a handler is installed.
809 * Disable the GPE. The GPE will remain disabled a handler
810 * is installed or ACPICA is restarted.
884 */
885 Status = AcpiEvDisableGpe (GpeEventInfo);
886 if (ACPI_FAILURE (Status))
887 {
888 ACPI_EXCEPTION ((AE_INFO, Status,
889 "Unable to disable GPE[0x%2X]", GpeNumber));
890 return_UINT32 (ACPI_INTERRUPT_NOT_HANDLED);
891 }
892 break;
893 }
894
895 return_UINT32 (ACPI_INTERRUPT_HANDLED);
896}
897
811 */
812 Status = AcpiEvDisableGpe (GpeEventInfo);
813 if (ACPI_FAILURE (Status))
814 {
815 ACPI_EXCEPTION ((AE_INFO, Status,
816 "Unable to disable GPE[0x%2X]", GpeNumber));
817 return_UINT32 (ACPI_INTERRUPT_NOT_HANDLED);
818 }
819 break;
820 }
821
822 return_UINT32 (ACPI_INTERRUPT_HANDLED);
823}
824