Loading...
1/******************************************************************************
2 *
3 * Module Name: evxfgpe - External Interfaces for General Purpose Events (GPEs)
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2012, Intel Corp.
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/export.h>
45#include <acpi/acpi.h>
46#include "accommon.h"
47#include "acevents.h"
48#include "acnamesp.h"
49
50#define _COMPONENT ACPI_EVENTS
51ACPI_MODULE_NAME("evxfgpe")
52
53#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
54/******************************************************************************
55 *
56 * FUNCTION: acpi_update_all_gpes
57 *
58 * PARAMETERS: None
59 *
60 * RETURN: Status
61 *
62 * DESCRIPTION: Complete GPE initialization and enable all GPEs that have
63 * associated _Lxx or _Exx methods and are not pointed to by any
64 * device _PRW methods (this indicates that these GPEs are
65 * generally intended for system or device wakeup. Such GPEs
66 * have to be enabled directly when the devices whose _PRW
67 * methods point to them are set up for wakeup signaling.)
68 *
69 * NOTE: Should be called after any GPEs are added to the system. Primarily,
70 * after the system _PRW methods have been run, but also after a GPE Block
71 * Device has been added or if any new GPE methods have been added via a
72 * dynamic table load.
73 *
74 ******************************************************************************/
75
76acpi_status acpi_update_all_gpes(void)
77{
78 acpi_status status;
79
80 ACPI_FUNCTION_TRACE(acpi_update_all_gpes);
81
82 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
83 if (ACPI_FAILURE(status)) {
84 return_ACPI_STATUS(status);
85 }
86
87 if (acpi_gbl_all_gpes_initialized) {
88 goto unlock_and_exit;
89 }
90
91 status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block, NULL);
92 if (ACPI_SUCCESS(status)) {
93 acpi_gbl_all_gpes_initialized = TRUE;
94 }
95
96unlock_and_exit:
97 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
98
99 return_ACPI_STATUS(status);
100}
101
102ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
103
104/*******************************************************************************
105 *
106 * FUNCTION: acpi_enable_gpe
107 *
108 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
109 * gpe_number - GPE level within the GPE block
110 *
111 * RETURN: Status
112 *
113 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
114 * hardware-enabled.
115 *
116 ******************************************************************************/
117
118acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
119{
120 acpi_status status = AE_BAD_PARAMETER;
121 struct acpi_gpe_event_info *gpe_event_info;
122 acpi_cpu_flags flags;
123
124 ACPI_FUNCTION_TRACE(acpi_enable_gpe);
125
126 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
127
128 /* Ensure that we have a valid GPE number */
129
130 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
131 if (gpe_event_info) {
132 status = acpi_ev_add_gpe_reference(gpe_event_info);
133 }
134
135 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
136 return_ACPI_STATUS(status);
137}
138ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
139
140/*******************************************************************************
141 *
142 * FUNCTION: acpi_disable_gpe
143 *
144 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
145 * gpe_number - GPE level within the GPE block
146 *
147 * RETURN: Status
148 *
149 * DESCRIPTION: Remove a reference to a GPE. When the last reference is
150 * removed, only then is the GPE disabled (for runtime GPEs), or
151 * the GPE mask bit disabled (for wake GPEs)
152 *
153 ******************************************************************************/
154
155acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
156{
157 acpi_status status = AE_BAD_PARAMETER;
158 struct acpi_gpe_event_info *gpe_event_info;
159 acpi_cpu_flags flags;
160
161 ACPI_FUNCTION_TRACE(acpi_disable_gpe);
162
163 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
164
165 /* Ensure that we have a valid GPE number */
166
167 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
168 if (gpe_event_info) {
169 status = acpi_ev_remove_gpe_reference(gpe_event_info) ;
170 }
171
172 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
173 return_ACPI_STATUS(status);
174}
175ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
176
177
178/*******************************************************************************
179 *
180 * FUNCTION: acpi_setup_gpe_for_wake
181 *
182 * PARAMETERS: wake_device - Device associated with the GPE (via _PRW)
183 * gpe_device - Parent GPE Device. NULL for GPE0/GPE1
184 * gpe_number - GPE level within the GPE block
185 *
186 * RETURN: Status
187 *
188 * DESCRIPTION: Mark a GPE as having the ability to wake the system. This
189 * interface is intended to be used as the host executes the
190 * _PRW methods (Power Resources for Wake) in the system tables.
191 * Each _PRW appears under a Device Object (The wake_device), and
192 * contains the info for the wake GPE associated with the
193 * wake_device.
194 *
195 ******************************************************************************/
196acpi_status
197acpi_setup_gpe_for_wake(acpi_handle wake_device,
198 acpi_handle gpe_device, u32 gpe_number)
199{
200 acpi_status status = AE_BAD_PARAMETER;
201 struct acpi_gpe_event_info *gpe_event_info;
202 struct acpi_namespace_node *device_node;
203 struct acpi_gpe_notify_object *notify_object;
204 acpi_cpu_flags flags;
205 u8 gpe_dispatch_mask;
206
207 ACPI_FUNCTION_TRACE(acpi_setup_gpe_for_wake);
208
209 /* Parameter Validation */
210
211 if (!wake_device) {
212 /*
213 * By forcing wake_device to be valid, we automatically enable the
214 * implicit notify feature on all hosts.
215 */
216 return_ACPI_STATUS(AE_BAD_PARAMETER);
217 }
218
219 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
220
221 /* Ensure that we have a valid GPE number */
222
223 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
224 if (!gpe_event_info) {
225 goto unlock_and_exit;
226 }
227
228 if (wake_device == ACPI_ROOT_OBJECT) {
229 goto out;
230 }
231
232 /*
233 * If there is no method or handler for this GPE, then the
234 * wake_device will be notified whenever this GPE fires (aka
235 * "implicit notify") Note: The GPE is assumed to be
236 * level-triggered (for windows compatibility).
237 */
238 gpe_dispatch_mask = gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK;
239 if (gpe_dispatch_mask != ACPI_GPE_DISPATCH_NONE
240 && gpe_dispatch_mask != ACPI_GPE_DISPATCH_NOTIFY) {
241 goto out;
242 }
243
244 /* Validate wake_device is of type Device */
245
246 device_node = ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
247 if (device_node->type != ACPI_TYPE_DEVICE) {
248 goto unlock_and_exit;
249 }
250
251 if (gpe_dispatch_mask == ACPI_GPE_DISPATCH_NONE) {
252 gpe_event_info->flags = (ACPI_GPE_DISPATCH_NOTIFY |
253 ACPI_GPE_LEVEL_TRIGGERED);
254 gpe_event_info->dispatch.device.node = device_node;
255 gpe_event_info->dispatch.device.next = NULL;
256 } else {
257 /* There are multiple devices to notify implicitly. */
258
259 notify_object = ACPI_ALLOCATE_ZEROED(sizeof(*notify_object));
260 if (!notify_object) {
261 status = AE_NO_MEMORY;
262 goto unlock_and_exit;
263 }
264
265 notify_object->node = device_node;
266 notify_object->next = gpe_event_info->dispatch.device.next;
267 gpe_event_info->dispatch.device.next = notify_object;
268 }
269
270 out:
271 gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
272 status = AE_OK;
273
274 unlock_and_exit:
275 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
276 return_ACPI_STATUS(status);
277}
278ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)
279
280/*******************************************************************************
281 *
282 * FUNCTION: acpi_set_gpe_wake_mask
283 *
284 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
285 * gpe_number - GPE level within the GPE block
286 * Action - Enable or Disable
287 *
288 * RETURN: Status
289 *
290 * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit. The GPE must
291 * already be marked as a WAKE GPE.
292 *
293 ******************************************************************************/
294
295acpi_status acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
296{
297 acpi_status status = AE_OK;
298 struct acpi_gpe_event_info *gpe_event_info;
299 struct acpi_gpe_register_info *gpe_register_info;
300 acpi_cpu_flags flags;
301 u32 register_bit;
302
303 ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask);
304
305 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
306
307 /*
308 * Ensure that we have a valid GPE number and that this GPE is in
309 * fact a wake GPE
310 */
311 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
312 if (!gpe_event_info) {
313 status = AE_BAD_PARAMETER;
314 goto unlock_and_exit;
315 }
316
317 if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
318 status = AE_TYPE;
319 goto unlock_and_exit;
320 }
321
322 gpe_register_info = gpe_event_info->register_info;
323 if (!gpe_register_info) {
324 status = AE_NOT_EXIST;
325 goto unlock_and_exit;
326 }
327
328 register_bit =
329 acpi_hw_get_gpe_register_bit(gpe_event_info, gpe_register_info);
330
331 /* Perform the action */
332
333 switch (action) {
334 case ACPI_GPE_ENABLE:
335 ACPI_SET_BIT(gpe_register_info->enable_for_wake,
336 (u8)register_bit);
337 break;
338
339 case ACPI_GPE_DISABLE:
340 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
341 (u8)register_bit);
342 break;
343
344 default:
345 ACPI_ERROR((AE_INFO, "%u, Invalid action", action));
346 status = AE_BAD_PARAMETER;
347 break;
348 }
349
350unlock_and_exit:
351 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
352 return_ACPI_STATUS(status);
353}
354
355ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask)
356
357/*******************************************************************************
358 *
359 * FUNCTION: acpi_clear_gpe
360 *
361 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
362 * gpe_number - GPE level within the GPE block
363 *
364 * RETURN: Status
365 *
366 * DESCRIPTION: Clear an ACPI event (general purpose)
367 *
368 ******************************************************************************/
369acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
370{
371 acpi_status status = AE_OK;
372 struct acpi_gpe_event_info *gpe_event_info;
373 acpi_cpu_flags flags;
374
375 ACPI_FUNCTION_TRACE(acpi_clear_gpe);
376
377 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
378
379 /* Ensure that we have a valid GPE number */
380
381 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
382 if (!gpe_event_info) {
383 status = AE_BAD_PARAMETER;
384 goto unlock_and_exit;
385 }
386
387 status = acpi_hw_clear_gpe(gpe_event_info);
388
389 unlock_and_exit:
390 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
391 return_ACPI_STATUS(status);
392}
393
394ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
395
396/*******************************************************************************
397 *
398 * FUNCTION: acpi_get_gpe_status
399 *
400 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
401 * gpe_number - GPE level within the GPE block
402 * event_status - Where the current status of the event will
403 * be returned
404 *
405 * RETURN: Status
406 *
407 * DESCRIPTION: Get the current status of a GPE (signalled/not_signalled)
408 *
409 ******************************************************************************/
410acpi_status
411acpi_get_gpe_status(acpi_handle gpe_device,
412 u32 gpe_number, acpi_event_status *event_status)
413{
414 acpi_status status = AE_OK;
415 struct acpi_gpe_event_info *gpe_event_info;
416 acpi_cpu_flags flags;
417
418 ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
419
420 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
421
422 /* Ensure that we have a valid GPE number */
423
424 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
425 if (!gpe_event_info) {
426 status = AE_BAD_PARAMETER;
427 goto unlock_and_exit;
428 }
429
430 /* Obtain status on the requested GPE number */
431
432 status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
433
434 if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
435 *event_status |= ACPI_EVENT_FLAG_HANDLE;
436
437 unlock_and_exit:
438 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
439 return_ACPI_STATUS(status);
440}
441
442ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
443
444/******************************************************************************
445 *
446 * FUNCTION: acpi_disable_all_gpes
447 *
448 * PARAMETERS: None
449 *
450 * RETURN: Status
451 *
452 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
453 *
454 ******************************************************************************/
455
456acpi_status acpi_disable_all_gpes(void)
457{
458 acpi_status status;
459
460 ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
461
462 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
463 if (ACPI_FAILURE(status)) {
464 return_ACPI_STATUS(status);
465 }
466
467 status = acpi_hw_disable_all_gpes();
468 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
469
470 return_ACPI_STATUS(status);
471}
472
473ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)
474
475/******************************************************************************
476 *
477 * FUNCTION: acpi_enable_all_runtime_gpes
478 *
479 * PARAMETERS: None
480 *
481 * RETURN: Status
482 *
483 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
484 *
485 ******************************************************************************/
486
487acpi_status acpi_enable_all_runtime_gpes(void)
488{
489 acpi_status status;
490
491 ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
492
493 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
494 if (ACPI_FAILURE(status)) {
495 return_ACPI_STATUS(status);
496 }
497
498 status = acpi_hw_enable_all_runtime_gpes();
499 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
500
501 return_ACPI_STATUS(status);
502}
503
504ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)
505
506/*******************************************************************************
507 *
508 * FUNCTION: acpi_install_gpe_block
509 *
510 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
511 * gpe_block_address - Address and space_iD
512 * register_count - Number of GPE register pairs in the block
513 * interrupt_number - H/W interrupt for the block
514 *
515 * RETURN: Status
516 *
517 * DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not
518 * enabled here.
519 *
520 ******************************************************************************/
521acpi_status
522acpi_install_gpe_block(acpi_handle gpe_device,
523 struct acpi_generic_address *gpe_block_address,
524 u32 register_count, u32 interrupt_number)
525{
526 acpi_status status;
527 union acpi_operand_object *obj_desc;
528 struct acpi_namespace_node *node;
529 struct acpi_gpe_block_info *gpe_block;
530
531 ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
532
533 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
534 return_ACPI_STATUS(AE_BAD_PARAMETER);
535 }
536
537 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
538 if (ACPI_FAILURE(status)) {
539 return (status);
540 }
541
542 node = acpi_ns_validate_handle(gpe_device);
543 if (!node) {
544 status = AE_BAD_PARAMETER;
545 goto unlock_and_exit;
546 }
547
548 /*
549 * For user-installed GPE Block Devices, the gpe_block_base_number
550 * is always zero
551 */
552 status =
553 acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
554 interrupt_number, &gpe_block);
555 if (ACPI_FAILURE(status)) {
556 goto unlock_and_exit;
557 }
558
559 /* Install block in the device_object attached to the node */
560
561 obj_desc = acpi_ns_get_attached_object(node);
562 if (!obj_desc) {
563
564 /*
565 * No object, create a new one (Device nodes do not always have
566 * an attached object)
567 */
568 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
569 if (!obj_desc) {
570 status = AE_NO_MEMORY;
571 goto unlock_and_exit;
572 }
573
574 status =
575 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
576
577 /* Remove local reference to the object */
578
579 acpi_ut_remove_reference(obj_desc);
580
581 if (ACPI_FAILURE(status)) {
582 goto unlock_and_exit;
583 }
584 }
585
586 /* Now install the GPE block in the device_object */
587
588 obj_desc->device.gpe_block = gpe_block;
589
590 unlock_and_exit:
591 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
592 return_ACPI_STATUS(status);
593}
594
595ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
596
597/*******************************************************************************
598 *
599 * FUNCTION: acpi_remove_gpe_block
600 *
601 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
602 *
603 * RETURN: Status
604 *
605 * DESCRIPTION: Remove a previously installed block of GPE registers
606 *
607 ******************************************************************************/
608acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
609{
610 union acpi_operand_object *obj_desc;
611 acpi_status status;
612 struct acpi_namespace_node *node;
613
614 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
615
616 if (!gpe_device) {
617 return_ACPI_STATUS(AE_BAD_PARAMETER);
618 }
619
620 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
621 if (ACPI_FAILURE(status)) {
622 return (status);
623 }
624
625 node = acpi_ns_validate_handle(gpe_device);
626 if (!node) {
627 status = AE_BAD_PARAMETER;
628 goto unlock_and_exit;
629 }
630
631 /* Get the device_object attached to the node */
632
633 obj_desc = acpi_ns_get_attached_object(node);
634 if (!obj_desc || !obj_desc->device.gpe_block) {
635 return_ACPI_STATUS(AE_NULL_OBJECT);
636 }
637
638 /* Delete the GPE block (but not the device_object) */
639
640 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
641 if (ACPI_SUCCESS(status)) {
642 obj_desc->device.gpe_block = NULL;
643 }
644
645 unlock_and_exit:
646 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
647 return_ACPI_STATUS(status);
648}
649
650ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
651
652/*******************************************************************************
653 *
654 * FUNCTION: acpi_get_gpe_device
655 *
656 * PARAMETERS: Index - System GPE index (0-current_gpe_count)
657 * gpe_device - Where the parent GPE Device is returned
658 *
659 * RETURN: Status
660 *
661 * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
662 * gpe device indicates that the gpe number is contained in one of
663 * the FADT-defined gpe blocks. Otherwise, the GPE block device.
664 *
665 ******************************************************************************/
666acpi_status
667acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)
668{
669 struct acpi_gpe_device_info info;
670 acpi_status status;
671
672 ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
673
674 if (!gpe_device) {
675 return_ACPI_STATUS(AE_BAD_PARAMETER);
676 }
677
678 if (index >= acpi_current_gpe_count) {
679 return_ACPI_STATUS(AE_NOT_EXIST);
680 }
681
682 /* Setup and walk the GPE list */
683
684 info.index = index;
685 info.status = AE_NOT_EXIST;
686 info.gpe_device = NULL;
687 info.next_block_base_index = 0;
688
689 status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
690 if (ACPI_FAILURE(status)) {
691 return_ACPI_STATUS(status);
692 }
693
694 *gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device);
695 return_ACPI_STATUS(info.status);
696}
697
698ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
699#endif /* !ACPI_REDUCED_HARDWARE */
1/******************************************************************************
2 *
3 * Module Name: evxfgpe - External Interfaces for General Purpose Events (GPEs)
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2014, Intel Corp.
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#define EXPORT_ACPI_INTERFACES
45
46#include <acpi/acpi.h>
47#include "accommon.h"
48#include "acevents.h"
49#include "acnamesp.h"
50
51#define _COMPONENT ACPI_EVENTS
52ACPI_MODULE_NAME("evxfgpe")
53
54#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
55/*******************************************************************************
56 *
57 * FUNCTION: acpi_update_all_gpes
58 *
59 * PARAMETERS: None
60 *
61 * RETURN: Status
62 *
63 * DESCRIPTION: Complete GPE initialization and enable all GPEs that have
64 * associated _Lxx or _Exx methods and are not pointed to by any
65 * device _PRW methods (this indicates that these GPEs are
66 * generally intended for system or device wakeup. Such GPEs
67 * have to be enabled directly when the devices whose _PRW
68 * methods point to them are set up for wakeup signaling.)
69 *
70 * NOTE: Should be called after any GPEs are added to the system. Primarily,
71 * after the system _PRW methods have been run, but also after a GPE Block
72 * Device has been added or if any new GPE methods have been added via a
73 * dynamic table load.
74 *
75 ******************************************************************************/
76
77acpi_status acpi_update_all_gpes(void)
78{
79 acpi_status status;
80
81 ACPI_FUNCTION_TRACE(acpi_update_all_gpes);
82
83 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
84 if (ACPI_FAILURE(status)) {
85 return_ACPI_STATUS(status);
86 }
87
88 if (acpi_gbl_all_gpes_initialized) {
89 goto unlock_and_exit;
90 }
91
92 status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block, NULL);
93 if (ACPI_SUCCESS(status)) {
94 acpi_gbl_all_gpes_initialized = TRUE;
95 }
96
97unlock_and_exit:
98 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
99
100 return_ACPI_STATUS(status);
101}
102
103ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
104
105/*******************************************************************************
106 *
107 * FUNCTION: acpi_enable_gpe
108 *
109 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
110 * gpe_number - GPE level within the GPE block
111 *
112 * RETURN: Status
113 *
114 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
115 * hardware-enabled.
116 *
117 ******************************************************************************/
118
119acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
120{
121 acpi_status status = AE_BAD_PARAMETER;
122 struct acpi_gpe_event_info *gpe_event_info;
123 acpi_cpu_flags flags;
124
125 ACPI_FUNCTION_TRACE(acpi_enable_gpe);
126
127 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
128
129 /* Ensure that we have a valid GPE number */
130
131 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
132 if (gpe_event_info) {
133 status = acpi_ev_add_gpe_reference(gpe_event_info);
134 }
135
136 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
137 return_ACPI_STATUS(status);
138}
139ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
140
141/*******************************************************************************
142 *
143 * FUNCTION: acpi_disable_gpe
144 *
145 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
146 * gpe_number - GPE level within the GPE block
147 *
148 * RETURN: Status
149 *
150 * DESCRIPTION: Remove a reference to a GPE. When the last reference is
151 * removed, only then is the GPE disabled (for runtime GPEs), or
152 * the GPE mask bit disabled (for wake GPEs)
153 *
154 ******************************************************************************/
155
156acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
157{
158 acpi_status status = AE_BAD_PARAMETER;
159 struct acpi_gpe_event_info *gpe_event_info;
160 acpi_cpu_flags flags;
161
162 ACPI_FUNCTION_TRACE(acpi_disable_gpe);
163
164 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
165
166 /* Ensure that we have a valid GPE number */
167
168 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
169 if (gpe_event_info) {
170 status = acpi_ev_remove_gpe_reference(gpe_event_info) ;
171 }
172
173 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
174 return_ACPI_STATUS(status);
175}
176
177ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
178
179
180/*******************************************************************************
181 *
182 * FUNCTION: acpi_setup_gpe_for_wake
183 *
184 * PARAMETERS: wake_device - Device associated with the GPE (via _PRW)
185 * gpe_device - Parent GPE Device. NULL for GPE0/GPE1
186 * gpe_number - GPE level within the GPE block
187 *
188 * RETURN: Status
189 *
190 * DESCRIPTION: Mark a GPE as having the ability to wake the system. This
191 * interface is intended to be used as the host executes the
192 * _PRW methods (Power Resources for Wake) in the system tables.
193 * Each _PRW appears under a Device Object (The wake_device), and
194 * contains the info for the wake GPE associated with the
195 * wake_device.
196 *
197 ******************************************************************************/
198acpi_status
199acpi_setup_gpe_for_wake(acpi_handle wake_device,
200 acpi_handle gpe_device, u32 gpe_number)
201{
202 acpi_status status;
203 struct acpi_gpe_event_info *gpe_event_info;
204 struct acpi_namespace_node *device_node;
205 struct acpi_gpe_notify_info *notify;
206 struct acpi_gpe_notify_info *new_notify;
207 acpi_cpu_flags flags;
208
209 ACPI_FUNCTION_TRACE(acpi_setup_gpe_for_wake);
210
211 /* Parameter Validation */
212
213 if (!wake_device) {
214 /*
215 * By forcing wake_device to be valid, we automatically enable the
216 * implicit notify feature on all hosts.
217 */
218 return_ACPI_STATUS(AE_BAD_PARAMETER);
219 }
220
221 /* Handle root object case */
222
223 if (wake_device == ACPI_ROOT_OBJECT) {
224 device_node = acpi_gbl_root_node;
225 } else {
226 device_node =
227 ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
228 }
229
230 /* Validate wake_device is of type Device */
231
232 if (device_node->type != ACPI_TYPE_DEVICE) {
233 return_ACPI_STATUS (AE_BAD_PARAMETER);
234 }
235
236 /*
237 * Allocate a new notify object up front, in case it is needed.
238 * Memory allocation while holding a spinlock is a big no-no
239 * on some hosts.
240 */
241 new_notify = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_notify_info));
242 if (!new_notify) {
243 return_ACPI_STATUS(AE_NO_MEMORY);
244 }
245
246 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
247
248 /* Ensure that we have a valid GPE number */
249
250 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
251 if (!gpe_event_info) {
252 status = AE_BAD_PARAMETER;
253 goto unlock_and_exit;
254 }
255
256 /*
257 * If there is no method or handler for this GPE, then the
258 * wake_device will be notified whenever this GPE fires. This is
259 * known as an "implicit notify". Note: The GPE is assumed to be
260 * level-triggered (for windows compatibility).
261 */
262 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
263 ACPI_GPE_DISPATCH_NONE) {
264 /*
265 * This is the first device for implicit notify on this GPE.
266 * Just set the flags here, and enter the NOTIFY block below.
267 */
268 gpe_event_info->flags =
269 (ACPI_GPE_DISPATCH_NOTIFY | ACPI_GPE_LEVEL_TRIGGERED);
270 }
271
272 /*
273 * If we already have an implicit notify on this GPE, add
274 * this device to the notify list.
275 */
276 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
277 ACPI_GPE_DISPATCH_NOTIFY) {
278
279 /* Ensure that the device is not already in the list */
280
281 notify = gpe_event_info->dispatch.notify_list;
282 while (notify) {
283 if (notify->device_node == device_node) {
284 status = AE_ALREADY_EXISTS;
285 goto unlock_and_exit;
286 }
287 notify = notify->next;
288 }
289
290 /* Add this device to the notify list for this GPE */
291
292 new_notify->device_node = device_node;
293 new_notify->next = gpe_event_info->dispatch.notify_list;
294 gpe_event_info->dispatch.notify_list = new_notify;
295 new_notify = NULL;
296 }
297
298 /* Mark the GPE as a possible wake event */
299
300 gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
301 status = AE_OK;
302
303unlock_and_exit:
304 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
305
306 /* Delete the notify object if it was not used above */
307
308 if (new_notify) {
309 ACPI_FREE(new_notify);
310 }
311 return_ACPI_STATUS(status);
312}
313ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)
314
315/*******************************************************************************
316 *
317 * FUNCTION: acpi_set_gpe_wake_mask
318 *
319 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
320 * gpe_number - GPE level within the GPE block
321 * action - Enable or Disable
322 *
323 * RETURN: Status
324 *
325 * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit. The GPE must
326 * already be marked as a WAKE GPE.
327 *
328 ******************************************************************************/
329
330acpi_status
331acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
332{
333 acpi_status status = AE_OK;
334 struct acpi_gpe_event_info *gpe_event_info;
335 struct acpi_gpe_register_info *gpe_register_info;
336 acpi_cpu_flags flags;
337 u32 register_bit;
338
339 ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask);
340
341 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
342
343 /*
344 * Ensure that we have a valid GPE number and that this GPE is in
345 * fact a wake GPE
346 */
347 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
348 if (!gpe_event_info) {
349 status = AE_BAD_PARAMETER;
350 goto unlock_and_exit;
351 }
352
353 if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
354 status = AE_TYPE;
355 goto unlock_and_exit;
356 }
357
358 gpe_register_info = gpe_event_info->register_info;
359 if (!gpe_register_info) {
360 status = AE_NOT_EXIST;
361 goto unlock_and_exit;
362 }
363
364 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
365
366 /* Perform the action */
367
368 switch (action) {
369 case ACPI_GPE_ENABLE:
370
371 ACPI_SET_BIT(gpe_register_info->enable_for_wake,
372 (u8)register_bit);
373 break;
374
375 case ACPI_GPE_DISABLE:
376
377 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
378 (u8)register_bit);
379 break;
380
381 default:
382
383 ACPI_ERROR((AE_INFO, "%u, Invalid action", action));
384 status = AE_BAD_PARAMETER;
385 break;
386 }
387
388unlock_and_exit:
389 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
390 return_ACPI_STATUS(status);
391}
392
393ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask)
394
395/*******************************************************************************
396 *
397 * FUNCTION: acpi_clear_gpe
398 *
399 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
400 * gpe_number - GPE level within the GPE block
401 *
402 * RETURN: Status
403 *
404 * DESCRIPTION: Clear an ACPI event (general purpose)
405 *
406 ******************************************************************************/
407acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
408{
409 acpi_status status = AE_OK;
410 struct acpi_gpe_event_info *gpe_event_info;
411 acpi_cpu_flags flags;
412
413 ACPI_FUNCTION_TRACE(acpi_clear_gpe);
414
415 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
416
417 /* Ensure that we have a valid GPE number */
418
419 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
420 if (!gpe_event_info) {
421 status = AE_BAD_PARAMETER;
422 goto unlock_and_exit;
423 }
424
425 status = acpi_hw_clear_gpe(gpe_event_info);
426
427 unlock_and_exit:
428 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
429 return_ACPI_STATUS(status);
430}
431
432ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
433
434/*******************************************************************************
435 *
436 * FUNCTION: acpi_get_gpe_status
437 *
438 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
439 * gpe_number - GPE level within the GPE block
440 * event_status - Where the current status of the event
441 * will be returned
442 *
443 * RETURN: Status
444 *
445 * DESCRIPTION: Get the current status of a GPE (signalled/not_signalled)
446 *
447 ******************************************************************************/
448acpi_status
449acpi_get_gpe_status(acpi_handle gpe_device,
450 u32 gpe_number, acpi_event_status *event_status)
451{
452 acpi_status status = AE_OK;
453 struct acpi_gpe_event_info *gpe_event_info;
454 acpi_cpu_flags flags;
455
456 ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
457
458 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
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 /* Obtain status on the requested GPE number */
469
470 status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
471
472 if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
473 *event_status |= ACPI_EVENT_FLAG_HANDLE;
474
475unlock_and_exit:
476 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
477 return_ACPI_STATUS(status);
478}
479
480ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
481
482/******************************************************************************
483 *
484 * FUNCTION: acpi_disable_all_gpes
485 *
486 * PARAMETERS: None
487 *
488 * RETURN: Status
489 *
490 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
491 *
492 ******************************************************************************/
493
494acpi_status acpi_disable_all_gpes(void)
495{
496 acpi_status status;
497
498 ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
499
500 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
501 if (ACPI_FAILURE(status)) {
502 return_ACPI_STATUS(status);
503 }
504
505 status = acpi_hw_disable_all_gpes();
506 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
507
508 return_ACPI_STATUS(status);
509}
510
511ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)
512
513/******************************************************************************
514 *
515 * FUNCTION: acpi_enable_all_runtime_gpes
516 *
517 * PARAMETERS: None
518 *
519 * RETURN: Status
520 *
521 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
522 *
523 ******************************************************************************/
524
525acpi_status acpi_enable_all_runtime_gpes(void)
526{
527 acpi_status status;
528
529 ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
530
531 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
532 if (ACPI_FAILURE(status)) {
533 return_ACPI_STATUS(status);
534 }
535
536 status = acpi_hw_enable_all_runtime_gpes();
537 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
538
539 return_ACPI_STATUS(status);
540}
541
542ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)
543
544/*******************************************************************************
545 *
546 * FUNCTION: acpi_install_gpe_block
547 *
548 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
549 * gpe_block_address - Address and space_ID
550 * register_count - Number of GPE register pairs in the block
551 * interrupt_number - H/W interrupt for the block
552 *
553 * RETURN: Status
554 *
555 * DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not
556 * enabled here.
557 *
558 ******************************************************************************/
559acpi_status
560acpi_install_gpe_block(acpi_handle gpe_device,
561 struct acpi_generic_address *gpe_block_address,
562 u32 register_count, u32 interrupt_number)
563{
564 acpi_status status;
565 union acpi_operand_object *obj_desc;
566 struct acpi_namespace_node *node;
567 struct acpi_gpe_block_info *gpe_block;
568
569 ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
570
571 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
572 return_ACPI_STATUS(AE_BAD_PARAMETER);
573 }
574
575 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
576 if (ACPI_FAILURE(status)) {
577 return_ACPI_STATUS(status);
578 }
579
580 node = acpi_ns_validate_handle(gpe_device);
581 if (!node) {
582 status = AE_BAD_PARAMETER;
583 goto unlock_and_exit;
584 }
585
586 /* Validate the parent device */
587
588 if (node->type != ACPI_TYPE_DEVICE) {
589 status = AE_TYPE;
590 goto unlock_and_exit;
591 }
592
593 if (node->object) {
594 status = AE_ALREADY_EXISTS;
595 goto unlock_and_exit;
596 }
597
598 /*
599 * For user-installed GPE Block Devices, the gpe_block_base_number
600 * is always zero
601 */
602 status =
603 acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
604 interrupt_number, &gpe_block);
605 if (ACPI_FAILURE(status)) {
606 goto unlock_and_exit;
607 }
608
609 /* Install block in the device_object attached to the node */
610
611 obj_desc = acpi_ns_get_attached_object(node);
612 if (!obj_desc) {
613
614 /*
615 * No object, create a new one (Device nodes do not always have
616 * an attached object)
617 */
618 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
619 if (!obj_desc) {
620 status = AE_NO_MEMORY;
621 goto unlock_and_exit;
622 }
623
624 status =
625 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
626
627 /* Remove local reference to the object */
628
629 acpi_ut_remove_reference(obj_desc);
630
631 if (ACPI_FAILURE(status)) {
632 goto unlock_and_exit;
633 }
634 }
635
636 /* Now install the GPE block in the device_object */
637
638 obj_desc->device.gpe_block = gpe_block;
639
640unlock_and_exit:
641 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
642 return_ACPI_STATUS(status);
643}
644
645ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
646
647/*******************************************************************************
648 *
649 * FUNCTION: acpi_remove_gpe_block
650 *
651 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
652 *
653 * RETURN: Status
654 *
655 * DESCRIPTION: Remove a previously installed block of GPE registers
656 *
657 ******************************************************************************/
658acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
659{
660 union acpi_operand_object *obj_desc;
661 acpi_status status;
662 struct acpi_namespace_node *node;
663
664 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
665
666 if (!gpe_device) {
667 return_ACPI_STATUS(AE_BAD_PARAMETER);
668 }
669
670 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
671 if (ACPI_FAILURE(status)) {
672 return_ACPI_STATUS(status);
673 }
674
675 node = acpi_ns_validate_handle(gpe_device);
676 if (!node) {
677 status = AE_BAD_PARAMETER;
678 goto unlock_and_exit;
679 }
680
681 /* Validate the parent device */
682
683 if (node->type != ACPI_TYPE_DEVICE) {
684 status = AE_TYPE;
685 goto unlock_and_exit;
686 }
687
688 /* Get the device_object attached to the node */
689
690 obj_desc = acpi_ns_get_attached_object(node);
691 if (!obj_desc || !obj_desc->device.gpe_block) {
692 return_ACPI_STATUS(AE_NULL_OBJECT);
693 }
694
695 /* Delete the GPE block (but not the device_object) */
696
697 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
698 if (ACPI_SUCCESS(status)) {
699 obj_desc->device.gpe_block = NULL;
700 }
701
702unlock_and_exit:
703 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
704 return_ACPI_STATUS(status);
705}
706
707ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
708
709/*******************************************************************************
710 *
711 * FUNCTION: acpi_get_gpe_device
712 *
713 * PARAMETERS: index - System GPE index (0-current_gpe_count)
714 * gpe_device - Where the parent GPE Device is returned
715 *
716 * RETURN: Status
717 *
718 * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
719 * gpe device indicates that the gpe number is contained in one of
720 * the FADT-defined gpe blocks. Otherwise, the GPE block device.
721 *
722 ******************************************************************************/
723acpi_status acpi_get_gpe_device(u32 index, acpi_handle * gpe_device)
724{
725 struct acpi_gpe_device_info info;
726 acpi_status status;
727
728 ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
729
730 if (!gpe_device) {
731 return_ACPI_STATUS(AE_BAD_PARAMETER);
732 }
733
734 if (index >= acpi_current_gpe_count) {
735 return_ACPI_STATUS(AE_NOT_EXIST);
736 }
737
738 /* Setup and walk the GPE list */
739
740 info.index = index;
741 info.status = AE_NOT_EXIST;
742 info.gpe_device = NULL;
743 info.next_block_base_index = 0;
744
745 status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
746 if (ACPI_FAILURE(status)) {
747 return_ACPI_STATUS(status);
748 }
749
750 *gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device);
751 return_ACPI_STATUS(info.status);
752}
753
754ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
755#endif /* !ACPI_REDUCED_HARDWARE */