Loading...
1
2/******************************************************************************
3 *
4 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45#include <acpi/acpi.h>
46#include "accommon.h"
47#include "acevents.h"
48
49#define _COMPONENT ACPI_HARDWARE
50ACPI_MODULE_NAME("hwgpe")
51
52/* Local prototypes */
53static acpi_status
54acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
55 struct acpi_gpe_block_info *gpe_block,
56 void *context);
57
58/******************************************************************************
59 *
60 * FUNCTION: acpi_hw_get_gpe_register_bit
61 *
62 * PARAMETERS: gpe_event_info - Info block for the GPE
63 * gpe_register_info - Info block for the GPE register
64 *
65 * RETURN: Register mask with a one in the GPE bit position
66 *
67 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
68 * correct position for the input GPE.
69 *
70 ******************************************************************************/
71
72u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info,
73 struct acpi_gpe_register_info *gpe_register_info)
74{
75 return (u32)1 << (gpe_event_info->gpe_number -
76 gpe_register_info->base_gpe_number);
77}
78
79/******************************************************************************
80 *
81 * FUNCTION: acpi_hw_low_set_gpe
82 *
83 * PARAMETERS: gpe_event_info - Info block for the GPE to be disabled
84 * action - Enable or disable
85 *
86 * RETURN: Status
87 *
88 * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
89 *
90 ******************************************************************************/
91
92acpi_status
93acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
94{
95 struct acpi_gpe_register_info *gpe_register_info;
96 acpi_status status;
97 u32 enable_mask;
98 u32 register_bit;
99
100 ACPI_FUNCTION_ENTRY();
101
102 /* Get the info block for the entire GPE register */
103
104 gpe_register_info = gpe_event_info->register_info;
105 if (!gpe_register_info) {
106 return (AE_NOT_EXIST);
107 }
108
109 /* Get current value of the enable register that contains this GPE */
110
111 status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address);
112 if (ACPI_FAILURE(status)) {
113 return (status);
114 }
115
116 /* Set or clear just the bit that corresponds to this GPE */
117
118 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info,
119 gpe_register_info);
120 switch (action) {
121 case ACPI_GPE_CONDITIONAL_ENABLE:
122
123 /* Only enable if the enable_for_run bit is set */
124
125 if (!(register_bit & gpe_register_info->enable_for_run)) {
126 return (AE_BAD_PARAMETER);
127 }
128
129 /*lint -fallthrough */
130
131 case ACPI_GPE_ENABLE:
132 ACPI_SET_BIT(enable_mask, register_bit);
133 break;
134
135 case ACPI_GPE_DISABLE:
136 ACPI_CLEAR_BIT(enable_mask, register_bit);
137 break;
138
139 default:
140 ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u\n", action));
141 return (AE_BAD_PARAMETER);
142 }
143
144 /* Write the updated enable mask */
145
146 status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
147 return (status);
148}
149
150/******************************************************************************
151 *
152 * FUNCTION: acpi_hw_clear_gpe
153 *
154 * PARAMETERS: gpe_event_info - Info block for the GPE to be cleared
155 *
156 * RETURN: Status
157 *
158 * DESCRIPTION: Clear the status bit for a single GPE.
159 *
160 ******************************************************************************/
161
162acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
163{
164 struct acpi_gpe_register_info *gpe_register_info;
165 acpi_status status;
166 u32 register_bit;
167
168 ACPI_FUNCTION_ENTRY();
169
170 /* Get the info block for the entire GPE register */
171
172 gpe_register_info = gpe_event_info->register_info;
173 if (!gpe_register_info) {
174 return (AE_NOT_EXIST);
175 }
176
177 /*
178 * Write a one to the appropriate bit in the status register to
179 * clear this GPE.
180 */
181 register_bit =
182 acpi_hw_get_gpe_register_bit(gpe_event_info, gpe_register_info);
183
184 status = acpi_hw_write(register_bit,
185 &gpe_register_info->status_address);
186
187 return (status);
188}
189
190/******************************************************************************
191 *
192 * FUNCTION: acpi_hw_get_gpe_status
193 *
194 * PARAMETERS: gpe_event_info - Info block for the GPE to queried
195 * event_status - Where the GPE status is returned
196 *
197 * RETURN: Status
198 *
199 * DESCRIPTION: Return the status of a single GPE.
200 *
201 ******************************************************************************/
202
203acpi_status
204acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
205 acpi_event_status * event_status)
206{
207 u32 in_byte;
208 u32 register_bit;
209 struct acpi_gpe_register_info *gpe_register_info;
210 acpi_event_status local_event_status = 0;
211 acpi_status status;
212
213 ACPI_FUNCTION_ENTRY();
214
215 if (!event_status) {
216 return (AE_BAD_PARAMETER);
217 }
218
219 /* Get the info block for the entire GPE register */
220
221 gpe_register_info = gpe_event_info->register_info;
222
223 /* Get the register bitmask for this GPE */
224
225 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info,
226 gpe_register_info);
227
228 /* GPE currently enabled? (enabled for runtime?) */
229
230 if (register_bit & gpe_register_info->enable_for_run) {
231 local_event_status |= ACPI_EVENT_FLAG_ENABLED;
232 }
233
234 /* GPE enabled for wake? */
235
236 if (register_bit & gpe_register_info->enable_for_wake) {
237 local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
238 }
239
240 /* GPE currently active (status bit == 1)? */
241
242 status = acpi_hw_read(&in_byte, &gpe_register_info->status_address);
243 if (ACPI_FAILURE(status)) {
244 return (status);
245 }
246
247 if (register_bit & in_byte) {
248 local_event_status |= ACPI_EVENT_FLAG_SET;
249 }
250
251 /* Set return value */
252
253 (*event_status) = local_event_status;
254 return (AE_OK);
255}
256
257/******************************************************************************
258 *
259 * FUNCTION: acpi_hw_disable_gpe_block
260 *
261 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
262 * gpe_block - Gpe Block info
263 *
264 * RETURN: Status
265 *
266 * DESCRIPTION: Disable all GPEs within a single GPE block
267 *
268 ******************************************************************************/
269
270acpi_status
271acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
272 struct acpi_gpe_block_info *gpe_block, void *context)
273{
274 u32 i;
275 acpi_status status;
276
277 /* Examine each GPE Register within the block */
278
279 for (i = 0; i < gpe_block->register_count; i++) {
280
281 /* Disable all GPEs in this register */
282
283 status =
284 acpi_hw_write(0x00,
285 &gpe_block->register_info[i].enable_address);
286 if (ACPI_FAILURE(status)) {
287 return (status);
288 }
289 }
290
291 return (AE_OK);
292}
293
294/******************************************************************************
295 *
296 * FUNCTION: acpi_hw_clear_gpe_block
297 *
298 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
299 * gpe_block - Gpe Block info
300 *
301 * RETURN: Status
302 *
303 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
304 *
305 ******************************************************************************/
306
307acpi_status
308acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
309 struct acpi_gpe_block_info *gpe_block, void *context)
310{
311 u32 i;
312 acpi_status status;
313
314 /* Examine each GPE Register within the block */
315
316 for (i = 0; i < gpe_block->register_count; i++) {
317
318 /* Clear status on all GPEs in this register */
319
320 status =
321 acpi_hw_write(0xFF,
322 &gpe_block->register_info[i].status_address);
323 if (ACPI_FAILURE(status)) {
324 return (status);
325 }
326 }
327
328 return (AE_OK);
329}
330
331/******************************************************************************
332 *
333 * FUNCTION: acpi_hw_enable_runtime_gpe_block
334 *
335 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
336 * gpe_block - Gpe Block info
337 *
338 * RETURN: Status
339 *
340 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
341 * combination wake/run GPEs.
342 *
343 ******************************************************************************/
344
345acpi_status
346acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
347 struct acpi_gpe_block_info *gpe_block, void *context)
348{
349 u32 i;
350 acpi_status status;
351
352 /* NOTE: assumes that all GPEs are currently disabled */
353
354 /* Examine each GPE Register within the block */
355
356 for (i = 0; i < gpe_block->register_count; i++) {
357 if (!gpe_block->register_info[i].enable_for_run) {
358 continue;
359 }
360
361 /* Enable all "runtime" GPEs in this register */
362
363 status =
364 acpi_hw_write(gpe_block->register_info[i].enable_for_run,
365 &gpe_block->register_info[i].enable_address);
366 if (ACPI_FAILURE(status)) {
367 return (status);
368 }
369 }
370
371 return (AE_OK);
372}
373
374/******************************************************************************
375 *
376 * FUNCTION: acpi_hw_enable_wakeup_gpe_block
377 *
378 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
379 * gpe_block - Gpe Block info
380 *
381 * RETURN: Status
382 *
383 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
384 * combination wake/run GPEs.
385 *
386 ******************************************************************************/
387
388static acpi_status
389acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
390 struct acpi_gpe_block_info *gpe_block,
391 void *context)
392{
393 u32 i;
394 acpi_status status;
395
396 /* Examine each GPE Register within the block */
397
398 for (i = 0; i < gpe_block->register_count; i++) {
399 if (!gpe_block->register_info[i].enable_for_wake) {
400 continue;
401 }
402
403 /* Enable all "wake" GPEs in this register */
404
405 status =
406 acpi_hw_write(gpe_block->register_info[i].enable_for_wake,
407 &gpe_block->register_info[i].enable_address);
408 if (ACPI_FAILURE(status)) {
409 return (status);
410 }
411 }
412
413 return (AE_OK);
414}
415
416/******************************************************************************
417 *
418 * FUNCTION: acpi_hw_disable_all_gpes
419 *
420 * PARAMETERS: None
421 *
422 * RETURN: Status
423 *
424 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
425 *
426 ******************************************************************************/
427
428acpi_status acpi_hw_disable_all_gpes(void)
429{
430 acpi_status status;
431
432 ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
433
434 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
435 status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
436 return_ACPI_STATUS(status);
437}
438
439/******************************************************************************
440 *
441 * FUNCTION: acpi_hw_enable_all_runtime_gpes
442 *
443 * PARAMETERS: None
444 *
445 * RETURN: Status
446 *
447 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
448 *
449 ******************************************************************************/
450
451acpi_status acpi_hw_enable_all_runtime_gpes(void)
452{
453 acpi_status status;
454
455 ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
456
457 status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
458 return_ACPI_STATUS(status);
459}
460
461/******************************************************************************
462 *
463 * FUNCTION: acpi_hw_enable_all_wakeup_gpes
464 *
465 * PARAMETERS: None
466 *
467 * RETURN: Status
468 *
469 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
470 *
471 ******************************************************************************/
472
473acpi_status acpi_hw_enable_all_wakeup_gpes(void)
474{
475 acpi_status status;
476
477 ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
478
479 status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
480 return_ACPI_STATUS(status);
481}
1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2/******************************************************************************
3 *
4 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
5 *
6 * Copyright (C) 2000 - 2022, Intel Corp.
7 *
8 *****************************************************************************/
9
10#include <acpi/acpi.h>
11#include "accommon.h"
12#include "acevents.h"
13
14#define _COMPONENT ACPI_HARDWARE
15ACPI_MODULE_NAME("hwgpe")
16#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
17/* Local prototypes */
18static acpi_status
19acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
20 struct acpi_gpe_block_info *gpe_block,
21 void *context);
22
23static acpi_status
24acpi_hw_gpe_enable_write(u8 enable_mask,
25 struct acpi_gpe_register_info *gpe_register_info);
26
27/******************************************************************************
28 *
29 * FUNCTION: acpi_hw_gpe_read
30 *
31 * PARAMETERS: value - Where the value is returned
32 * reg - GPE register structure
33 *
34 * RETURN: Status
35 *
36 * DESCRIPTION: Read from a GPE register in either memory or IO space.
37 *
38 * LIMITATIONS: <These limitations also apply to acpi_hw_gpe_write>
39 * space_ID must be system_memory or system_IO.
40 *
41 ******************************************************************************/
42
43acpi_status acpi_hw_gpe_read(u64 *value, struct acpi_gpe_address *reg)
44{
45 acpi_status status;
46 u32 value32;
47
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);
52#else
53 return acpi_os_read_memory((acpi_physical_address)reg->address,
54 value, ACPI_GPE_REGISTER_WIDTH);
55#endif
56 }
57
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);
62
63 *value = (u64)value32;
64
65 return_ACPI_STATUS(AE_OK);
66}
67
68/******************************************************************************
69 *
70 * FUNCTION: acpi_hw_gpe_write
71 *
72 * PARAMETERS: value - Value to be written
73 * reg - GPE register structure
74 *
75 * RETURN: Status
76 *
77 * DESCRIPTION: Write to a GPE register in either memory or IO space.
78 *
79 ******************************************************************************/
80
81acpi_status acpi_hw_gpe_write(u64 value, struct acpi_gpe_address *reg)
82{
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);
87#else
88 return acpi_os_write_memory((acpi_physical_address)reg->address,
89 value, ACPI_GPE_REGISTER_WIDTH);
90#endif
91 }
92
93 return acpi_os_write_port((acpi_io_address)reg->address, (u32)value,
94 ACPI_GPE_REGISTER_WIDTH);
95}
96
97/******************************************************************************
98 *
99 * FUNCTION: acpi_hw_get_gpe_register_bit
100 *
101 * PARAMETERS: gpe_event_info - Info block for the GPE
102 *
103 * RETURN: Register mask with a one in the GPE bit position
104 *
105 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
106 * correct position for the input GPE.
107 *
108 ******************************************************************************/
109
110u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info)
111{
112
113 return ((u32)1 <<
114 (gpe_event_info->gpe_number -
115 gpe_event_info->register_info->base_gpe_number));
116}
117
118/******************************************************************************
119 *
120 * FUNCTION: acpi_hw_low_set_gpe
121 *
122 * PARAMETERS: gpe_event_info - Info block for the GPE to be disabled
123 * action - Enable or disable
124 *
125 * RETURN: Status
126 *
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.
130 *
131 ******************************************************************************/
132
133acpi_status
134acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
135{
136 struct acpi_gpe_register_info *gpe_register_info;
137 acpi_status status = AE_OK;
138 u64 enable_mask;
139 u32 register_bit;
140
141 ACPI_FUNCTION_ENTRY();
142
143 /* Get the info block for the entire GPE register */
144
145 gpe_register_info = gpe_event_info->register_info;
146 if (!gpe_register_info) {
147 return (AE_NOT_EXIST);
148 }
149
150 /* Get current value of the enable register that contains this GPE */
151
152 status = acpi_hw_gpe_read(&enable_mask,
153 &gpe_register_info->enable_address);
154 if (ACPI_FAILURE(status)) {
155 return (status);
156 }
157
158 /* Set or clear just the bit that corresponds to this GPE */
159
160 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
161 switch (action) {
162 case ACPI_GPE_CONDITIONAL_ENABLE:
163
164 /* Only enable if the corresponding enable_mask bit is set */
165
166 if (!(register_bit & gpe_register_info->enable_mask)) {
167 return (AE_BAD_PARAMETER);
168 }
169
170 ACPI_FALLTHROUGH;
171
172 case ACPI_GPE_ENABLE:
173
174 ACPI_SET_BIT(enable_mask, register_bit);
175 break;
176
177 case ACPI_GPE_DISABLE:
178
179 ACPI_CLEAR_BIT(enable_mask, register_bit);
180 break;
181
182 default:
183
184 ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u", action));
185 return (AE_BAD_PARAMETER);
186 }
187
188 if (!(register_bit & gpe_register_info->mask_for_run)) {
189
190 /* Write the updated enable mask */
191
192 status = acpi_hw_gpe_write(enable_mask,
193 &gpe_register_info->enable_address);
194 }
195 return (status);
196}
197
198/******************************************************************************
199 *
200 * FUNCTION: acpi_hw_clear_gpe
201 *
202 * PARAMETERS: gpe_event_info - Info block for the GPE to be cleared
203 *
204 * RETURN: Status
205 *
206 * DESCRIPTION: Clear the status bit for a single GPE.
207 *
208 ******************************************************************************/
209
210acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info *gpe_event_info)
211{
212 struct acpi_gpe_register_info *gpe_register_info;
213 acpi_status status;
214 u32 register_bit;
215
216 ACPI_FUNCTION_ENTRY();
217
218 /* Get the info block for the entire GPE register */
219
220 gpe_register_info = gpe_event_info->register_info;
221 if (!gpe_register_info) {
222 return (AE_NOT_EXIST);
223 }
224
225 /*
226 * Write a one to the appropriate bit in the status register to
227 * clear this GPE.
228 */
229 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
230
231 status = acpi_hw_gpe_write(register_bit,
232 &gpe_register_info->status_address);
233 return (status);
234}
235
236/******************************************************************************
237 *
238 * FUNCTION: acpi_hw_get_gpe_status
239 *
240 * PARAMETERS: gpe_event_info - Info block for the GPE to queried
241 * event_status - Where the GPE status is returned
242 *
243 * RETURN: Status
244 *
245 * DESCRIPTION: Return the status of a single GPE.
246 *
247 ******************************************************************************/
248
249acpi_status
250acpi_hw_get_gpe_status(struct acpi_gpe_event_info *gpe_event_info,
251 acpi_event_status *event_status)
252{
253 u64 in_byte;
254 u32 register_bit;
255 struct acpi_gpe_register_info *gpe_register_info;
256 acpi_event_status local_event_status = 0;
257 acpi_status status;
258
259 ACPI_FUNCTION_ENTRY();
260
261 if (!event_status) {
262 return (AE_BAD_PARAMETER);
263 }
264
265 /* GPE currently handled? */
266
267 if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
268 ACPI_GPE_DISPATCH_NONE) {
269 local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
270 }
271
272 /* Get the info block for the entire GPE register */
273
274 gpe_register_info = gpe_event_info->register_info;
275
276 /* Get the register bitmask for this GPE */
277
278 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
279
280 /* GPE currently enabled? (enabled for runtime?) */
281
282 if (register_bit & gpe_register_info->enable_for_run) {
283 local_event_status |= ACPI_EVENT_FLAG_ENABLED;
284 }
285
286 /* GPE currently masked? (masked for runtime?) */
287
288 if (register_bit & gpe_register_info->mask_for_run) {
289 local_event_status |= ACPI_EVENT_FLAG_MASKED;
290 }
291
292 /* GPE enabled for wake? */
293
294 if (register_bit & gpe_register_info->enable_for_wake) {
295 local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
296 }
297
298 /* GPE currently enabled (enable bit == 1)? */
299
300 status = acpi_hw_gpe_read(&in_byte, &gpe_register_info->enable_address);
301 if (ACPI_FAILURE(status)) {
302 return (status);
303 }
304
305 if (register_bit & in_byte) {
306 local_event_status |= ACPI_EVENT_FLAG_ENABLE_SET;
307 }
308
309 /* GPE currently active (status bit == 1)? */
310
311 status = acpi_hw_gpe_read(&in_byte, &gpe_register_info->status_address);
312 if (ACPI_FAILURE(status)) {
313 return (status);
314 }
315
316 if (register_bit & in_byte) {
317 local_event_status |= ACPI_EVENT_FLAG_STATUS_SET;
318 }
319
320 /* Set return value */
321
322 (*event_status) = local_event_status;
323 return (AE_OK);
324}
325
326/******************************************************************************
327 *
328 * FUNCTION: acpi_hw_gpe_enable_write
329 *
330 * PARAMETERS: enable_mask - Bit mask to write to the GPE register
331 * gpe_register_info - Gpe Register info
332 *
333 * RETURN: Status
334 *
335 * DESCRIPTION: Write the enable mask byte to the given GPE register.
336 *
337 ******************************************************************************/
338
339static acpi_status
340acpi_hw_gpe_enable_write(u8 enable_mask,
341 struct acpi_gpe_register_info *gpe_register_info)
342{
343 acpi_status status;
344
345 gpe_register_info->enable_mask = enable_mask;
346
347 status = acpi_hw_gpe_write(enable_mask,
348 &gpe_register_info->enable_address);
349 return (status);
350}
351
352/******************************************************************************
353 *
354 * FUNCTION: acpi_hw_disable_gpe_block
355 *
356 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
357 * gpe_block - Gpe Block info
358 *
359 * RETURN: Status
360 *
361 * DESCRIPTION: Disable all GPEs within a single GPE block
362 *
363 ******************************************************************************/
364
365acpi_status
366acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
367 struct acpi_gpe_block_info *gpe_block, void *context)
368{
369 u32 i;
370 acpi_status status;
371
372 /* Examine each GPE Register within the block */
373
374 for (i = 0; i < gpe_block->register_count; i++) {
375
376 /* Disable all GPEs in this register */
377
378 status =
379 acpi_hw_gpe_enable_write(0x00,
380 &gpe_block->register_info[i]);
381 if (ACPI_FAILURE(status)) {
382 return (status);
383 }
384 }
385
386 return (AE_OK);
387}
388
389/******************************************************************************
390 *
391 * FUNCTION: acpi_hw_clear_gpe_block
392 *
393 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
394 * gpe_block - Gpe Block info
395 *
396 * RETURN: Status
397 *
398 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
399 *
400 ******************************************************************************/
401
402acpi_status
403acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
404 struct acpi_gpe_block_info *gpe_block, void *context)
405{
406 u32 i;
407 acpi_status status;
408
409 /* Examine each GPE Register within the block */
410
411 for (i = 0; i < gpe_block->register_count; i++) {
412
413 /* Clear status on all GPEs in this register */
414
415 status = acpi_hw_gpe_write(0xFF,
416 &gpe_block->register_info[i].status_address);
417 if (ACPI_FAILURE(status)) {
418 return (status);
419 }
420 }
421
422 return (AE_OK);
423}
424
425/******************************************************************************
426 *
427 * FUNCTION: acpi_hw_enable_runtime_gpe_block
428 *
429 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
430 * gpe_block - Gpe Block info
431 *
432 * RETURN: Status
433 *
434 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
435 * combination wake/run GPEs.
436 *
437 ******************************************************************************/
438
439acpi_status
440acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
441 struct acpi_gpe_block_info *gpe_block,
442 void *context)
443{
444 u32 i;
445 acpi_status status;
446 struct acpi_gpe_register_info *gpe_register_info;
447 u8 enable_mask;
448
449 /* NOTE: assumes that all GPEs are currently disabled */
450
451 /* Examine each GPE Register within the block */
452
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) {
456 continue;
457 }
458
459 /* Enable all "runtime" GPEs in this register */
460
461 enable_mask = gpe_register_info->enable_for_run &
462 ~gpe_register_info->mask_for_run;
463 status =
464 acpi_hw_gpe_enable_write(enable_mask, gpe_register_info);
465 if (ACPI_FAILURE(status)) {
466 return (status);
467 }
468 }
469
470 return (AE_OK);
471}
472
473/******************************************************************************
474 *
475 * FUNCTION: acpi_hw_enable_wakeup_gpe_block
476 *
477 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
478 * gpe_block - Gpe Block info
479 *
480 * RETURN: Status
481 *
482 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
483 * combination wake/run GPEs.
484 *
485 ******************************************************************************/
486
487static acpi_status
488acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
489 struct acpi_gpe_block_info *gpe_block,
490 void *context)
491{
492 u32 i;
493 acpi_status status;
494 struct acpi_gpe_register_info *gpe_register_info;
495
496 /* Examine each GPE Register within the block */
497
498 for (i = 0; i < gpe_block->register_count; i++) {
499 gpe_register_info = &gpe_block->register_info[i];
500
501 /*
502 * Enable all "wake" GPEs in this register and disable the
503 * remaining ones.
504 */
505
506 status =
507 acpi_hw_gpe_enable_write(gpe_register_info->enable_for_wake,
508 gpe_register_info);
509 if (ACPI_FAILURE(status)) {
510 return (status);
511 }
512 }
513
514 return (AE_OK);
515}
516
517struct acpi_gpe_block_status_context {
518 struct acpi_gpe_register_info *gpe_skip_register_info;
519 u8 gpe_skip_mask;
520 u8 retval;
521};
522
523/******************************************************************************
524 *
525 * FUNCTION: acpi_hw_get_gpe_block_status
526 *
527 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
528 * gpe_block - Gpe Block info
529 * context - GPE list walk context data
530 *
531 * RETURN: Success
532 *
533 * DESCRIPTION: Produce a combined GPE status bits mask for the given block.
534 *
535 ******************************************************************************/
536
537static acpi_status
538acpi_hw_get_gpe_block_status(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
539 struct acpi_gpe_block_info *gpe_block,
540 void *context)
541{
542 struct acpi_gpe_block_status_context *c = context;
543 struct acpi_gpe_register_info *gpe_register_info;
544 u64 in_enable, in_status;
545 acpi_status status;
546 u8 ret_mask;
547 u32 i;
548
549 /* Examine each GPE Register within the block */
550
551 for (i = 0; i < gpe_block->register_count; i++) {
552 gpe_register_info = &gpe_block->register_info[i];
553
554 status = acpi_hw_gpe_read(&in_enable,
555 &gpe_register_info->enable_address);
556 if (ACPI_FAILURE(status)) {
557 continue;
558 }
559
560 status = acpi_hw_gpe_read(&in_status,
561 &gpe_register_info->status_address);
562 if (ACPI_FAILURE(status)) {
563 continue;
564 }
565
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;
569 }
570 c->retval |= ret_mask;
571 }
572
573 return (AE_OK);
574}
575
576/******************************************************************************
577 *
578 * FUNCTION: acpi_hw_disable_all_gpes
579 *
580 * PARAMETERS: None
581 *
582 * RETURN: Status
583 *
584 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
585 *
586 ******************************************************************************/
587
588acpi_status acpi_hw_disable_all_gpes(void)
589{
590 acpi_status status;
591
592 ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
593
594 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
595 return_ACPI_STATUS(status);
596}
597
598/******************************************************************************
599 *
600 * FUNCTION: acpi_hw_enable_all_runtime_gpes
601 *
602 * PARAMETERS: None
603 *
604 * RETURN: Status
605 *
606 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
607 *
608 ******************************************************************************/
609
610acpi_status acpi_hw_enable_all_runtime_gpes(void)
611{
612 acpi_status status;
613
614 ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
615
616 status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
617 return_ACPI_STATUS(status);
618}
619
620/******************************************************************************
621 *
622 * FUNCTION: acpi_hw_enable_all_wakeup_gpes
623 *
624 * PARAMETERS: None
625 *
626 * RETURN: Status
627 *
628 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
629 *
630 ******************************************************************************/
631
632acpi_status acpi_hw_enable_all_wakeup_gpes(void)
633{
634 acpi_status status;
635
636 ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
637
638 status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
639 return_ACPI_STATUS(status);
640}
641
642/******************************************************************************
643 *
644 * FUNCTION: acpi_hw_check_all_gpes
645 *
646 * PARAMETERS: gpe_skip_device - GPE devoce of the GPE to skip
647 * gpe_skip_number - Number of the GPE to skip
648 *
649 * RETURN: Combined status of all GPEs
650 *
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.
654 *
655 ******************************************************************************/
656
657u8 acpi_hw_check_all_gpes(acpi_handle gpe_skip_device, u32 gpe_skip_number)
658{
659 struct acpi_gpe_block_status_context context = {
660 .gpe_skip_register_info = NULL,
661 .retval = 0,
662 };
663 struct acpi_gpe_event_info *gpe_event_info;
664 acpi_cpu_flags flags;
665
666 ACPI_FUNCTION_TRACE(acpi_hw_check_all_gpes);
667
668 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
669
670 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_skip_device,
671 gpe_skip_number);
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);
675 }
676
677 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
678
679 (void)acpi_ev_walk_gpe_list(acpi_hw_get_gpe_block_status, &context);
680 return (context.retval != 0);
681}
682
683#endif /* !ACPI_REDUCED_HARDWARE */