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 enabled (enable bit == 1)? */
255 status = acpi_hw_read(&in_byte, &gpe_register_info->enable_address);
256 if (ACPI_FAILURE(status)) {
260 if (register_bit & in_byte) {
261 local_event_status |= ACPI_EVENT_FLAG_ENABLE_SET;
264 /* GPE currently active (status bit == 1)? */
266 status = acpi_hw_read(&in_byte, &gpe_register_info->status_address);
267 if (ACPI_FAILURE(status)) {
271 if (register_bit & in_byte) {
272 local_event_status |= ACPI_EVENT_FLAG_STATUS_SET;
275 /* Set return value */
277 (*event_status) = local_event_status;
281 /******************************************************************************
283 * FUNCTION: acpi_hw_gpe_enable_write
285 * PARAMETERS: enable_mask - Bit mask to write to the GPE register
286 * gpe_register_info - Gpe Register info
290 * DESCRIPTION: Write the enable mask byte to the given GPE register.
292 ******************************************************************************/
295 acpi_hw_gpe_enable_write(u8 enable_mask,
296 struct acpi_gpe_register_info *gpe_register_info)
300 status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
301 if (ACPI_SUCCESS(status)) {
302 gpe_register_info->enable_mask = enable_mask;
307 /******************************************************************************
309 * FUNCTION: acpi_hw_disable_gpe_block
311 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
312 * gpe_block - Gpe Block info
316 * DESCRIPTION: Disable all GPEs within a single GPE block
318 ******************************************************************************/
321 acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
322 struct acpi_gpe_block_info *gpe_block, void *context)
327 /* Examine each GPE Register within the block */
329 for (i = 0; i < gpe_block->register_count; i++) {
331 /* Disable all GPEs in this register */
334 acpi_hw_gpe_enable_write(0x00,
335 &gpe_block->register_info[i]);
336 if (ACPI_FAILURE(status)) {
344 /******************************************************************************
346 * FUNCTION: acpi_hw_clear_gpe_block
348 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
349 * gpe_block - Gpe Block info
353 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
355 ******************************************************************************/
358 acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
359 struct acpi_gpe_block_info *gpe_block, void *context)
364 /* Examine each GPE Register within the block */
366 for (i = 0; i < gpe_block->register_count; i++) {
368 /* Clear status on all GPEs in this register */
372 &gpe_block->register_info[i].status_address);
373 if (ACPI_FAILURE(status)) {
381 /******************************************************************************
383 * FUNCTION: acpi_hw_enable_runtime_gpe_block
385 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
386 * gpe_block - Gpe Block info
390 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
391 * combination wake/run GPEs.
393 ******************************************************************************/
396 acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
397 struct acpi_gpe_block_info * gpe_block,
402 struct acpi_gpe_register_info *gpe_register_info;
404 /* NOTE: assumes that all GPEs are currently disabled */
406 /* Examine each GPE Register within the block */
408 for (i = 0; i < gpe_block->register_count; i++) {
409 gpe_register_info = &gpe_block->register_info[i];
410 if (!gpe_register_info->enable_for_run) {
414 /* Enable all "runtime" GPEs in this register */
417 acpi_hw_gpe_enable_write(gpe_register_info->enable_for_run,
419 if (ACPI_FAILURE(status)) {
427 /******************************************************************************
429 * FUNCTION: acpi_hw_enable_wakeup_gpe_block
431 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
432 * gpe_block - Gpe Block info
436 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
437 * combination wake/run GPEs.
439 ******************************************************************************/
442 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
443 struct acpi_gpe_block_info *gpe_block,
448 struct acpi_gpe_register_info *gpe_register_info;
450 /* Examine each GPE Register within the block */
452 for (i = 0; i < gpe_block->register_count; i++) {
453 gpe_register_info = &gpe_block->register_info[i];
456 * Enable all "wake" GPEs in this register and disable the
461 acpi_hw_gpe_enable_write(gpe_register_info->enable_for_wake,
463 if (ACPI_FAILURE(status)) {
471 /******************************************************************************
473 * FUNCTION: acpi_hw_disable_all_gpes
479 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
481 ******************************************************************************/
483 acpi_status acpi_hw_disable_all_gpes(void)
487 ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
489 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
490 status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
491 return_ACPI_STATUS(status);
494 /******************************************************************************
496 * FUNCTION: acpi_hw_enable_all_runtime_gpes
502 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
504 ******************************************************************************/
506 acpi_status acpi_hw_enable_all_runtime_gpes(void)
510 ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
512 status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
513 return_ACPI_STATUS(status);
516 /******************************************************************************
518 * FUNCTION: acpi_hw_enable_all_wakeup_gpes
524 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
526 ******************************************************************************/
528 acpi_status acpi_hw_enable_all_wakeup_gpes(void)
532 ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
534 status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
535 return_ACPI_STATUS(status);
538 #endif /* !ACPI_REDUCED_HARDWARE */