[PATCH] cfq-iosched: fix crash in do_div()
[linux-2.6.git] / drivers / acpi / events / evxfevnt.c
1 /******************************************************************************
2  *
3  * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2006, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <linux/module.h>
45
46 #include <acpi/acpi.h>
47 #include <acpi/acevents.h>
48 #include <acpi/acnamesp.h>
49
50 #define _COMPONENT          ACPI_EVENTS
51 ACPI_MODULE_NAME("evxfevnt")
52
53 /*******************************************************************************
54  *
55  * FUNCTION:    acpi_enable
56  *
57  * PARAMETERS:  None
58  *
59  * RETURN:      Status
60  *
61  * DESCRIPTION: Transfers the system into ACPI mode.
62  *
63  ******************************************************************************/
64 acpi_status acpi_enable(void)
65 {
66         acpi_status status = AE_OK;
67
68         ACPI_FUNCTION_TRACE("acpi_enable");
69
70         /* Make sure we have the FADT */
71
72         if (!acpi_gbl_FADT) {
73                 ACPI_WARNING((AE_INFO, "No FADT information present!"));
74                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
75         }
76
77         if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
78                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
79                                   "System is already in ACPI mode\n"));
80         } else {
81                 /* Transition to ACPI mode */
82
83                 status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
84                 if (ACPI_FAILURE(status)) {
85                         ACPI_ERROR((AE_INFO,
86                                     "Could not transition to ACPI mode"));
87                         return_ACPI_STATUS(status);
88                 }
89
90                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
91                                   "Transition to ACPI mode successful\n"));
92         }
93
94         return_ACPI_STATUS(status);
95 }
96
97 /*******************************************************************************
98  *
99  * FUNCTION:    acpi_disable
100  *
101  * PARAMETERS:  None
102  *
103  * RETURN:      Status
104  *
105  * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
106  *
107  ******************************************************************************/
108
109 acpi_status acpi_disable(void)
110 {
111         acpi_status status = AE_OK;
112
113         ACPI_FUNCTION_TRACE("acpi_disable");
114
115         if (!acpi_gbl_FADT) {
116                 ACPI_WARNING((AE_INFO, "No FADT information present!"));
117                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
118         }
119
120         if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) {
121                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
122                                   "System is already in legacy (non-ACPI) mode\n"));
123         } else {
124                 /* Transition to LEGACY mode */
125
126                 status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY);
127
128                 if (ACPI_FAILURE(status)) {
129                         ACPI_ERROR((AE_INFO,
130                                     "Could not exit ACPI mode to legacy mode"));
131                         return_ACPI_STATUS(status);
132                 }
133
134                 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI mode disabled\n"));
135         }
136
137         return_ACPI_STATUS(status);
138 }
139
140 /*******************************************************************************
141  *
142  * FUNCTION:    acpi_enable_event
143  *
144  * PARAMETERS:  Event           - The fixed eventto be enabled
145  *              Flags           - Reserved
146  *
147  * RETURN:      Status
148  *
149  * DESCRIPTION: Enable an ACPI event (fixed)
150  *
151  ******************************************************************************/
152
153 acpi_status acpi_enable_event(u32 event, u32 flags)
154 {
155         acpi_status status = AE_OK;
156         u32 value;
157
158         ACPI_FUNCTION_TRACE("acpi_enable_event");
159
160         /* Decode the Fixed Event */
161
162         if (event > ACPI_EVENT_MAX) {
163                 return_ACPI_STATUS(AE_BAD_PARAMETER);
164         }
165
166         /*
167          * Enable the requested fixed event (by writing a one to the
168          * enable register bit)
169          */
170         status =
171             acpi_set_register(acpi_gbl_fixed_event_info[event].
172                               enable_register_id, 1, ACPI_MTX_LOCK);
173         if (ACPI_FAILURE(status)) {
174                 return_ACPI_STATUS(status);
175         }
176
177         /* Make sure that the hardware responded */
178
179         status =
180             acpi_get_register(acpi_gbl_fixed_event_info[event].
181                               enable_register_id, &value, ACPI_MTX_LOCK);
182         if (ACPI_FAILURE(status)) {
183                 return_ACPI_STATUS(status);
184         }
185
186         if (value != 1) {
187                 ACPI_ERROR((AE_INFO,
188                             "Could not enable %s event",
189                             acpi_ut_get_event_name(event)));
190                 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
191         }
192
193         return_ACPI_STATUS(status);
194 }
195
196 EXPORT_SYMBOL(acpi_enable_event);
197
198 /*******************************************************************************
199  *
200  * FUNCTION:    acpi_set_gpe_type
201  *
202  * PARAMETERS:  gpe_device      - Parent GPE Device
203  *              gpe_number      - GPE level within the GPE block
204  *              Type            - New GPE type
205  *
206  * RETURN:      Status
207  *
208  * DESCRIPTION: Set the type of an individual GPE
209  *
210  ******************************************************************************/
211
212 acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
213 {
214         acpi_status status = AE_OK;
215         struct acpi_gpe_event_info *gpe_event_info;
216
217         ACPI_FUNCTION_TRACE("acpi_set_gpe_type");
218
219         /* Ensure that we have a valid GPE number */
220
221         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
222         if (!gpe_event_info) {
223                 status = AE_BAD_PARAMETER;
224                 goto unlock_and_exit;
225         }
226
227         if ((gpe_event_info->flags & ACPI_GPE_TYPE_MASK) == type) {
228                 return_ACPI_STATUS(AE_OK);
229         }
230
231         /* Set the new type (will disable GPE if currently enabled) */
232
233         status = acpi_ev_set_gpe_type(gpe_event_info, type);
234
235       unlock_and_exit:
236         return_ACPI_STATUS(status);
237 }
238
239 EXPORT_SYMBOL(acpi_set_gpe_type);
240
241 /*******************************************************************************
242  *
243  * FUNCTION:    acpi_enable_gpe
244  *
245  * PARAMETERS:  gpe_device      - Parent GPE Device
246  *              gpe_number      - GPE level within the GPE block
247  *              Flags           - Just enable, or also wake enable?
248  *                                Called from ISR or not
249  *
250  * RETURN:      Status
251  *
252  * DESCRIPTION: Enable an ACPI event (general purpose)
253  *
254  ******************************************************************************/
255
256 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
257 {
258         acpi_status status = AE_OK;
259         struct acpi_gpe_event_info *gpe_event_info;
260
261         ACPI_FUNCTION_TRACE("acpi_enable_gpe");
262
263         /* Use semaphore lock if not executing at interrupt level */
264
265         if (flags & ACPI_NOT_ISR) {
266                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
267                 if (ACPI_FAILURE(status)) {
268                         return_ACPI_STATUS(status);
269                 }
270         }
271
272         /* Ensure that we have a valid GPE number */
273
274         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
275         if (!gpe_event_info) {
276                 status = AE_BAD_PARAMETER;
277                 goto unlock_and_exit;
278         }
279
280         /* Perform the enable */
281
282         status = acpi_ev_enable_gpe(gpe_event_info, TRUE);
283
284       unlock_and_exit:
285         if (flags & ACPI_NOT_ISR) {
286                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
287         }
288         return_ACPI_STATUS(status);
289 }
290
291 EXPORT_SYMBOL(acpi_enable_gpe);
292
293 /*******************************************************************************
294  *
295  * FUNCTION:    acpi_disable_gpe
296  *
297  * PARAMETERS:  gpe_device      - Parent GPE Device
298  *              gpe_number      - GPE level within the GPE block
299  *              Flags           - Just disable, or also wake disable?
300  *                                Called from ISR or not
301  *
302  * RETURN:      Status
303  *
304  * DESCRIPTION: Disable an ACPI event (general purpose)
305  *
306  ******************************************************************************/
307
308 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
309 {
310         acpi_status status = AE_OK;
311         struct acpi_gpe_event_info *gpe_event_info;
312
313         ACPI_FUNCTION_TRACE("acpi_disable_gpe");
314
315         /* Use semaphore lock if not executing at interrupt level */
316
317         if (flags & ACPI_NOT_ISR) {
318                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
319                 if (ACPI_FAILURE(status)) {
320                         return_ACPI_STATUS(status);
321                 }
322         }
323
324         /* Ensure that we have a valid GPE number */
325
326         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
327         if (!gpe_event_info) {
328                 status = AE_BAD_PARAMETER;
329                 goto unlock_and_exit;
330         }
331
332         status = acpi_ev_disable_gpe(gpe_event_info);
333
334       unlock_and_exit:
335         if (flags & ACPI_NOT_ISR) {
336                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
337         }
338         return_ACPI_STATUS(status);
339 }
340
341 /*******************************************************************************
342  *
343  * FUNCTION:    acpi_disable_event
344  *
345  * PARAMETERS:  Event           - The fixed eventto be enabled
346  *              Flags           - Reserved
347  *
348  * RETURN:      Status
349  *
350  * DESCRIPTION: Disable an ACPI event (fixed)
351  *
352  ******************************************************************************/
353
354 acpi_status acpi_disable_event(u32 event, u32 flags)
355 {
356         acpi_status status = AE_OK;
357         u32 value;
358
359         ACPI_FUNCTION_TRACE("acpi_disable_event");
360
361         /* Decode the Fixed Event */
362
363         if (event > ACPI_EVENT_MAX) {
364                 return_ACPI_STATUS(AE_BAD_PARAMETER);
365         }
366
367         /*
368          * Disable the requested fixed event (by writing a zero to the
369          * enable register bit)
370          */
371         status =
372             acpi_set_register(acpi_gbl_fixed_event_info[event].
373                               enable_register_id, 0, ACPI_MTX_LOCK);
374         if (ACPI_FAILURE(status)) {
375                 return_ACPI_STATUS(status);
376         }
377
378         status =
379             acpi_get_register(acpi_gbl_fixed_event_info[event].
380                               enable_register_id, &value, ACPI_MTX_LOCK);
381         if (ACPI_FAILURE(status)) {
382                 return_ACPI_STATUS(status);
383         }
384
385         if (value != 0) {
386                 ACPI_ERROR((AE_INFO,
387                             "Could not disable %s events",
388                             acpi_ut_get_event_name(event)));
389                 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
390         }
391
392         return_ACPI_STATUS(status);
393 }
394
395 EXPORT_SYMBOL(acpi_disable_event);
396
397 /*******************************************************************************
398  *
399  * FUNCTION:    acpi_clear_event
400  *
401  * PARAMETERS:  Event           - The fixed event to be cleared
402  *
403  * RETURN:      Status
404  *
405  * DESCRIPTION: Clear an ACPI event (fixed)
406  *
407  ******************************************************************************/
408
409 acpi_status acpi_clear_event(u32 event)
410 {
411         acpi_status status = AE_OK;
412
413         ACPI_FUNCTION_TRACE("acpi_clear_event");
414
415         /* Decode the Fixed Event */
416
417         if (event > ACPI_EVENT_MAX) {
418                 return_ACPI_STATUS(AE_BAD_PARAMETER);
419         }
420
421         /*
422          * Clear the requested fixed event (By writing a one to the
423          * status register bit)
424          */
425         status =
426             acpi_set_register(acpi_gbl_fixed_event_info[event].
427                               status_register_id, 1, ACPI_MTX_LOCK);
428
429         return_ACPI_STATUS(status);
430 }
431
432 EXPORT_SYMBOL(acpi_clear_event);
433
434 /*******************************************************************************
435  *
436  * FUNCTION:    acpi_clear_gpe
437  *
438  * PARAMETERS:  gpe_device      - Parent GPE Device
439  *              gpe_number      - GPE level within the GPE block
440  *              Flags           - Called from an ISR or not
441  *
442  * RETURN:      Status
443  *
444  * DESCRIPTION: Clear an ACPI event (general purpose)
445  *
446  ******************************************************************************/
447
448 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
449 {
450         acpi_status status = AE_OK;
451         struct acpi_gpe_event_info *gpe_event_info;
452
453         ACPI_FUNCTION_TRACE("acpi_clear_gpe");
454
455         /* Use semaphore lock if not executing at interrupt level */
456
457         if (flags & ACPI_NOT_ISR) {
458                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
459                 if (ACPI_FAILURE(status)) {
460                         return_ACPI_STATUS(status);
461                 }
462         }
463
464         /* Ensure that we have a valid GPE number */
465
466         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
467         if (!gpe_event_info) {
468                 status = AE_BAD_PARAMETER;
469                 goto unlock_and_exit;
470         }
471
472         status = acpi_hw_clear_gpe(gpe_event_info);
473
474       unlock_and_exit:
475         if (flags & ACPI_NOT_ISR) {
476                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
477         }
478         return_ACPI_STATUS(status);
479 }
480
481 #ifdef ACPI_FUTURE_USAGE
482 /*******************************************************************************
483  *
484  * FUNCTION:    acpi_get_event_status
485  *
486  * PARAMETERS:  Event           - The fixed event
487  *              event_status    - Where the current status of the event will
488  *                                be returned
489  *
490  * RETURN:      Status
491  *
492  * DESCRIPTION: Obtains and returns the current status of the event
493  *
494  ******************************************************************************/
495
496 acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
497 {
498         acpi_status status = AE_OK;
499
500         ACPI_FUNCTION_TRACE("acpi_get_event_status");
501
502         if (!event_status) {
503                 return_ACPI_STATUS(AE_BAD_PARAMETER);
504         }
505
506         /* Decode the Fixed Event */
507
508         if (event > ACPI_EVENT_MAX) {
509                 return_ACPI_STATUS(AE_BAD_PARAMETER);
510         }
511
512         /* Get the status of the requested fixed event */
513
514         status =
515             acpi_get_register(acpi_gbl_fixed_event_info[event].
516                               status_register_id, event_status, ACPI_MTX_LOCK);
517
518         return_ACPI_STATUS(status);
519 }
520
521 /*******************************************************************************
522  *
523  * FUNCTION:    acpi_get_gpe_status
524  *
525  * PARAMETERS:  gpe_device      - Parent GPE Device
526  *              gpe_number      - GPE level within the GPE block
527  *              Flags           - Called from an ISR or not
528  *              event_status    - Where the current status of the event will
529  *                                be returned
530  *
531  * RETURN:      Status
532  *
533  * DESCRIPTION: Get status of an event (general purpose)
534  *
535  ******************************************************************************/
536
537 acpi_status
538 acpi_get_gpe_status(acpi_handle gpe_device,
539                     u32 gpe_number, u32 flags, acpi_event_status * event_status)
540 {
541         acpi_status status = AE_OK;
542         struct acpi_gpe_event_info *gpe_event_info;
543
544         ACPI_FUNCTION_TRACE("acpi_get_gpe_status");
545
546         /* Use semaphore lock if not executing at interrupt level */
547
548         if (flags & ACPI_NOT_ISR) {
549                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
550                 if (ACPI_FAILURE(status)) {
551                         return_ACPI_STATUS(status);
552                 }
553         }
554
555         /* Ensure that we have a valid GPE number */
556
557         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
558         if (!gpe_event_info) {
559                 status = AE_BAD_PARAMETER;
560                 goto unlock_and_exit;
561         }
562
563         /* Obtain status on the requested GPE number */
564
565         status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
566
567       unlock_and_exit:
568         if (flags & ACPI_NOT_ISR) {
569                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
570         }
571         return_ACPI_STATUS(status);
572 }
573 #endif                          /*  ACPI_FUTURE_USAGE  */
574
575 /*******************************************************************************
576  *
577  * FUNCTION:    acpi_install_gpe_block
578  *
579  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
580  *              gpe_block_address   - Address and space_iD
581  *              register_count      - Number of GPE register pairs in the block
582  *              interrupt_number    - H/W interrupt for the block
583  *
584  * RETURN:      Status
585  *
586  * DESCRIPTION: Create and Install a block of GPE registers
587  *
588  ******************************************************************************/
589
590 acpi_status
591 acpi_install_gpe_block(acpi_handle gpe_device,
592                        struct acpi_generic_address *gpe_block_address,
593                        u32 register_count, u32 interrupt_number)
594 {
595         acpi_status status;
596         union acpi_operand_object *obj_desc;
597         struct acpi_namespace_node *node;
598         struct acpi_gpe_block_info *gpe_block;
599
600         ACPI_FUNCTION_TRACE("acpi_install_gpe_block");
601
602         if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
603                 return_ACPI_STATUS(AE_BAD_PARAMETER);
604         }
605
606         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
607         if (ACPI_FAILURE(status)) {
608                 return (status);
609         }
610
611         node = acpi_ns_map_handle_to_node(gpe_device);
612         if (!node) {
613                 status = AE_BAD_PARAMETER;
614                 goto unlock_and_exit;
615         }
616
617         /*
618          * For user-installed GPE Block Devices, the gpe_block_base_number
619          * is always zero
620          */
621         status =
622             acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
623                                      interrupt_number, &gpe_block);
624         if (ACPI_FAILURE(status)) {
625                 goto unlock_and_exit;
626         }
627
628         /* Run the _PRW methods and enable the GPEs */
629
630         status = acpi_ev_initialize_gpe_block(node, gpe_block);
631         if (ACPI_FAILURE(status)) {
632                 goto unlock_and_exit;
633         }
634
635         /* Get the device_object attached to the node */
636
637         obj_desc = acpi_ns_get_attached_object(node);
638         if (!obj_desc) {
639                 /* No object, create a new one */
640
641                 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
642                 if (!obj_desc) {
643                         status = AE_NO_MEMORY;
644                         goto unlock_and_exit;
645                 }
646
647                 status =
648                     acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
649
650                 /* Remove local reference to the object */
651
652                 acpi_ut_remove_reference(obj_desc);
653
654                 if (ACPI_FAILURE(status)) {
655                         goto unlock_and_exit;
656                 }
657         }
658
659         /* Install the GPE block in the device_object */
660
661         obj_desc->device.gpe_block = gpe_block;
662
663       unlock_and_exit:
664         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
665         return_ACPI_STATUS(status);
666 }
667
668 EXPORT_SYMBOL(acpi_install_gpe_block);
669
670 /*******************************************************************************
671  *
672  * FUNCTION:    acpi_remove_gpe_block
673  *
674  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
675  *
676  * RETURN:      Status
677  *
678  * DESCRIPTION: Remove a previously installed block of GPE registers
679  *
680  ******************************************************************************/
681
682 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
683 {
684         union acpi_operand_object *obj_desc;
685         acpi_status status;
686         struct acpi_namespace_node *node;
687
688         ACPI_FUNCTION_TRACE("acpi_remove_gpe_block");
689
690         if (!gpe_device) {
691                 return_ACPI_STATUS(AE_BAD_PARAMETER);
692         }
693
694         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
695         if (ACPI_FAILURE(status)) {
696                 return (status);
697         }
698
699         node = acpi_ns_map_handle_to_node(gpe_device);
700         if (!node) {
701                 status = AE_BAD_PARAMETER;
702                 goto unlock_and_exit;
703         }
704
705         /* Get the device_object attached to the node */
706
707         obj_desc = acpi_ns_get_attached_object(node);
708         if (!obj_desc || !obj_desc->device.gpe_block) {
709                 return_ACPI_STATUS(AE_NULL_OBJECT);
710         }
711
712         /* Delete the GPE block (but not the device_object) */
713
714         status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
715         if (ACPI_SUCCESS(status)) {
716                 obj_desc->device.gpe_block = NULL;
717         }
718
719       unlock_and_exit:
720         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
721         return_ACPI_STATUS(status);
722 }
723
724 EXPORT_SYMBOL(acpi_remove_gpe_block);