1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: evxfgpe - External Interfaces for General Purpose Events (GPEs)
5  *
6  * Copyright (C) 2000 - 2023, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #define EXPORT_ACPI_INTERFACES
11 
12 #include <acpi/acpi.h>
13 #include "accommon.h"
14 #include "acevents.h"
15 #include "acnamesp.h"
16 
17 #define _COMPONENT          ACPI_EVENTS
18 ACPI_MODULE_NAME("evxfgpe")
19 
20 #if (!ACPI_REDUCED_HARDWARE)	/* Entire module */
21 /*******************************************************************************
22  *
23  * FUNCTION:    acpi_update_all_gpes
24  *
25  * PARAMETERS:  None
26  *
27  * RETURN:      Status
28  *
29  * DESCRIPTION: Complete GPE initialization and enable all GPEs that have
30  *              associated _Lxx or _Exx methods and are not pointed to by any
31  *              device _PRW methods (this indicates that these GPEs are
32  *              generally intended for system or device wakeup. Such GPEs
33  *              have to be enabled directly when the devices whose _PRW
34  *              methods point to them are set up for wakeup signaling.)
35  *
36  * NOTE: Should be called after any GPEs are added to the system. Primarily,
37  * after the system _PRW methods have been run, but also after a GPE Block
38  * Device has been added or if any new GPE methods have been added via a
39  * dynamic table load.
40  *
41  ******************************************************************************/
42 
acpi_update_all_gpes(void)43 acpi_status acpi_update_all_gpes(void)
44 {
45 	acpi_status status;
46 	u8 is_polling_needed = FALSE;
47 
48 	ACPI_FUNCTION_TRACE(acpi_update_all_gpes);
49 
50 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
51 	if (ACPI_FAILURE(status)) {
52 		return_ACPI_STATUS(status);
53 	}
54 
55 	if (acpi_gbl_all_gpes_initialized) {
56 		goto unlock_and_exit;
57 	}
58 
59 	status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block,
60 				       &is_polling_needed);
61 	if (ACPI_SUCCESS(status)) {
62 		acpi_gbl_all_gpes_initialized = TRUE;
63 	}
64 
65 unlock_and_exit:
66 	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
67 
68 	if (is_polling_needed && acpi_gbl_all_gpes_initialized) {
69 
70 		/* Poll GPEs to handle already triggered events */
71 
72 		acpi_ev_gpe_detect(acpi_gbl_gpe_xrupt_list_head);
73 	}
74 	return_ACPI_STATUS(status);
75 }
76 
ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)77 ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
78 
79 /*******************************************************************************
80  *
81  * FUNCTION:    acpi_enable_gpe
82  *
83  * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
84  *              gpe_number          - GPE level within the GPE block
85  *
86  * RETURN:      Status
87  *
88  * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
89  *              hardware-enabled.
90  *
91  ******************************************************************************/
92 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
93 {
94 	acpi_status status = AE_BAD_PARAMETER;
95 	struct acpi_gpe_event_info *gpe_event_info;
96 	acpi_cpu_flags flags;
97 
98 	ACPI_FUNCTION_TRACE(acpi_enable_gpe);
99 
100 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
101 
102 	/*
103 	 * Ensure that we have a valid GPE number and that there is some way
104 	 * of handling the GPE (handler or a GPE method). In other words, we
105 	 * won't allow a valid GPE to be enabled if there is no way to handle it.
106 	 */
107 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
108 	if (gpe_event_info) {
109 		if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
110 		    ACPI_GPE_DISPATCH_NONE) {
111 			status = acpi_ev_add_gpe_reference(gpe_event_info, TRUE);
112 			if (ACPI_SUCCESS(status) &&
113 			    ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) {
114 
115 				/* Poll edge-triggered GPEs to handle existing events */
116 
117 				acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
118 				(void)acpi_ev_detect_gpe(gpe_device,
119 							 gpe_event_info,
120 							 gpe_number);
121 				flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
122 			}
123 		} else {
124 			status = AE_NO_HANDLER;
125 		}
126 	}
127 
128 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
129 	return_ACPI_STATUS(status);
130 }
ACPI_EXPORT_SYMBOL(acpi_enable_gpe)131 ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
132 
133 /*******************************************************************************
134  *
135  * FUNCTION:    acpi_disable_gpe
136  *
137  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
138  *              gpe_number      - GPE level within the GPE block
139  *
140  * RETURN:      Status
141  *
142  * DESCRIPTION: Remove a reference to a GPE. When the last reference is
143  *              removed, only then is the GPE disabled (for runtime GPEs), or
144  *              the GPE mask bit disabled (for wake GPEs)
145  *
146  ******************************************************************************/
147 
148 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
149 {
150 	acpi_status status = AE_BAD_PARAMETER;
151 	struct acpi_gpe_event_info *gpe_event_info;
152 	acpi_cpu_flags flags;
153 
154 	ACPI_FUNCTION_TRACE(acpi_disable_gpe);
155 
156 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
157 
158 	/* Ensure that we have a valid GPE number */
159 
160 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
161 	if (gpe_event_info) {
162 		status = acpi_ev_remove_gpe_reference(gpe_event_info) ;
163 	}
164 
165 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
166 	return_ACPI_STATUS(status);
167 }
168 
ACPI_EXPORT_SYMBOL(acpi_disable_gpe)169 ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
170 
171 /*******************************************************************************
172  *
173  * FUNCTION:    acpi_set_gpe
174  *
175  * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
176  *              gpe_number          - GPE level within the GPE block
177  *              action              - ACPI_GPE_ENABLE or ACPI_GPE_DISABLE
178  *
179  * RETURN:      Status
180  *
181  * DESCRIPTION: Enable or disable an individual GPE. This function bypasses
182  *              the reference count mechanism used in the acpi_enable_gpe(),
183  *              acpi_disable_gpe() interfaces.
184  *              This API is typically used by the GPE raw handler mode driver
185  *              to switch between the polling mode and the interrupt mode after
186  *              the driver has enabled the GPE.
187  *              The APIs should be invoked in this order:
188  *               acpi_enable_gpe()            <- Ensure the reference count > 0
189  *               acpi_set_gpe(ACPI_GPE_DISABLE) <- Enter polling mode
190  *               acpi_set_gpe(ACPI_GPE_ENABLE) <- Leave polling mode
191  *               acpi_disable_gpe()           <- Decrease the reference count
192  *
193  * Note: If a GPE is shared by 2 silicon components, then both the drivers
194  *       should support GPE polling mode or disabling the GPE for long period
195  *       for one driver may break the other. So use it with care since all
196  *       firmware _Lxx/_Exx handlers currently rely on the GPE interrupt mode.
197  *
198  ******************************************************************************/
199 acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action)
200 {
201 	struct acpi_gpe_event_info *gpe_event_info;
202 	acpi_status status;
203 	acpi_cpu_flags flags;
204 
205 	ACPI_FUNCTION_TRACE(acpi_set_gpe);
206 
207 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
208 
209 	/* Ensure that we have a valid GPE number */
210 
211 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
212 	if (!gpe_event_info) {
213 		status = AE_BAD_PARAMETER;
214 		goto unlock_and_exit;
215 	}
216 
217 	/* Perform the action */
218 
219 	switch (action) {
220 	case ACPI_GPE_ENABLE:
221 
222 		status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
223 		gpe_event_info->disable_for_dispatch = FALSE;
224 		break;
225 
226 	case ACPI_GPE_DISABLE:
227 
228 		status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
229 		gpe_event_info->disable_for_dispatch = TRUE;
230 		break;
231 
232 	default:
233 
234 		status = AE_BAD_PARAMETER;
235 		break;
236 	}
237 
238 unlock_and_exit:
239 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
240 	return_ACPI_STATUS(status);
241 }
242 
ACPI_EXPORT_SYMBOL(acpi_set_gpe)243 ACPI_EXPORT_SYMBOL(acpi_set_gpe)
244 
245 /*******************************************************************************
246  *
247  * FUNCTION:    acpi_mask_gpe
248  *
249  * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
250  *              gpe_number          - GPE level within the GPE block
251  *              is_masked           - Whether the GPE is masked or not
252  *
253  * RETURN:      Status
254  *
255  * DESCRIPTION: Unconditionally mask/unmask the an individual GPE, ex., to
256  *              prevent a GPE flooding.
257  *
258  ******************************************************************************/
259 acpi_status acpi_mask_gpe(acpi_handle gpe_device, u32 gpe_number, u8 is_masked)
260 {
261 	struct acpi_gpe_event_info *gpe_event_info;
262 	acpi_status status;
263 	acpi_cpu_flags flags;
264 
265 	ACPI_FUNCTION_TRACE(acpi_mask_gpe);
266 
267 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
268 
269 	/* Ensure that we have a valid GPE number */
270 
271 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
272 	if (!gpe_event_info) {
273 		status = AE_BAD_PARAMETER;
274 		goto unlock_and_exit;
275 	}
276 
277 	status = acpi_ev_mask_gpe(gpe_event_info, is_masked);
278 
279 unlock_and_exit:
280 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
281 	return_ACPI_STATUS(status);
282 }
283 
ACPI_EXPORT_SYMBOL(acpi_mask_gpe)284 ACPI_EXPORT_SYMBOL(acpi_mask_gpe)
285 
286 /*******************************************************************************
287  *
288  * FUNCTION:    acpi_mark_gpe_for_wake
289  *
290  * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
291  *              gpe_number          - GPE level within the GPE block
292  *
293  * RETURN:      Status
294  *
295  * DESCRIPTION: Mark a GPE as having the ability to wake the system. Simply
296  *              sets the ACPI_GPE_CAN_WAKE flag.
297  *
298  * Some potential callers of acpi_setup_gpe_for_wake may know in advance that
299  * there won't be any notify handlers installed for device wake notifications
300  * from the given GPE (one example is a button GPE in Linux). For these cases,
301  * acpi_mark_gpe_for_wake should be used instead of acpi_setup_gpe_for_wake.
302  * This will set the ACPI_GPE_CAN_WAKE flag for the GPE without trying to
303  * setup implicit wake notification for it (since there's no handler method).
304  *
305  ******************************************************************************/
306 acpi_status acpi_mark_gpe_for_wake(acpi_handle gpe_device, u32 gpe_number)
307 {
308 	struct acpi_gpe_event_info *gpe_event_info;
309 	acpi_status status = AE_BAD_PARAMETER;
310 	acpi_cpu_flags flags;
311 
312 	ACPI_FUNCTION_TRACE(acpi_mark_gpe_for_wake);
313 
314 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
315 
316 	/* Ensure that we have a valid GPE number */
317 
318 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
319 	if (gpe_event_info) {
320 
321 		/* Mark the GPE as a possible wake event */
322 
323 		gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
324 		status = AE_OK;
325 	}
326 
327 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
328 	return_ACPI_STATUS(status);
329 }
330 
ACPI_EXPORT_SYMBOL(acpi_mark_gpe_for_wake)331 ACPI_EXPORT_SYMBOL(acpi_mark_gpe_for_wake)
332 
333 /*******************************************************************************
334  *
335  * FUNCTION:    acpi_setup_gpe_for_wake
336  *
337  * PARAMETERS:  wake_device         - Device associated with the GPE (via _PRW)
338  *              gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
339  *              gpe_number          - GPE level within the GPE block
340  *
341  * RETURN:      Status
342  *
343  * DESCRIPTION: Mark a GPE as having the ability to wake the system. This
344  *              interface is intended to be used as the host executes the
345  *              _PRW methods (Power Resources for Wake) in the system tables.
346  *              Each _PRW appears under a Device Object (The wake_device), and
347  *              contains the info for the wake GPE associated with the
348  *              wake_device.
349  *
350  ******************************************************************************/
351 acpi_status
352 acpi_setup_gpe_for_wake(acpi_handle wake_device,
353 			acpi_handle gpe_device, u32 gpe_number)
354 {
355 	acpi_status status;
356 	struct acpi_gpe_event_info *gpe_event_info;
357 	struct acpi_namespace_node *device_node;
358 	struct acpi_gpe_notify_info *notify;
359 	struct acpi_gpe_notify_info *new_notify;
360 	acpi_cpu_flags flags;
361 
362 	ACPI_FUNCTION_TRACE(acpi_setup_gpe_for_wake);
363 
364 	/* Parameter Validation */
365 
366 	if (!wake_device) {
367 		/*
368 		 * By forcing wake_device to be valid, we automatically enable the
369 		 * implicit notify feature on all hosts.
370 		 */
371 		return_ACPI_STATUS(AE_BAD_PARAMETER);
372 	}
373 
374 	/* Handle root object case */
375 
376 	if (wake_device == ACPI_ROOT_OBJECT) {
377 		device_node = acpi_gbl_root_node;
378 	} else {
379 		device_node =
380 		    ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
381 	}
382 
383 	/* Validate wake_device is of type Device */
384 
385 	if (device_node->type != ACPI_TYPE_DEVICE) {
386 		return_ACPI_STATUS (AE_BAD_PARAMETER);
387 	}
388 
389 	/*
390 	 * Allocate a new notify object up front, in case it is needed.
391 	 * Memory allocation while holding a spinlock is a big no-no
392 	 * on some hosts.
393 	 */
394 	new_notify = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_notify_info));
395 	if (!new_notify) {
396 		return_ACPI_STATUS(AE_NO_MEMORY);
397 	}
398 
399 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
400 
401 	/* Ensure that we have a valid GPE number */
402 
403 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
404 	if (!gpe_event_info) {
405 		status = AE_BAD_PARAMETER;
406 		goto unlock_and_exit;
407 	}
408 
409 	/*
410 	 * If there is no method or handler for this GPE, then the
411 	 * wake_device will be notified whenever this GPE fires. This is
412 	 * known as an "implicit notify". Note: The GPE is assumed to be
413 	 * level-triggered (for windows compatibility).
414 	 */
415 	if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
416 	    ACPI_GPE_DISPATCH_NONE) {
417 		/*
418 		 * This is the first device for implicit notify on this GPE.
419 		 * Just set the flags here, and enter the NOTIFY block below.
420 		 */
421 		gpe_event_info->flags =
422 		    (ACPI_GPE_DISPATCH_NOTIFY | ACPI_GPE_LEVEL_TRIGGERED);
423 	} else if (gpe_event_info->flags & ACPI_GPE_AUTO_ENABLED) {
424 		/*
425 		 * A reference to this GPE has been added during the GPE block
426 		 * initialization, so drop it now to prevent the GPE from being
427 		 * permanently enabled and clear its ACPI_GPE_AUTO_ENABLED flag.
428 		 */
429 		(void)acpi_ev_remove_gpe_reference(gpe_event_info);
430 		gpe_event_info->flags &= ~ACPI_GPE_AUTO_ENABLED;
431 	}
432 
433 	/*
434 	 * If we already have an implicit notify on this GPE, add
435 	 * this device to the notify list.
436 	 */
437 	if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
438 	    ACPI_GPE_DISPATCH_NOTIFY) {
439 
440 		/* Ensure that the device is not already in the list */
441 
442 		notify = gpe_event_info->dispatch.notify_list;
443 		while (notify) {
444 			if (notify->device_node == device_node) {
445 				status = AE_ALREADY_EXISTS;
446 				goto unlock_and_exit;
447 			}
448 			notify = notify->next;
449 		}
450 
451 		/* Add this device to the notify list for this GPE */
452 
453 		new_notify->device_node = device_node;
454 		new_notify->next = gpe_event_info->dispatch.notify_list;
455 		gpe_event_info->dispatch.notify_list = new_notify;
456 		new_notify = NULL;
457 	}
458 
459 	/* Mark the GPE as a possible wake event */
460 
461 	gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
462 	status = AE_OK;
463 
464 unlock_and_exit:
465 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
466 
467 	/* Delete the notify object if it was not used above */
468 
469 	if (new_notify) {
470 		ACPI_FREE(new_notify);
471 	}
472 	return_ACPI_STATUS(status);
473 }
ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)474 ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)
475 
476 /*******************************************************************************
477  *
478  * FUNCTION:    acpi_set_gpe_wake_mask
479  *
480  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
481  *              gpe_number      - GPE level within the GPE block
482  *              action              - Enable or Disable
483  *
484  * RETURN:      Status
485  *
486  * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit. The GPE must
487  *              already be marked as a WAKE GPE.
488  *
489  ******************************************************************************/
490 
491 acpi_status
492 acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
493 {
494 	acpi_status status = AE_OK;
495 	struct acpi_gpe_event_info *gpe_event_info;
496 	struct acpi_gpe_register_info *gpe_register_info;
497 	acpi_cpu_flags flags;
498 	u32 register_bit;
499 
500 	ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask);
501 
502 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
503 
504 	/*
505 	 * Ensure that we have a valid GPE number and that this GPE is in
506 	 * fact a wake GPE
507 	 */
508 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
509 	if (!gpe_event_info) {
510 		status = AE_BAD_PARAMETER;
511 		goto unlock_and_exit;
512 	}
513 
514 	if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
515 		status = AE_TYPE;
516 		goto unlock_and_exit;
517 	}
518 
519 	gpe_register_info = gpe_event_info->register_info;
520 	if (!gpe_register_info) {
521 		status = AE_NOT_EXIST;
522 		goto unlock_and_exit;
523 	}
524 
525 	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
526 
527 	/* Perform the action */
528 
529 	switch (action) {
530 	case ACPI_GPE_ENABLE:
531 
532 		ACPI_SET_BIT(gpe_register_info->enable_for_wake,
533 			     (u8)register_bit);
534 		break;
535 
536 	case ACPI_GPE_DISABLE:
537 
538 		ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
539 			       (u8)register_bit);
540 		break;
541 
542 	default:
543 
544 		ACPI_ERROR((AE_INFO, "%u, Invalid action", action));
545 		status = AE_BAD_PARAMETER;
546 		break;
547 	}
548 
549 unlock_and_exit:
550 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
551 	return_ACPI_STATUS(status);
552 }
553 
ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask)554 ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask)
555 
556 /*******************************************************************************
557  *
558  * FUNCTION:    acpi_clear_gpe
559  *
560  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
561  *              gpe_number      - GPE level within the GPE block
562  *
563  * RETURN:      Status
564  *
565  * DESCRIPTION: Clear an ACPI event (general purpose)
566  *
567  ******************************************************************************/
568 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
569 {
570 	acpi_status status = AE_OK;
571 	struct acpi_gpe_event_info *gpe_event_info;
572 	acpi_cpu_flags flags;
573 
574 	ACPI_FUNCTION_TRACE(acpi_clear_gpe);
575 
576 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
577 
578 	/* Ensure that we have a valid GPE number */
579 
580 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
581 	if (!gpe_event_info) {
582 		status = AE_BAD_PARAMETER;
583 		goto unlock_and_exit;
584 	}
585 
586 	status = acpi_hw_clear_gpe(gpe_event_info);
587 
588       unlock_and_exit:
589 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
590 	return_ACPI_STATUS(status);
591 }
592 
ACPI_EXPORT_SYMBOL(acpi_clear_gpe)593 ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
594 
595 /*******************************************************************************
596  *
597  * FUNCTION:    acpi_get_gpe_status
598  *
599  * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
600  *              gpe_number          - GPE level within the GPE block
601  *              event_status        - Where the current status of the event
602  *                                    will be returned
603  *
604  * RETURN:      Status
605  *
606  * DESCRIPTION: Get the current status of a GPE (signalled/not_signalled)
607  *
608  ******************************************************************************/
609 acpi_status
610 acpi_get_gpe_status(acpi_handle gpe_device,
611 		    u32 gpe_number, acpi_event_status *event_status)
612 {
613 	acpi_status status = AE_OK;
614 	struct acpi_gpe_event_info *gpe_event_info;
615 	acpi_cpu_flags flags;
616 
617 	ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
618 
619 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
620 
621 	/* Ensure that we have a valid GPE number */
622 
623 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
624 	if (!gpe_event_info) {
625 		status = AE_BAD_PARAMETER;
626 		goto unlock_and_exit;
627 	}
628 
629 	/* Obtain status on the requested GPE number */
630 
631 	status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
632 
633 unlock_and_exit:
634 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
635 	return_ACPI_STATUS(status);
636 }
637 
ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)638 ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
639 
640 /*******************************************************************************
641  *
642  * FUNCTION:    acpi_gispatch_gpe
643  *
644  * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
645  *              gpe_number          - GPE level within the GPE block
646  *
647  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
648  *
649  * DESCRIPTION: Detect and dispatch a General Purpose Event to either a function
650  *              (e.g. EC) or method (e.g. _Lxx/_Exx) handler.
651  *
652  ******************************************************************************/
653 u32 acpi_dispatch_gpe(acpi_handle gpe_device, u32 gpe_number)
654 {
655 	ACPI_FUNCTION_TRACE(acpi_dispatch_gpe);
656 
657 	return acpi_ev_detect_gpe(gpe_device, NULL, gpe_number);
658 }
659 
ACPI_EXPORT_SYMBOL(acpi_dispatch_gpe)660 ACPI_EXPORT_SYMBOL(acpi_dispatch_gpe)
661 
662 /*******************************************************************************
663  *
664  * FUNCTION:    acpi_finish_gpe
665  *
666  * PARAMETERS:  gpe_device          - Namespace node for the GPE Block
667  *                                    (NULL for FADT defined GPEs)
668  *              gpe_number          - GPE level within the GPE block
669  *
670  * RETURN:      Status
671  *
672  * DESCRIPTION: Clear and conditionally re-enable a GPE. This completes the GPE
673  *              processing. Intended for use by asynchronous host-installed
674  *              GPE handlers. The GPE is only re-enabled if the enable_for_run bit
675  *              is set in the GPE info.
676  *
677  ******************************************************************************/
678 acpi_status acpi_finish_gpe(acpi_handle gpe_device, u32 gpe_number)
679 {
680 	struct acpi_gpe_event_info *gpe_event_info;
681 	acpi_status status;
682 	acpi_cpu_flags flags;
683 
684 	ACPI_FUNCTION_TRACE(acpi_finish_gpe);
685 
686 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
687 
688 	/* Ensure that we have a valid GPE number */
689 
690 	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
691 	if (!gpe_event_info) {
692 		status = AE_BAD_PARAMETER;
693 		goto unlock_and_exit;
694 	}
695 
696 	status = acpi_ev_finish_gpe(gpe_event_info);
697 
698 unlock_and_exit:
699 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
700 	return_ACPI_STATUS(status);
701 }
702 
ACPI_EXPORT_SYMBOL(acpi_finish_gpe)703 ACPI_EXPORT_SYMBOL(acpi_finish_gpe)
704 
705 /******************************************************************************
706  *
707  * FUNCTION:    acpi_disable_all_gpes
708  *
709  * PARAMETERS:  None
710  *
711  * RETURN:      Status
712  *
713  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
714  *
715  ******************************************************************************/
716 
717 acpi_status acpi_disable_all_gpes(void)
718 {
719 	acpi_status status;
720 
721 	ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
722 
723 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
724 	if (ACPI_FAILURE(status)) {
725 		return_ACPI_STATUS(status);
726 	}
727 
728 	status = acpi_hw_disable_all_gpes();
729 	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
730 
731 	return_ACPI_STATUS(status);
732 }
733 
ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)734 ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)
735 
736 /******************************************************************************
737  *
738  * FUNCTION:    acpi_enable_all_runtime_gpes
739  *
740  * PARAMETERS:  None
741  *
742  * RETURN:      Status
743  *
744  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
745  *
746  ******************************************************************************/
747 
748 acpi_status acpi_enable_all_runtime_gpes(void)
749 {
750 	acpi_status status;
751 
752 	ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
753 
754 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
755 	if (ACPI_FAILURE(status)) {
756 		return_ACPI_STATUS(status);
757 	}
758 
759 	status = acpi_hw_enable_all_runtime_gpes();
760 	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
761 
762 	return_ACPI_STATUS(status);
763 }
764 
ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)765 ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)
766 
767 /******************************************************************************
768  *
769  * FUNCTION:    acpi_enable_all_wakeup_gpes
770  *
771  * PARAMETERS:  None
772  *
773  * RETURN:      Status
774  *
775  * DESCRIPTION: Enable all "wakeup" GPEs and disable all of the other GPEs, in
776  *              all GPE blocks.
777  *
778  ******************************************************************************/
779 acpi_status acpi_enable_all_wakeup_gpes(void)
780 {
781 	acpi_status status;
782 
783 	ACPI_FUNCTION_TRACE(acpi_enable_all_wakeup_gpes);
784 
785 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
786 	if (ACPI_FAILURE(status)) {
787 		return_ACPI_STATUS(status);
788 	}
789 
790 	status = acpi_hw_enable_all_wakeup_gpes();
791 	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
792 
793 	return_ACPI_STATUS(status);
794 }
795 
ACPI_EXPORT_SYMBOL(acpi_enable_all_wakeup_gpes)796 ACPI_EXPORT_SYMBOL(acpi_enable_all_wakeup_gpes)
797 
798 /******************************************************************************
799  *
800  * FUNCTION:    acpi_any_gpe_status_set
801  *
802  * PARAMETERS:  gpe_skip_number      - Number of the GPE to skip
803  *
804  * RETURN:      Whether or not the status bit is set for any GPE
805  *
806  * DESCRIPTION: Check the status bits of all enabled GPEs, except for the one
807  *              represented by the "skip" argument, and return TRUE if any of
808  *              them is set or FALSE otherwise.
809  *
810  ******************************************************************************/
811 u32 acpi_any_gpe_status_set(u32 gpe_skip_number)
812 {
813 	acpi_status status;
814 	acpi_handle gpe_device;
815 	u8 ret;
816 
817 	ACPI_FUNCTION_TRACE(acpi_any_gpe_status_set);
818 
819 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
820 	if (ACPI_FAILURE(status)) {
821 		return (FALSE);
822 	}
823 
824 	status = acpi_get_gpe_device(gpe_skip_number, &gpe_device);
825 	if (ACPI_FAILURE(status)) {
826 		gpe_device = NULL;
827 	}
828 
829 	ret = acpi_hw_check_all_gpes(gpe_device, gpe_skip_number);
830 	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
831 
832 	return (ret);
833 }
834 
ACPI_EXPORT_SYMBOL(acpi_any_gpe_status_set)835 ACPI_EXPORT_SYMBOL(acpi_any_gpe_status_set)
836 
837 /*******************************************************************************
838  *
839  * FUNCTION:    acpi_install_gpe_block
840  *
841  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
842  *              gpe_block_address   - Address and space_ID
843  *              register_count      - Number of GPE register pairs in the block
844  *              interrupt_number    - H/W interrupt for the block
845  *
846  * RETURN:      Status
847  *
848  * DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not
849  *              enabled here.
850  *
851  ******************************************************************************/
852 acpi_status
853 acpi_install_gpe_block(acpi_handle gpe_device,
854 		       struct acpi_generic_address *gpe_block_address,
855 		       u32 register_count, u32 interrupt_number)
856 {
857 	acpi_status status;
858 	union acpi_operand_object *obj_desc;
859 	struct acpi_namespace_node *node;
860 	struct acpi_gpe_block_info *gpe_block;
861 
862 	ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
863 
864 	if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
865 		return_ACPI_STATUS(AE_BAD_PARAMETER);
866 	}
867 
868 	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
869 	if (ACPI_FAILURE(status)) {
870 		return_ACPI_STATUS(status);
871 	}
872 
873 	node = acpi_ns_validate_handle(gpe_device);
874 	if (!node) {
875 		status = AE_BAD_PARAMETER;
876 		goto unlock_and_exit;
877 	}
878 
879 	/* Validate the parent device */
880 
881 	if (node->type != ACPI_TYPE_DEVICE) {
882 		status = AE_TYPE;
883 		goto unlock_and_exit;
884 	}
885 
886 	if (node->object) {
887 		status = AE_ALREADY_EXISTS;
888 		goto unlock_and_exit;
889 	}
890 
891 	/*
892 	 * For user-installed GPE Block Devices, the gpe_block_base_number
893 	 * is always zero
894 	 */
895 	status = acpi_ev_create_gpe_block(node, gpe_block_address->address,
896 					  gpe_block_address->space_id,
897 					  register_count, 0, interrupt_number,
898 					  &gpe_block);
899 	if (ACPI_FAILURE(status)) {
900 		goto unlock_and_exit;
901 	}
902 
903 	/* Install block in the device_object attached to the node */
904 
905 	obj_desc = acpi_ns_get_attached_object(node);
906 	if (!obj_desc) {
907 
908 		/*
909 		 * No object, create a new one (Device nodes do not always have
910 		 * an attached object)
911 		 */
912 		obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
913 		if (!obj_desc) {
914 			status = AE_NO_MEMORY;
915 			goto unlock_and_exit;
916 		}
917 
918 		status =
919 		    acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
920 
921 		/* Remove local reference to the object */
922 
923 		acpi_ut_remove_reference(obj_desc);
924 
925 		if (ACPI_FAILURE(status)) {
926 			goto unlock_and_exit;
927 		}
928 	}
929 
930 	/* Now install the GPE block in the device_object */
931 
932 	obj_desc->device.gpe_block = gpe_block;
933 
934 unlock_and_exit:
935 	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
936 	return_ACPI_STATUS(status);
937 }
938 
ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)939 ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
940 
941 /*******************************************************************************
942  *
943  * FUNCTION:    acpi_remove_gpe_block
944  *
945  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
946  *
947  * RETURN:      Status
948  *
949  * DESCRIPTION: Remove a previously installed block of GPE registers
950  *
951  ******************************************************************************/
952 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
953 {
954 	union acpi_operand_object *obj_desc;
955 	acpi_status status;
956 	struct acpi_namespace_node *node;
957 
958 	ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
959 
960 	if (!gpe_device) {
961 		return_ACPI_STATUS(AE_BAD_PARAMETER);
962 	}
963 
964 	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
965 	if (ACPI_FAILURE(status)) {
966 		return_ACPI_STATUS(status);
967 	}
968 
969 	node = acpi_ns_validate_handle(gpe_device);
970 	if (!node) {
971 		status = AE_BAD_PARAMETER;
972 		goto unlock_and_exit;
973 	}
974 
975 	/* Validate the parent device */
976 
977 	if (node->type != ACPI_TYPE_DEVICE) {
978 		status = AE_TYPE;
979 		goto unlock_and_exit;
980 	}
981 
982 	/* Get the device_object attached to the node */
983 
984 	obj_desc = acpi_ns_get_attached_object(node);
985 	if (!obj_desc || !obj_desc->device.gpe_block) {
986 		return_ACPI_STATUS(AE_NULL_OBJECT);
987 	}
988 
989 	/* Delete the GPE block (but not the device_object) */
990 
991 	status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
992 	if (ACPI_SUCCESS(status)) {
993 		obj_desc->device.gpe_block = NULL;
994 	}
995 
996 unlock_and_exit:
997 	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
998 	return_ACPI_STATUS(status);
999 }
1000 
ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)1001 ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
1002 
1003 /*******************************************************************************
1004  *
1005  * FUNCTION:    acpi_get_gpe_device
1006  *
1007  * PARAMETERS:  index               - System GPE index (0-current_gpe_count)
1008  *              gpe_device          - Where the parent GPE Device is returned
1009  *
1010  * RETURN:      Status
1011  *
1012  * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
1013  *              gpe device indicates that the gpe number is contained in one of
1014  *              the FADT-defined gpe blocks. Otherwise, the GPE block device.
1015  *
1016  ******************************************************************************/
1017 acpi_status acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)
1018 {
1019 	struct acpi_gpe_device_info info;
1020 	acpi_status status;
1021 
1022 	ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
1023 
1024 	if (!gpe_device) {
1025 		return_ACPI_STATUS(AE_BAD_PARAMETER);
1026 	}
1027 
1028 	if (index >= acpi_current_gpe_count) {
1029 		return_ACPI_STATUS(AE_NOT_EXIST);
1030 	}
1031 
1032 	/* Setup and walk the GPE list */
1033 
1034 	info.index = index;
1035 	info.status = AE_NOT_EXIST;
1036 	info.gpe_device = NULL;
1037 	info.next_block_base_index = 0;
1038 
1039 	status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
1040 	if (ACPI_FAILURE(status)) {
1041 		return_ACPI_STATUS(status);
1042 	}
1043 
1044 	*gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device);
1045 	return_ACPI_STATUS(info.status);
1046 }
1047 
1048 ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
1049 #endif				/* !ACPI_REDUCED_HARDWARE */
1050