1 /******************************************************************************
2 *
3 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2014, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
25 *
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.
29 *
30 * NO WARRANTY
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.
42 */
43
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acevents.h"
47
48 #define _COMPONENT ACPI_HARDWARE
49 ACPI_MODULE_NAME("hwgpe")
50 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
51 /* Local prototypes */
52 static acpi_status
53 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
54 struct acpi_gpe_block_info *gpe_block,
55 void *context);
56
57 /******************************************************************************
58 *
59 * FUNCTION: acpi_hw_get_gpe_register_bit
60 *
61 * PARAMETERS: gpe_event_info - Info block for the GPE
62 *
63 * RETURN: Register mask with a one in the GPE bit position
64 *
65 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
66 * correct position for the input GPE.
67 *
68 ******************************************************************************/
69
acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info * gpe_event_info)70 u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info)
71 {
72
73 return ((u32)1 <<
74 (gpe_event_info->gpe_number -
75 gpe_event_info->register_info->base_gpe_number));
76 }
77
78 /******************************************************************************
79 *
80 * FUNCTION: acpi_hw_low_set_gpe
81 *
82 * PARAMETERS: gpe_event_info - Info block for the GPE to be disabled
83 * action - Enable or disable
84 *
85 * RETURN: Status
86 *
87 * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
88 *
89 ******************************************************************************/
90
91 acpi_status
acpi_hw_low_set_gpe(struct acpi_gpe_event_info * gpe_event_info,u32 action)92 acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
93 {
94 struct acpi_gpe_register_info *gpe_register_info;
95 acpi_status status;
96 u32 enable_mask;
97 u32 register_bit;
98
99 ACPI_FUNCTION_ENTRY();
100
101 /* Get the info block for the entire GPE register */
102
103 gpe_register_info = gpe_event_info->register_info;
104 if (!gpe_register_info) {
105 return (AE_NOT_EXIST);
106 }
107
108 /* Get current value of the enable register that contains this GPE */
109
110 status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address);
111 if (ACPI_FAILURE(status)) {
112 return (status);
113 }
114
115 /* Set or clear just the bit that corresponds to this GPE */
116
117 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
118 switch (action) {
119 case ACPI_GPE_CONDITIONAL_ENABLE:
120
121 /* Only enable if the enable_for_run bit is set */
122
123 if (!(register_bit & gpe_register_info->enable_for_run)) {
124 return (AE_BAD_PARAMETER);
125 }
126
127 /*lint -fallthrough */
128
129 case ACPI_GPE_ENABLE:
130
131 ACPI_SET_BIT(enable_mask, register_bit);
132 break;
133
134 case ACPI_GPE_DISABLE:
135
136 ACPI_CLEAR_BIT(enable_mask, register_bit);
137 break;
138
139 default:
140
141 ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u", action));
142 return (AE_BAD_PARAMETER);
143 }
144
145 /* Write the updated enable mask */
146
147 status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
148 return (status);
149 }
150
151 /******************************************************************************
152 *
153 * FUNCTION: acpi_hw_clear_gpe
154 *
155 * PARAMETERS: gpe_event_info - Info block for the GPE to be cleared
156 *
157 * RETURN: Status
158 *
159 * DESCRIPTION: Clear the status bit for a single GPE.
160 *
161 ******************************************************************************/
162
acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)163 acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
164 {
165 struct acpi_gpe_register_info *gpe_register_info;
166 acpi_status status;
167 u32 register_bit;
168
169 ACPI_FUNCTION_ENTRY();
170
171 /* Get the info block for the entire GPE register */
172
173 gpe_register_info = gpe_event_info->register_info;
174 if (!gpe_register_info) {
175 return (AE_NOT_EXIST);
176 }
177
178 /*
179 * Write a one to the appropriate bit in the status register to
180 * clear this GPE.
181 */
182 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_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
203 acpi_status
acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,acpi_event_status * event_status)204 acpi_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 /* GPE currently handled? */
220
221 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) !=
222 ACPI_GPE_DISPATCH_NONE) {
223 local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
224 }
225
226 /* Get the info block for the entire GPE register */
227
228 gpe_register_info = gpe_event_info->register_info;
229
230 /* Get the register bitmask for this GPE */
231
232 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
233
234 /* GPE currently enabled? (enabled for runtime?) */
235
236 if (register_bit & gpe_register_info->enable_for_run) {
237 local_event_status |= ACPI_EVENT_FLAG_ENABLED;
238 }
239
240 /* GPE enabled for wake? */
241
242 if (register_bit & gpe_register_info->enable_for_wake) {
243 local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
244 }
245
246 /* GPE currently active (status bit == 1)? */
247
248 status = acpi_hw_read(&in_byte, &gpe_register_info->status_address);
249 if (ACPI_FAILURE(status)) {
250 return (status);
251 }
252
253 if (register_bit & in_byte) {
254 local_event_status |= ACPI_EVENT_FLAG_SET;
255 }
256
257 /* Set return value */
258
259 (*event_status) = local_event_status;
260 return (AE_OK);
261 }
262
263 /******************************************************************************
264 *
265 * FUNCTION: acpi_hw_disable_gpe_block
266 *
267 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
268 * gpe_block - Gpe Block info
269 *
270 * RETURN: Status
271 *
272 * DESCRIPTION: Disable all GPEs within a single GPE block
273 *
274 ******************************************************************************/
275
276 acpi_status
acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)277 acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
278 struct acpi_gpe_block_info *gpe_block, void *context)
279 {
280 u32 i;
281 acpi_status status;
282
283 /* Examine each GPE Register within the block */
284
285 for (i = 0; i < gpe_block->register_count; i++) {
286
287 /* Disable all GPEs in this register */
288
289 status =
290 acpi_hw_write(0x00,
291 &gpe_block->register_info[i].enable_address);
292 if (ACPI_FAILURE(status)) {
293 return (status);
294 }
295 }
296
297 return (AE_OK);
298 }
299
300 /******************************************************************************
301 *
302 * FUNCTION: acpi_hw_clear_gpe_block
303 *
304 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
305 * gpe_block - Gpe Block info
306 *
307 * RETURN: Status
308 *
309 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
310 *
311 ******************************************************************************/
312
313 acpi_status
acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)314 acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
315 struct acpi_gpe_block_info *gpe_block, void *context)
316 {
317 u32 i;
318 acpi_status status;
319
320 /* Examine each GPE Register within the block */
321
322 for (i = 0; i < gpe_block->register_count; i++) {
323
324 /* Clear status on all GPEs in this register */
325
326 status =
327 acpi_hw_write(0xFF,
328 &gpe_block->register_info[i].status_address);
329 if (ACPI_FAILURE(status)) {
330 return (status);
331 }
332 }
333
334 return (AE_OK);
335 }
336
337 /******************************************************************************
338 *
339 * FUNCTION: acpi_hw_enable_runtime_gpe_block
340 *
341 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
342 * gpe_block - Gpe Block info
343 *
344 * RETURN: Status
345 *
346 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
347 * combination wake/run GPEs.
348 *
349 ******************************************************************************/
350
351 acpi_status
acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)352 acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
353 struct acpi_gpe_block_info * gpe_block,
354 void *context)
355 {
356 u32 i;
357 acpi_status status;
358
359 /* NOTE: assumes that all GPEs are currently disabled */
360
361 /* Examine each GPE Register within the block */
362
363 for (i = 0; i < gpe_block->register_count; i++) {
364 if (!gpe_block->register_info[i].enable_for_run) {
365 continue;
366 }
367
368 /* Enable all "runtime" GPEs in this register */
369
370 status =
371 acpi_hw_write(gpe_block->register_info[i].enable_for_run,
372 &gpe_block->register_info[i].enable_address);
373 if (ACPI_FAILURE(status)) {
374 return (status);
375 }
376 }
377
378 return (AE_OK);
379 }
380
381 /******************************************************************************
382 *
383 * FUNCTION: acpi_hw_enable_wakeup_gpe_block
384 *
385 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
386 * gpe_block - Gpe Block info
387 *
388 * RETURN: Status
389 *
390 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
391 * combination wake/run GPEs.
392 *
393 ******************************************************************************/
394
395 static acpi_status
acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)396 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
397 struct acpi_gpe_block_info *gpe_block,
398 void *context)
399 {
400 u32 i;
401 acpi_status status;
402
403 /* Examine each GPE Register within the block */
404
405 for (i = 0; i < gpe_block->register_count; i++) {
406
407 /*
408 * Enable all "wake" GPEs in this register and disable the
409 * remaining ones.
410 */
411
412 status =
413 acpi_hw_write(gpe_block->register_info[i].enable_for_wake,
414 &gpe_block->register_info[i].enable_address);
415 if (ACPI_FAILURE(status)) {
416 return (status);
417 }
418 }
419
420 return (AE_OK);
421 }
422
423 /******************************************************************************
424 *
425 * FUNCTION: acpi_hw_disable_all_gpes
426 *
427 * PARAMETERS: None
428 *
429 * RETURN: Status
430 *
431 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
432 *
433 ******************************************************************************/
434
acpi_hw_disable_all_gpes(void)435 acpi_status acpi_hw_disable_all_gpes(void)
436 {
437 acpi_status status;
438
439 ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
440
441 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
442 status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
443 return_ACPI_STATUS(status);
444 }
445
446 /******************************************************************************
447 *
448 * FUNCTION: acpi_hw_enable_all_runtime_gpes
449 *
450 * PARAMETERS: None
451 *
452 * RETURN: Status
453 *
454 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
455 *
456 ******************************************************************************/
457
acpi_hw_enable_all_runtime_gpes(void)458 acpi_status acpi_hw_enable_all_runtime_gpes(void)
459 {
460 acpi_status status;
461
462 ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
463
464 status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
465 return_ACPI_STATUS(status);
466 }
467
468 /******************************************************************************
469 *
470 * FUNCTION: acpi_hw_enable_all_wakeup_gpes
471 *
472 * PARAMETERS: None
473 *
474 * RETURN: Status
475 *
476 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
477 *
478 ******************************************************************************/
479
acpi_hw_enable_all_wakeup_gpes(void)480 acpi_status acpi_hw_enable_all_wakeup_gpes(void)
481 {
482 acpi_status status;
483
484 ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
485
486 status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
487 return_ACPI_STATUS(status);
488 }
489
490 #endif /* !ACPI_REDUCED_HARDWARE */
491