1 /******************************************************************************
3 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2015, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <acpi/acpi.h>
48 #define _COMPONENT ACPI_HARDWARE
49 ACPI_MODULE_NAME("hwgpe")
50 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
51 /* Local prototypes */
53 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
54 struct acpi_gpe_block_info *gpe_block,
58 acpi_hw_gpe_enable_write(u8 enable_mask,
59 struct acpi_gpe_register_info *gpe_register_info);
61 /******************************************************************************
63 * FUNCTION: acpi_hw_get_gpe_register_bit
65 * PARAMETERS: gpe_event_info - Info block for the GPE
67 * RETURN: Register mask with a one in the GPE bit position
69 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
70 * correct position for the input GPE.
72 ******************************************************************************/
74 u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info)
78 (gpe_event_info->gpe_number -
79 gpe_event_info->register_info->base_gpe_number));
82 /******************************************************************************
84 * FUNCTION: acpi_hw_low_set_gpe
86 * PARAMETERS: gpe_event_info - Info block for the GPE to be disabled
87 * action - Enable or disable
91 * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
93 ******************************************************************************/
96 acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
98 struct acpi_gpe_register_info *gpe_register_info;
103 ACPI_FUNCTION_ENTRY();
105 /* Get the info block for the entire GPE register */
107 gpe_register_info = gpe_event_info->register_info;
108 if (!gpe_register_info) {
109 return (AE_NOT_EXIST);
112 /* Get current value of the enable register that contains this GPE */
114 status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address);
115 if (ACPI_FAILURE(status)) {
119 /* Set or clear just the bit that corresponds to this GPE */
121 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
122 switch (action & ~ACPI_GPE_SAVE_MASK) {
123 case ACPI_GPE_CONDITIONAL_ENABLE:
125 /* Only enable if the corresponding enable_mask bit is set */
127 if (!(register_bit & gpe_register_info->enable_mask)) {
128 return (AE_BAD_PARAMETER);
131 /*lint -fallthrough */
133 case ACPI_GPE_ENABLE:
135 ACPI_SET_BIT(enable_mask, register_bit);
138 case ACPI_GPE_DISABLE:
140 ACPI_CLEAR_BIT(enable_mask, register_bit);
145 ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u", action));
146 return (AE_BAD_PARAMETER);
149 /* Write the updated enable mask */
151 status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
152 if (ACPI_SUCCESS(status) && (action & ACPI_GPE_SAVE_MASK)) {
153 gpe_register_info->enable_mask = (u8)enable_mask;
158 /******************************************************************************
160 * FUNCTION: acpi_hw_clear_gpe
162 * PARAMETERS: gpe_event_info - Info block for the GPE to be cleared
166 * DESCRIPTION: Clear the status bit for a single GPE.
168 ******************************************************************************/
170 acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
172 struct acpi_gpe_register_info *gpe_register_info;
176 ACPI_FUNCTION_ENTRY();
178 /* Get the info block for the entire GPE register */
180 gpe_register_info = gpe_event_info->register_info;
181 if (!gpe_register_info) {
182 return (AE_NOT_EXIST);
186 * Write a one to the appropriate bit in the status register to
189 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
191 status = acpi_hw_write(register_bit,
192 &gpe_register_info->status_address);
197 /******************************************************************************
199 * FUNCTION: acpi_hw_get_gpe_status
201 * PARAMETERS: gpe_event_info - Info block for the GPE to queried
202 * event_status - Where the GPE status is returned
206 * DESCRIPTION: Return the status of a single GPE.
208 ******************************************************************************/
211 acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
212 acpi_event_status *event_status)
216 struct acpi_gpe_register_info *gpe_register_info;
217 acpi_event_status local_event_status = 0;
220 ACPI_FUNCTION_ENTRY();
223 return (AE_BAD_PARAMETER);
226 /* GPE currently handled? */
228 if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
229 ACPI_GPE_DISPATCH_NONE) {
230 local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
233 /* Get the info block for the entire GPE register */
235 gpe_register_info = gpe_event_info->register_info;
237 /* Get the register bitmask for this GPE */
239 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
241 /* GPE currently enabled? (enabled for runtime?) */
243 if (register_bit & gpe_register_info->enable_for_run) {
244 local_event_status |= ACPI_EVENT_FLAG_ENABLED;
247 /* GPE enabled for wake? */
249 if (register_bit & gpe_register_info->enable_for_wake) {
250 local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
253 /* GPE currently active (status bit == 1)? */
255 status = acpi_hw_read(&in_byte, &gpe_register_info->status_address);
256 if (ACPI_FAILURE(status)) {
260 if (register_bit & in_byte) {
261 local_event_status |= ACPI_EVENT_FLAG_SET;
264 /* Set return value */
266 (*event_status) = local_event_status;
270 /******************************************************************************
272 * FUNCTION: acpi_hw_gpe_enable_write
274 * PARAMETERS: enable_mask - Bit mask to write to the GPE register
275 * gpe_register_info - Gpe Register info
279 * DESCRIPTION: Write the enable mask byte to the given GPE register.
281 ******************************************************************************/
284 acpi_hw_gpe_enable_write(u8 enable_mask,
285 struct acpi_gpe_register_info *gpe_register_info)
289 status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
290 if (ACPI_SUCCESS(status)) {
291 gpe_register_info->enable_mask = enable_mask;
296 /******************************************************************************
298 * FUNCTION: acpi_hw_disable_gpe_block
300 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
301 * gpe_block - Gpe Block info
305 * DESCRIPTION: Disable all GPEs within a single GPE block
307 ******************************************************************************/
310 acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
311 struct acpi_gpe_block_info *gpe_block, void *context)
316 /* Examine each GPE Register within the block */
318 for (i = 0; i < gpe_block->register_count; i++) {
320 /* Disable all GPEs in this register */
323 acpi_hw_gpe_enable_write(0x00,
324 &gpe_block->register_info[i]);
325 if (ACPI_FAILURE(status)) {
333 /******************************************************************************
335 * FUNCTION: acpi_hw_clear_gpe_block
337 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
338 * gpe_block - Gpe Block info
342 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
344 ******************************************************************************/
347 acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
348 struct acpi_gpe_block_info *gpe_block, void *context)
353 /* Examine each GPE Register within the block */
355 for (i = 0; i < gpe_block->register_count; i++) {
357 /* Clear status on all GPEs in this register */
361 &gpe_block->register_info[i].status_address);
362 if (ACPI_FAILURE(status)) {
370 /******************************************************************************
372 * FUNCTION: acpi_hw_enable_runtime_gpe_block
374 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
375 * gpe_block - Gpe Block info
379 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
380 * combination wake/run GPEs.
382 ******************************************************************************/
385 acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
386 struct acpi_gpe_block_info * gpe_block,
391 struct acpi_gpe_register_info *gpe_register_info;
393 /* NOTE: assumes that all GPEs are currently disabled */
395 /* Examine each GPE Register within the block */
397 for (i = 0; i < gpe_block->register_count; i++) {
398 gpe_register_info = &gpe_block->register_info[i];
399 if (!gpe_register_info->enable_for_run) {
403 /* Enable all "runtime" GPEs in this register */
406 acpi_hw_gpe_enable_write(gpe_register_info->enable_for_run,
408 if (ACPI_FAILURE(status)) {
416 /******************************************************************************
418 * FUNCTION: acpi_hw_enable_wakeup_gpe_block
420 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
421 * gpe_block - Gpe Block info
425 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
426 * combination wake/run GPEs.
428 ******************************************************************************/
431 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
432 struct acpi_gpe_block_info *gpe_block,
437 struct acpi_gpe_register_info *gpe_register_info;
439 /* Examine each GPE Register within the block */
441 for (i = 0; i < gpe_block->register_count; i++) {
442 gpe_register_info = &gpe_block->register_info[i];
445 * Enable all "wake" GPEs in this register and disable the
450 acpi_hw_gpe_enable_write(gpe_register_info->enable_for_wake,
452 if (ACPI_FAILURE(status)) {
460 /******************************************************************************
462 * FUNCTION: acpi_hw_disable_all_gpes
468 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
470 ******************************************************************************/
472 acpi_status acpi_hw_disable_all_gpes(void)
476 ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
478 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
479 status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
480 return_ACPI_STATUS(status);
483 /******************************************************************************
485 * FUNCTION: acpi_hw_enable_all_runtime_gpes
491 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
493 ******************************************************************************/
495 acpi_status acpi_hw_enable_all_runtime_gpes(void)
499 ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
501 status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
502 return_ACPI_STATUS(status);
505 /******************************************************************************
507 * FUNCTION: acpi_hw_enable_all_wakeup_gpes
513 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
515 ******************************************************************************/
517 acpi_status acpi_hw_enable_all_wakeup_gpes(void)
521 ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
523 status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
524 return_ACPI_STATUS(status);
527 #endif /* !ACPI_REDUCED_HARDWARE */