1
2 /******************************************************************************
3 *
4 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
5 *
6 *****************************************************************************/
7
8 /*
9 * Copyright (C) 2000 - 2008, 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
50 ACPI_MODULE_NAME("hwgpe")
51
52 /* Local prototypes */
53 static acpi_status
54 acpi_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_low_disable_gpe
61 *
62 * PARAMETERS: gpe_event_info - Info block for the GPE to be disabled
63 *
64 * RETURN: Status
65 *
66 * DESCRIPTION: Disable a single GPE in the enable register.
67 *
68 ******************************************************************************/
69
acpi_hw_low_disable_gpe(struct acpi_gpe_event_info * gpe_event_info)70 acpi_status acpi_hw_low_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
71 {
72 struct acpi_gpe_register_info *gpe_register_info;
73 acpi_status status;
74 u32 enable_mask;
75
76 /* Get the info block for the entire GPE register */
77
78 gpe_register_info = gpe_event_info->register_info;
79 if (!gpe_register_info) {
80 return (AE_NOT_EXIST);
81 }
82
83 /* Get current value of the enable register that contains this GPE */
84
85 status = acpi_read(&enable_mask, &gpe_register_info->enable_address);
86 if (ACPI_FAILURE(status)) {
87 return (status);
88 }
89
90 /* Clear just the bit that corresponds to this GPE */
91
92 ACPI_CLEAR_BIT(enable_mask,
93 ((u32) 1 <<
94 (gpe_event_info->gpe_number -
95 gpe_register_info->base_gpe_number)));
96
97 /* Write the updated enable mask */
98
99 status = acpi_write(enable_mask, &gpe_register_info->enable_address);
100 return (status);
101 }
102
103 /******************************************************************************
104 *
105 * FUNCTION: acpi_hw_write_gpe_enable_reg
106 *
107 * PARAMETERS: gpe_event_info - Info block for the GPE to be enabled
108 *
109 * RETURN: Status
110 *
111 * DESCRIPTION: Write a GPE enable register. Note: The bit for this GPE must
112 * already be cleared or set in the parent register
113 * enable_for_run mask.
114 *
115 ******************************************************************************/
116
117 acpi_status
acpi_hw_write_gpe_enable_reg(struct acpi_gpe_event_info * gpe_event_info)118 acpi_hw_write_gpe_enable_reg(struct acpi_gpe_event_info * gpe_event_info)
119 {
120 struct acpi_gpe_register_info *gpe_register_info;
121 acpi_status status;
122
123 ACPI_FUNCTION_ENTRY();
124
125 /* Get the info block for the entire GPE register */
126
127 gpe_register_info = gpe_event_info->register_info;
128 if (!gpe_register_info) {
129 return (AE_NOT_EXIST);
130 }
131
132 /* Write the entire GPE (runtime) enable register */
133
134 status = acpi_write(gpe_register_info->enable_for_run,
135 &gpe_register_info->enable_address);
136
137 return (status);
138 }
139
140 /******************************************************************************
141 *
142 * FUNCTION: acpi_hw_clear_gpe
143 *
144 * PARAMETERS: gpe_event_info - Info block for the GPE to be cleared
145 *
146 * RETURN: Status
147 *
148 * DESCRIPTION: Clear the status bit for a single GPE.
149 *
150 ******************************************************************************/
151
acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)152 acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
153 {
154 acpi_status status;
155 u8 register_bit;
156
157 ACPI_FUNCTION_ENTRY();
158
159 register_bit = (u8)
160 (1 <<
161 (gpe_event_info->gpe_number -
162 gpe_event_info->register_info->base_gpe_number));
163
164 /*
165 * Write a one to the appropriate bit in the status register to
166 * clear this GPE.
167 */
168 status = acpi_write(register_bit,
169 &gpe_event_info->register_info->status_address);
170
171 return (status);
172 }
173
174 /******************************************************************************
175 *
176 * FUNCTION: acpi_hw_get_gpe_status
177 *
178 * PARAMETERS: gpe_event_info - Info block for the GPE to queried
179 * event_status - Where the GPE status is returned
180 *
181 * RETURN: Status
182 *
183 * DESCRIPTION: Return the status of a single GPE.
184 *
185 ******************************************************************************/
186
187 acpi_status
acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,acpi_event_status * event_status)188 acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
189 acpi_event_status * event_status)
190 {
191 u32 in_byte;
192 u8 register_bit;
193 struct acpi_gpe_register_info *gpe_register_info;
194 acpi_status status;
195 acpi_event_status local_event_status = 0;
196
197 ACPI_FUNCTION_ENTRY();
198
199 if (!event_status) {
200 return (AE_BAD_PARAMETER);
201 }
202
203 /* Get the info block for the entire GPE register */
204
205 gpe_register_info = gpe_event_info->register_info;
206
207 /* Get the register bitmask for this GPE */
208
209 register_bit = (u8)
210 (1 <<
211 (gpe_event_info->gpe_number -
212 gpe_event_info->register_info->base_gpe_number));
213
214 /* GPE currently enabled? (enabled for runtime?) */
215
216 if (register_bit & gpe_register_info->enable_for_run) {
217 local_event_status |= ACPI_EVENT_FLAG_ENABLED;
218 }
219
220 /* GPE enabled for wake? */
221
222 if (register_bit & gpe_register_info->enable_for_wake) {
223 local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
224 }
225
226 /* GPE currently active (status bit == 1)? */
227
228 status = acpi_read(&in_byte, &gpe_register_info->status_address);
229 if (ACPI_FAILURE(status)) {
230 goto unlock_and_exit;
231 }
232
233 if (register_bit & in_byte) {
234 local_event_status |= ACPI_EVENT_FLAG_SET;
235 }
236
237 /* Set return value */
238
239 (*event_status) = local_event_status;
240
241 unlock_and_exit:
242 return (status);
243 }
244
245 /******************************************************************************
246 *
247 * FUNCTION: acpi_hw_disable_gpe_block
248 *
249 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
250 * gpe_block - Gpe Block info
251 *
252 * RETURN: Status
253 *
254 * DESCRIPTION: Disable all GPEs within a single GPE block
255 *
256 ******************************************************************************/
257
258 acpi_status
acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)259 acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
260 struct acpi_gpe_block_info *gpe_block, void *context)
261 {
262 u32 i;
263 acpi_status status;
264
265 /* Examine each GPE Register within the block */
266
267 for (i = 0; i < gpe_block->register_count; i++) {
268
269 /* Disable all GPEs in this register */
270
271 status =
272 acpi_write(0x00,
273 &gpe_block->register_info[i].enable_address);
274 if (ACPI_FAILURE(status)) {
275 return (status);
276 }
277 }
278
279 return (AE_OK);
280 }
281
282 /******************************************************************************
283 *
284 * FUNCTION: acpi_hw_clear_gpe_block
285 *
286 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
287 * gpe_block - Gpe Block info
288 *
289 * RETURN: Status
290 *
291 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
292 *
293 ******************************************************************************/
294
295 acpi_status
acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)296 acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
297 struct acpi_gpe_block_info *gpe_block, void *context)
298 {
299 u32 i;
300 acpi_status status;
301
302 /* Examine each GPE Register within the block */
303
304 for (i = 0; i < gpe_block->register_count; i++) {
305
306 /* Clear status on all GPEs in this register */
307
308 status =
309 acpi_write(0xFF,
310 &gpe_block->register_info[i].status_address);
311 if (ACPI_FAILURE(status)) {
312 return (status);
313 }
314 }
315
316 return (AE_OK);
317 }
318
319 /******************************************************************************
320 *
321 * FUNCTION: acpi_hw_enable_runtime_gpe_block
322 *
323 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
324 * gpe_block - Gpe Block info
325 *
326 * RETURN: Status
327 *
328 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
329 * combination wake/run GPEs.
330 *
331 ******************************************************************************/
332
333 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)334 acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
335 struct acpi_gpe_block_info *gpe_block, void *context)
336 {
337 u32 i;
338 acpi_status status;
339
340 /* NOTE: assumes that all GPEs are currently disabled */
341
342 /* Examine each GPE Register within the block */
343
344 for (i = 0; i < gpe_block->register_count; i++) {
345 if (!gpe_block->register_info[i].enable_for_run) {
346 continue;
347 }
348
349 /* Enable all "runtime" GPEs in this register */
350
351 status = acpi_write(gpe_block->register_info[i].enable_for_run,
352 &gpe_block->register_info[i].
353 enable_address);
354 if (ACPI_FAILURE(status)) {
355 return (status);
356 }
357 }
358
359 return (AE_OK);
360 }
361
362 /******************************************************************************
363 *
364 * FUNCTION: acpi_hw_enable_wakeup_gpe_block
365 *
366 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
367 * gpe_block - Gpe Block info
368 *
369 * RETURN: Status
370 *
371 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
372 * combination wake/run GPEs.
373 *
374 ******************************************************************************/
375
376 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)377 acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
378 struct acpi_gpe_block_info *gpe_block,
379 void *context)
380 {
381 u32 i;
382 acpi_status status;
383
384 /* Examine each GPE Register within the block */
385
386 for (i = 0; i < gpe_block->register_count; i++) {
387 if (!gpe_block->register_info[i].enable_for_wake) {
388 continue;
389 }
390
391 /* Enable all "wake" GPEs in this register */
392
393 status = acpi_write(gpe_block->register_info[i].enable_for_wake,
394 &gpe_block->register_info[i].
395 enable_address);
396 if (ACPI_FAILURE(status)) {
397 return (status);
398 }
399 }
400
401 return (AE_OK);
402 }
403
404 /******************************************************************************
405 *
406 * FUNCTION: acpi_hw_disable_all_gpes
407 *
408 * PARAMETERS: None
409 *
410 * RETURN: Status
411 *
412 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
413 *
414 ******************************************************************************/
415
acpi_hw_disable_all_gpes(void)416 acpi_status acpi_hw_disable_all_gpes(void)
417 {
418 acpi_status status;
419
420 ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
421
422 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
423 status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
424 return_ACPI_STATUS(status);
425 }
426
427 /******************************************************************************
428 *
429 * FUNCTION: acpi_hw_enable_all_runtime_gpes
430 *
431 * PARAMETERS: None
432 *
433 * RETURN: Status
434 *
435 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
436 *
437 ******************************************************************************/
438
acpi_hw_enable_all_runtime_gpes(void)439 acpi_status acpi_hw_enable_all_runtime_gpes(void)
440 {
441 acpi_status status;
442
443 ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
444
445 status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
446 return_ACPI_STATUS(status);
447 }
448
449 /******************************************************************************
450 *
451 * FUNCTION: acpi_hw_enable_all_wakeup_gpes
452 *
453 * PARAMETERS: None
454 *
455 * RETURN: Status
456 *
457 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
458 *
459 ******************************************************************************/
460
acpi_hw_enable_all_wakeup_gpes(void)461 acpi_status acpi_hw_enable_all_wakeup_gpes(void)
462 {
463 acpi_status status;
464
465 ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
466
467 status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
468 return_ACPI_STATUS(status);
469 }
470