1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
4 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
6 * Copyright (C) 2000 - 2021, Intel Corp.
8 *****************************************************************************/
10 #include <acpi/acpi.h>
14 #define _COMPONENT ACPI_HARDWARE
15 ACPI_MODULE_NAME("hwgpe")
16 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
17 /* Local prototypes */
19 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
20 struct acpi_gpe_block_info *gpe_block,
24 acpi_hw_gpe_enable_write(u8 enable_mask,
25 struct acpi_gpe_register_info *gpe_register_info);
27 /******************************************************************************
29 * FUNCTION: acpi_hw_gpe_read
31 * PARAMETERS: value - Where the value is returned
32 * reg - GPE register structure
36 * DESCRIPTION: Read from a GPE register in either memory or IO space.
38 * LIMITATIONS: <These limitations also apply to acpi_hw_gpe_write>
39 * space_ID must be system_memory or system_IO.
41 ******************************************************************************/
43 acpi_status acpi_hw_gpe_read(u64 *value, struct acpi_gpe_address *reg)
48 if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
49 #ifdef ACPI_GPE_USE_LOGICAL_ADDRESSES
50 *value = (u64)ACPI_GET8((unsigned long)reg->address);
51 return_ACPI_STATUS(AE_OK);
53 return acpi_os_read_memory((acpi_physical_address)reg->address,
54 value, ACPI_GPE_REGISTER_WIDTH);
58 status = acpi_os_read_port((acpi_io_address)reg->address,
59 &value32, ACPI_GPE_REGISTER_WIDTH);
60 if (ACPI_FAILURE(status))
61 return_ACPI_STATUS(status);
63 *value = (u64)value32;
65 return_ACPI_STATUS(AE_OK);
68 /******************************************************************************
70 * FUNCTION: acpi_hw_gpe_write
72 * PARAMETERS: value - Value to be written
73 * reg - GPE register structure
77 * DESCRIPTION: Write to a GPE register in either memory or IO space.
79 ******************************************************************************/
81 acpi_status acpi_hw_gpe_write(u64 value, struct acpi_gpe_address *reg)
83 if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
84 #ifdef ACPI_GPE_USE_LOGICAL_ADDRESSES
85 ACPI_SET8((unsigned long)reg->address, value);
86 return_ACPI_STATUS(AE_OK);
88 return acpi_os_write_memory((acpi_physical_address)reg->address,
89 value, ACPI_GPE_REGISTER_WIDTH);
93 return acpi_os_write_port((acpi_io_address)reg->address, (u32)value,
94 ACPI_GPE_REGISTER_WIDTH);
97 /******************************************************************************
99 * FUNCTION: acpi_hw_get_gpe_register_bit
101 * PARAMETERS: gpe_event_info - Info block for the GPE
103 * RETURN: Register mask with a one in the GPE bit position
105 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
106 * correct position for the input GPE.
108 ******************************************************************************/
110 u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info)
114 (gpe_event_info->gpe_number -
115 gpe_event_info->register_info->base_gpe_number));
118 /******************************************************************************
120 * FUNCTION: acpi_hw_low_set_gpe
122 * PARAMETERS: gpe_event_info - Info block for the GPE to be disabled
123 * action - Enable or disable
127 * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
128 * The enable_mask field of the involved GPE register must be
129 * updated by the caller if necessary.
131 ******************************************************************************/
134 acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
136 struct acpi_gpe_register_info *gpe_register_info;
137 acpi_status status = AE_OK;
141 ACPI_FUNCTION_ENTRY();
143 /* Get the info block for the entire GPE register */
145 gpe_register_info = gpe_event_info->register_info;
146 if (!gpe_register_info) {
147 return (AE_NOT_EXIST);
150 /* Get current value of the enable register that contains this GPE */
152 status = acpi_hw_gpe_read(&enable_mask,
153 &gpe_register_info->enable_address);
154 if (ACPI_FAILURE(status)) {
158 /* Set or clear just the bit that corresponds to this GPE */
160 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
162 case ACPI_GPE_CONDITIONAL_ENABLE:
164 /* Only enable if the corresponding enable_mask bit is set */
166 if (!(register_bit & gpe_register_info->enable_mask)) {
167 return (AE_BAD_PARAMETER);
172 case ACPI_GPE_ENABLE:
174 ACPI_SET_BIT(enable_mask, register_bit);
177 case ACPI_GPE_DISABLE:
179 ACPI_CLEAR_BIT(enable_mask, register_bit);
184 ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u", action));
185 return (AE_BAD_PARAMETER);
188 if (!(register_bit & gpe_register_info->mask_for_run)) {
190 /* Write the updated enable mask */
192 status = acpi_hw_gpe_write(enable_mask,
193 &gpe_register_info->enable_address);
198 /******************************************************************************
200 * FUNCTION: acpi_hw_clear_gpe
202 * PARAMETERS: gpe_event_info - Info block for the GPE to be cleared
206 * DESCRIPTION: Clear the status bit for a single GPE.
208 ******************************************************************************/
210 acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info *gpe_event_info)
212 struct acpi_gpe_register_info *gpe_register_info;
216 ACPI_FUNCTION_ENTRY();
218 /* Get the info block for the entire GPE register */
220 gpe_register_info = gpe_event_info->register_info;
221 if (!gpe_register_info) {
222 return (AE_NOT_EXIST);
226 * Write a one to the appropriate bit in the status register to
229 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
231 status = acpi_hw_gpe_write(register_bit,
232 &gpe_register_info->status_address);
236 /******************************************************************************
238 * FUNCTION: acpi_hw_get_gpe_status
240 * PARAMETERS: gpe_event_info - Info block for the GPE to queried
241 * event_status - Where the GPE status is returned
245 * DESCRIPTION: Return the status of a single GPE.
247 ******************************************************************************/
250 acpi_hw_get_gpe_status(struct acpi_gpe_event_info *gpe_event_info,
251 acpi_event_status *event_status)
255 struct acpi_gpe_register_info *gpe_register_info;
256 acpi_event_status local_event_status = 0;
259 ACPI_FUNCTION_ENTRY();
262 return (AE_BAD_PARAMETER);
265 /* GPE currently handled? */
267 if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
268 ACPI_GPE_DISPATCH_NONE) {
269 local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
272 /* Get the info block for the entire GPE register */
274 gpe_register_info = gpe_event_info->register_info;
276 /* Get the register bitmask for this GPE */
278 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
280 /* GPE currently enabled? (enabled for runtime?) */
282 if (register_bit & gpe_register_info->enable_for_run) {
283 local_event_status |= ACPI_EVENT_FLAG_ENABLED;
286 /* GPE currently masked? (masked for runtime?) */
288 if (register_bit & gpe_register_info->mask_for_run) {
289 local_event_status |= ACPI_EVENT_FLAG_MASKED;
292 /* GPE enabled for wake? */
294 if (register_bit & gpe_register_info->enable_for_wake) {
295 local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
298 /* GPE currently enabled (enable bit == 1)? */
300 status = acpi_hw_gpe_read(&in_byte, &gpe_register_info->enable_address);
301 if (ACPI_FAILURE(status)) {
305 if (register_bit & in_byte) {
306 local_event_status |= ACPI_EVENT_FLAG_ENABLE_SET;
309 /* GPE currently active (status bit == 1)? */
311 status = acpi_hw_gpe_read(&in_byte, &gpe_register_info->status_address);
312 if (ACPI_FAILURE(status)) {
316 if (register_bit & in_byte) {
317 local_event_status |= ACPI_EVENT_FLAG_STATUS_SET;
320 /* Set return value */
322 (*event_status) = local_event_status;
326 /******************************************************************************
328 * FUNCTION: acpi_hw_gpe_enable_write
330 * PARAMETERS: enable_mask - Bit mask to write to the GPE register
331 * gpe_register_info - Gpe Register info
335 * DESCRIPTION: Write the enable mask byte to the given GPE register.
337 ******************************************************************************/
340 acpi_hw_gpe_enable_write(u8 enable_mask,
341 struct acpi_gpe_register_info *gpe_register_info)
345 gpe_register_info->enable_mask = enable_mask;
347 status = acpi_hw_gpe_write(enable_mask,
348 &gpe_register_info->enable_address);
352 /******************************************************************************
354 * FUNCTION: acpi_hw_disable_gpe_block
356 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
357 * gpe_block - Gpe Block info
361 * DESCRIPTION: Disable all GPEs within a single GPE block
363 ******************************************************************************/
366 acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
367 struct acpi_gpe_block_info *gpe_block, void *context)
372 /* Examine each GPE Register within the block */
374 for (i = 0; i < gpe_block->register_count; i++) {
376 /* Disable all GPEs in this register */
379 acpi_hw_gpe_enable_write(0x00,
380 &gpe_block->register_info[i]);
381 if (ACPI_FAILURE(status)) {
389 /******************************************************************************
391 * FUNCTION: acpi_hw_clear_gpe_block
393 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
394 * gpe_block - Gpe Block info
398 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
400 ******************************************************************************/
403 acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
404 struct acpi_gpe_block_info *gpe_block, void *context)
409 /* Examine each GPE Register within the block */
411 for (i = 0; i < gpe_block->register_count; i++) {
413 /* Clear status on all GPEs in this register */
415 status = acpi_hw_gpe_write(0xFF,
416 &gpe_block->register_info[i].status_address);
417 if (ACPI_FAILURE(status)) {
425 /******************************************************************************
427 * FUNCTION: acpi_hw_enable_runtime_gpe_block
429 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
430 * gpe_block - Gpe Block info
434 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
435 * combination wake/run GPEs.
437 ******************************************************************************/
440 acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
441 struct acpi_gpe_block_info *gpe_block,
446 struct acpi_gpe_register_info *gpe_register_info;
449 /* NOTE: assumes that all GPEs are currently disabled */
451 /* Examine each GPE Register within the block */
453 for (i = 0; i < gpe_block->register_count; i++) {
454 gpe_register_info = &gpe_block->register_info[i];
455 if (!gpe_register_info->enable_for_run) {
459 /* Enable all "runtime" GPEs in this register */
461 enable_mask = gpe_register_info->enable_for_run &
462 ~gpe_register_info->mask_for_run;
464 acpi_hw_gpe_enable_write(enable_mask, gpe_register_info);
465 if (ACPI_FAILURE(status)) {
473 /******************************************************************************
475 * FUNCTION: acpi_hw_enable_wakeup_gpe_block
477 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
478 * gpe_block - Gpe Block info
482 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
483 * combination wake/run GPEs.
485 ******************************************************************************/
488 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
489 struct acpi_gpe_block_info *gpe_block,
494 struct acpi_gpe_register_info *gpe_register_info;
496 /* Examine each GPE Register within the block */
498 for (i = 0; i < gpe_block->register_count; i++) {
499 gpe_register_info = &gpe_block->register_info[i];
502 * Enable all "wake" GPEs in this register and disable the
507 acpi_hw_gpe_enable_write(gpe_register_info->enable_for_wake,
509 if (ACPI_FAILURE(status)) {
517 struct acpi_gpe_block_status_context {
518 struct acpi_gpe_register_info *gpe_skip_register_info;
523 /******************************************************************************
525 * FUNCTION: acpi_hw_get_gpe_block_status
527 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
528 * gpe_block - Gpe Block info
529 * context - GPE list walk context data
533 * DESCRIPTION: Produce a combined GPE status bits mask for the given block.
535 ******************************************************************************/
538 acpi_hw_get_gpe_block_status(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
539 struct acpi_gpe_block_info *gpe_block,
542 struct acpi_gpe_block_status_context *c = context;
543 struct acpi_gpe_register_info *gpe_register_info;
544 u64 in_enable, in_status;
549 /* Examine each GPE Register within the block */
551 for (i = 0; i < gpe_block->register_count; i++) {
552 gpe_register_info = &gpe_block->register_info[i];
554 status = acpi_hw_gpe_read(&in_enable,
555 &gpe_register_info->enable_address);
556 if (ACPI_FAILURE(status)) {
560 status = acpi_hw_gpe_read(&in_status,
561 &gpe_register_info->status_address);
562 if (ACPI_FAILURE(status)) {
566 ret_mask = in_enable & in_status;
567 if (ret_mask && c->gpe_skip_register_info == gpe_register_info) {
568 ret_mask &= ~c->gpe_skip_mask;
570 c->retval |= ret_mask;
576 /******************************************************************************
578 * FUNCTION: acpi_hw_disable_all_gpes
584 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
586 ******************************************************************************/
588 acpi_status acpi_hw_disable_all_gpes(void)
592 ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
594 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
595 return_ACPI_STATUS(status);
598 /******************************************************************************
600 * FUNCTION: acpi_hw_enable_all_runtime_gpes
606 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
608 ******************************************************************************/
610 acpi_status acpi_hw_enable_all_runtime_gpes(void)
614 ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
616 status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
617 return_ACPI_STATUS(status);
620 /******************************************************************************
622 * FUNCTION: acpi_hw_enable_all_wakeup_gpes
628 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
630 ******************************************************************************/
632 acpi_status acpi_hw_enable_all_wakeup_gpes(void)
636 ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
638 status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
639 return_ACPI_STATUS(status);
642 /******************************************************************************
644 * FUNCTION: acpi_hw_check_all_gpes
646 * PARAMETERS: gpe_skip_device - GPE devoce of the GPE to skip
647 * gpe_skip_number - Number of the GPE to skip
649 * RETURN: Combined status of all GPEs
651 * DESCRIPTION: Check all enabled GPEs in all GPE blocks, except for the one
652 * represented by the "skip" arguments, and return TRUE if the
653 * status bit is set for at least one of them of FALSE otherwise.
655 ******************************************************************************/
657 u8 acpi_hw_check_all_gpes(acpi_handle gpe_skip_device, u32 gpe_skip_number)
659 struct acpi_gpe_block_status_context context = {
660 .gpe_skip_register_info = NULL,
663 struct acpi_gpe_event_info *gpe_event_info;
664 acpi_cpu_flags flags;
666 ACPI_FUNCTION_TRACE(acpi_hw_check_all_gpes);
668 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
670 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_skip_device,
672 if (gpe_event_info) {
673 context.gpe_skip_register_info = gpe_event_info->register_info;
674 context.gpe_skip_mask = acpi_hw_get_gpe_register_bit(gpe_event_info);
677 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
679 (void)acpi_ev_walk_gpe_list(acpi_hw_get_gpe_block_status, &context);
680 return (context.retval != 0);
683 #endif /* !ACPI_REDUCED_HARDWARE */