Pull acpica into release branch
[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 <acpi/acpi.h>
45 #include <acpi/acevents.h>
46 #include <acpi/acnamesp.h>
47
48 #define _COMPONENT          ACPI_EVENTS
49 ACPI_MODULE_NAME("evxfevnt")
50
51 /*******************************************************************************
52  *
53  * FUNCTION:    acpi_enable
54  *
55  * PARAMETERS:  None
56  *
57  * RETURN:      Status
58  *
59  * DESCRIPTION: Transfers the system into ACPI mode.
60  *
61  ******************************************************************************/
62 acpi_status acpi_enable(void)
63 {
64         acpi_status status = AE_OK;
65
66         ACPI_FUNCTION_TRACE(acpi_enable);
67
68         /* Make sure we have the FADT */
69
70         if (!acpi_gbl_FADT) {
71                 ACPI_WARNING((AE_INFO, "No FADT information present!"));
72                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
73         }
74
75         if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
76                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
77                                   "System is already in ACPI mode\n"));
78         } else {
79                 /* Transition to ACPI mode */
80
81                 status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
82                 if (ACPI_FAILURE(status)) {
83                         ACPI_ERROR((AE_INFO,
84                                     "Could not transition to ACPI mode"));
85                         return_ACPI_STATUS(status);
86                 }
87
88                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
89                                   "Transition to ACPI mode successful\n"));
90         }
91
92         return_ACPI_STATUS(status);
93 }
94
95 ACPI_EXPORT_SYMBOL(acpi_enable)
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 acpi_status acpi_disable(void)
109 {
110         acpi_status status = AE_OK;
111
112         ACPI_FUNCTION_TRACE(acpi_disable);
113
114         if (!acpi_gbl_FADT) {
115                 ACPI_WARNING((AE_INFO, "No FADT information present!"));
116                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
117         }
118
119         if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) {
120                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
121                                   "System is already in legacy (non-ACPI) mode\n"));
122         } else {
123                 /* Transition to LEGACY mode */
124
125                 status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY);
126
127                 if (ACPI_FAILURE(status)) {
128                         ACPI_ERROR((AE_INFO,
129                                     "Could not exit ACPI mode to legacy mode"));
130                         return_ACPI_STATUS(status);
131                 }
132
133                 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI mode disabled\n"));
134         }
135
136         return_ACPI_STATUS(status);
137 }
138
139 ACPI_EXPORT_SYMBOL(acpi_disable)
140
141 /*******************************************************************************
142  *
143  * FUNCTION:    acpi_enable_event
144  *
145  * PARAMETERS:  Event           - The fixed eventto be enabled
146  *              Flags           - Reserved
147  *
148  * RETURN:      Status
149  *
150  * DESCRIPTION: Enable an ACPI event (fixed)
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 ACPI_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 acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
212 {
213         acpi_status status = AE_OK;
214         struct acpi_gpe_event_info *gpe_event_info;
215
216         ACPI_FUNCTION_TRACE(acpi_set_gpe_type);
217
218         /* Ensure that we have a valid GPE number */
219
220         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
221         if (!gpe_event_info) {
222                 status = AE_BAD_PARAMETER;
223                 goto unlock_and_exit;
224         }
225
226         if ((gpe_event_info->flags & ACPI_GPE_TYPE_MASK) == type) {
227                 return_ACPI_STATUS(AE_OK);
228         }
229
230         /* Set the new type (will disable GPE if currently enabled) */
231
232         status = acpi_ev_set_gpe_type(gpe_event_info, type);
233
234       unlock_and_exit:
235         return_ACPI_STATUS(status);
236 }
237
238 ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
239
240 /*******************************************************************************
241  *
242  * FUNCTION:    acpi_enable_gpe
243  *
244  * PARAMETERS:  gpe_device      - Parent GPE Device
245  *              gpe_number      - GPE level within the GPE block
246  *              Flags           - Just enable, or also wake enable?
247  *                                Called from ISR or not
248  *
249  * RETURN:      Status
250  *
251  * DESCRIPTION: Enable an ACPI event (general purpose)
252  *
253  ******************************************************************************/
254 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
255 {
256         acpi_status status = AE_OK;
257         struct acpi_gpe_event_info *gpe_event_info;
258
259         ACPI_FUNCTION_TRACE(acpi_enable_gpe);
260
261         /* Use semaphore lock if not executing at interrupt level */
262
263         if (flags & ACPI_NOT_ISR) {
264                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
265                 if (ACPI_FAILURE(status)) {
266                         return_ACPI_STATUS(status);
267                 }
268         }
269
270         /* Ensure that we have a valid GPE number */
271
272         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
273         if (!gpe_event_info) {
274                 status = AE_BAD_PARAMETER;
275                 goto unlock_and_exit;
276         }
277
278         /* Perform the enable */
279
280         status = acpi_ev_enable_gpe(gpe_event_info, TRUE);
281
282       unlock_and_exit:
283         if (flags & ACPI_NOT_ISR) {
284                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
285         }
286         return_ACPI_STATUS(status);
287 }
288
289 ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
290
291 /*******************************************************************************
292  *
293  * FUNCTION:    acpi_disable_gpe
294  *
295  * PARAMETERS:  gpe_device      - Parent GPE Device
296  *              gpe_number      - GPE level within the GPE block
297  *              Flags           - Just disable, or also wake disable?
298  *                                Called from ISR or not
299  *
300  * RETURN:      Status
301  *
302  * DESCRIPTION: Disable an ACPI event (general purpose)
303  *
304  ******************************************************************************/
305 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
306 {
307         acpi_status status = AE_OK;
308         struct acpi_gpe_event_info *gpe_event_info;
309
310         ACPI_FUNCTION_TRACE(acpi_disable_gpe);
311
312         /* Use semaphore lock if not executing at interrupt level */
313
314         if (flags & ACPI_NOT_ISR) {
315                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
316                 if (ACPI_FAILURE(status)) {
317                         return_ACPI_STATUS(status);
318                 }
319         }
320
321         /* Ensure that we have a valid GPE number */
322
323         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
324         if (!gpe_event_info) {
325                 status = AE_BAD_PARAMETER;
326                 goto unlock_and_exit;
327         }
328
329         status = acpi_ev_disable_gpe(gpe_event_info);
330
331       unlock_and_exit:
332         if (flags & ACPI_NOT_ISR) {
333                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
334         }
335         return_ACPI_STATUS(status);
336 }
337
338 ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
339
340 /*******************************************************************************
341  *
342  * FUNCTION:    acpi_disable_event
343  *
344  * PARAMETERS:  Event           - The fixed eventto be enabled
345  *              Flags           - Reserved
346  *
347  * RETURN:      Status
348  *
349  * DESCRIPTION: Disable an ACPI event (fixed)
350  *
351  ******************************************************************************/
352 acpi_status acpi_disable_event(u32 event, u32 flags)
353 {
354         acpi_status status = AE_OK;
355         u32 value;
356
357         ACPI_FUNCTION_TRACE(acpi_disable_event);
358
359         /* Decode the Fixed Event */
360
361         if (event > ACPI_EVENT_MAX) {
362                 return_ACPI_STATUS(AE_BAD_PARAMETER);
363         }
364
365         /*
366          * Disable the requested fixed event (by writing a zero to the
367          * enable register bit)
368          */
369         status =
370             acpi_set_register(acpi_gbl_fixed_event_info[event].
371                               enable_register_id, 0, ACPI_MTX_LOCK);
372         if (ACPI_FAILURE(status)) {
373                 return_ACPI_STATUS(status);
374         }
375
376         status =
377             acpi_get_register(acpi_gbl_fixed_event_info[event].
378                               enable_register_id, &value, ACPI_MTX_LOCK);
379         if (ACPI_FAILURE(status)) {
380                 return_ACPI_STATUS(status);
381         }
382
383         if (value != 0) {
384                 ACPI_ERROR((AE_INFO,
385                             "Could not disable %s events",
386                             acpi_ut_get_event_name(event)));
387                 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
388         }
389
390         return_ACPI_STATUS(status);
391 }
392
393 ACPI_EXPORT_SYMBOL(acpi_disable_event)
394
395 /*******************************************************************************
396  *
397  * FUNCTION:    acpi_clear_event
398  *
399  * PARAMETERS:  Event           - The fixed event to be cleared
400  *
401  * RETURN:      Status
402  *
403  * DESCRIPTION: Clear an ACPI event (fixed)
404  *
405  ******************************************************************************/
406 acpi_status acpi_clear_event(u32 event)
407 {
408         acpi_status status = AE_OK;
409
410         ACPI_FUNCTION_TRACE(acpi_clear_event);
411
412         /* Decode the Fixed Event */
413
414         if (event > ACPI_EVENT_MAX) {
415                 return_ACPI_STATUS(AE_BAD_PARAMETER);
416         }
417
418         /*
419          * Clear the requested fixed event (By writing a one to the
420          * status register bit)
421          */
422         status =
423             acpi_set_register(acpi_gbl_fixed_event_info[event].
424                               status_register_id, 1, ACPI_MTX_LOCK);
425
426         return_ACPI_STATUS(status);
427 }
428
429 ACPI_EXPORT_SYMBOL(acpi_clear_event)
430
431 /*******************************************************************************
432  *
433  * FUNCTION:    acpi_clear_gpe
434  *
435  * PARAMETERS:  gpe_device      - Parent GPE Device
436  *              gpe_number      - GPE level within the GPE block
437  *              Flags           - Called from an ISR or not
438  *
439  * RETURN:      Status
440  *
441  * DESCRIPTION: Clear an ACPI event (general purpose)
442  *
443  ******************************************************************************/
444 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
445 {
446         acpi_status status = AE_OK;
447         struct acpi_gpe_event_info *gpe_event_info;
448
449         ACPI_FUNCTION_TRACE(acpi_clear_gpe);
450
451         /* Use semaphore lock if not executing at interrupt level */
452
453         if (flags & ACPI_NOT_ISR) {
454                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
455                 if (ACPI_FAILURE(status)) {
456                         return_ACPI_STATUS(status);
457                 }
458         }
459
460         /* Ensure that we have a valid GPE number */
461
462         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
463         if (!gpe_event_info) {
464                 status = AE_BAD_PARAMETER;
465                 goto unlock_and_exit;
466         }
467
468         status = acpi_hw_clear_gpe(gpe_event_info);
469
470       unlock_and_exit:
471         if (flags & ACPI_NOT_ISR) {
472                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
473         }
474         return_ACPI_STATUS(status);
475 }
476
477 ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
478
479 #ifdef ACPI_FUTURE_USAGE
480 /*******************************************************************************
481  *
482  * FUNCTION:    acpi_get_event_status
483  *
484  * PARAMETERS:  Event           - The fixed event
485  *              event_status    - Where the current status of the event will
486  *                                be returned
487  *
488  * RETURN:      Status
489  *
490  * DESCRIPTION: Obtains and returns the current status of the event
491  *
492  ******************************************************************************/
493 acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
494 {
495         acpi_status status = AE_OK;
496
497         ACPI_FUNCTION_TRACE(acpi_get_event_status);
498
499         if (!event_status) {
500                 return_ACPI_STATUS(AE_BAD_PARAMETER);
501         }
502
503         /* Decode the Fixed Event */
504
505         if (event > ACPI_EVENT_MAX) {
506                 return_ACPI_STATUS(AE_BAD_PARAMETER);
507         }
508
509         /* Get the status of the requested fixed event */
510
511         status =
512             acpi_get_register(acpi_gbl_fixed_event_info[event].
513                               status_register_id, event_status, ACPI_MTX_LOCK);
514
515         return_ACPI_STATUS(status);
516 }
517
518 ACPI_EXPORT_SYMBOL(acpi_get_event_status)
519
520 /*******************************************************************************
521  *
522  * FUNCTION:    acpi_get_gpe_status
523  *
524  * PARAMETERS:  gpe_device      - Parent GPE Device
525  *              gpe_number      - GPE level within the GPE block
526  *              Flags           - Called from an ISR or not
527  *              event_status    - Where the current status of the event will
528  *                                be returned
529  *
530  * RETURN:      Status
531  *
532  * DESCRIPTION: Get status of an event (general purpose)
533  *
534  ******************************************************************************/
535 acpi_status
536 acpi_get_gpe_status(acpi_handle gpe_device,
537                     u32 gpe_number, u32 flags, acpi_event_status * event_status)
538 {
539         acpi_status status = AE_OK;
540         struct acpi_gpe_event_info *gpe_event_info;
541
542         ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
543
544         /* Use semaphore lock if not executing at interrupt level */
545
546         if (flags & ACPI_NOT_ISR) {
547                 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
548                 if (ACPI_FAILURE(status)) {
549                         return_ACPI_STATUS(status);
550                 }
551         }
552
553         /* Ensure that we have a valid GPE number */
554
555         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
556         if (!gpe_event_info) {
557                 status = AE_BAD_PARAMETER;
558                 goto unlock_and_exit;
559         }
560
561         /* Obtain status on the requested GPE number */
562
563         status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
564
565       unlock_and_exit:
566         if (flags & ACPI_NOT_ISR) {
567                 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
568         }
569         return_ACPI_STATUS(status);
570 }
571
572 ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
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 acpi_status
590 acpi_install_gpe_block(acpi_handle gpe_device,
591                        struct acpi_generic_address *gpe_block_address,
592                        u32 register_count, u32 interrupt_number)
593 {
594         acpi_status status;
595         union acpi_operand_object *obj_desc;
596         struct acpi_namespace_node *node;
597         struct acpi_gpe_block_info *gpe_block;
598
599         ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
600
601         if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
602                 return_ACPI_STATUS(AE_BAD_PARAMETER);
603         }
604
605         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
606         if (ACPI_FAILURE(status)) {
607                 return (status);
608         }
609
610         node = acpi_ns_map_handle_to_node(gpe_device);
611         if (!node) {
612                 status = AE_BAD_PARAMETER;
613                 goto unlock_and_exit;
614         }
615
616         /*
617          * For user-installed GPE Block Devices, the gpe_block_base_number
618          * is always zero
619          */
620         status =
621             acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
622                                      interrupt_number, &gpe_block);
623         if (ACPI_FAILURE(status)) {
624                 goto unlock_and_exit;
625         }
626
627         /* Run the _PRW methods and enable the GPEs */
628
629         status = acpi_ev_initialize_gpe_block(node, gpe_block);
630         if (ACPI_FAILURE(status)) {
631                 goto unlock_and_exit;
632         }
633
634         /* Get the device_object attached to the node */
635
636         obj_desc = acpi_ns_get_attached_object(node);
637         if (!obj_desc) {
638
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 ACPI_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 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
682 {
683         union acpi_operand_object *obj_desc;
684         acpi_status status;
685         struct acpi_namespace_node *node;
686
687         ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
688
689         if (!gpe_device) {
690                 return_ACPI_STATUS(AE_BAD_PARAMETER);
691         }
692
693         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
694         if (ACPI_FAILURE(status)) {
695                 return (status);
696         }
697
698         node = acpi_ns_map_handle_to_node(gpe_device);
699         if (!node) {
700                 status = AE_BAD_PARAMETER;
701                 goto unlock_and_exit;
702         }
703
704         /* Get the device_object attached to the node */
705
706         obj_desc = acpi_ns_get_attached_object(node);
707         if (!obj_desc || !obj_desc->device.gpe_block) {
708                 return_ACPI_STATUS(AE_NULL_OBJECT);
709         }
710
711         /* Delete the GPE block (but not the device_object) */
712
713         status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
714         if (ACPI_SUCCESS(status)) {
715                 obj_desc->device.gpe_block = NULL;
716         }
717
718       unlock_and_exit:
719         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
720         return_ACPI_STATUS(status);
721 }
722
723 ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)