ACPICA: hide private headers
[linux-2.6.git] / drivers / acpi / acpica / hwgpe.c
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
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
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
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
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
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
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
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
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
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
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
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 }