Merge branch 'fluff' into release
[linux-2.6] / drivers / acpi / acpica / evevent.c
1 /******************************************************************************
2  *
3  * Module Name: evevent - Fixed Event handling and dispatch
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2008, 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_EVENTS
49 ACPI_MODULE_NAME("evevent")
50
51 /* Local prototypes */
52 static acpi_status acpi_ev_fixed_event_initialize(void);
53
54 static u32 acpi_ev_fixed_event_dispatch(u32 event);
55
56 /*******************************************************************************
57  *
58  * FUNCTION:    acpi_ev_initialize_events
59  *
60  * PARAMETERS:  None
61  *
62  * RETURN:      Status
63  *
64  * DESCRIPTION: Initialize global data structures for ACPI events (Fixed, GPE)
65  *
66  ******************************************************************************/
67
68 acpi_status acpi_ev_initialize_events(void)
69 {
70         acpi_status status;
71
72         ACPI_FUNCTION_TRACE(ev_initialize_events);
73
74         /*
75          * Initialize the Fixed and General Purpose Events. This is done prior to
76          * enabling SCIs to prevent interrupts from occurring before the handlers
77          * are installed.
78          */
79         status = acpi_ev_fixed_event_initialize();
80         if (ACPI_FAILURE(status)) {
81                 ACPI_EXCEPTION((AE_INFO, status,
82                                 "Unable to initialize fixed events"));
83                 return_ACPI_STATUS(status);
84         }
85
86         status = acpi_ev_gpe_initialize();
87         if (ACPI_FAILURE(status)) {
88                 ACPI_EXCEPTION((AE_INFO, status,
89                                 "Unable to initialize general purpose events"));
90                 return_ACPI_STATUS(status);
91         }
92
93         return_ACPI_STATUS(status);
94 }
95
96 /*******************************************************************************
97  *
98  * FUNCTION:    acpi_ev_install_fadt_gpes
99  *
100  * PARAMETERS:  None
101  *
102  * RETURN:      Status
103  *
104  * DESCRIPTION: Completes initialization of the FADT-defined GPE blocks
105  *              (0 and 1). This causes the _PRW methods to be run, so the HW
106  *              must be fully initialized at this point, including global lock
107  *              support.
108  *
109  ******************************************************************************/
110
111 acpi_status acpi_ev_install_fadt_gpes(void)
112 {
113         acpi_status status;
114
115         ACPI_FUNCTION_TRACE(ev_install_fadt_gpes);
116
117         /* Namespace must be locked */
118
119         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
120         if (ACPI_FAILURE(status)) {
121                 return (status);
122         }
123
124         /* FADT GPE Block 0 */
125
126         (void)acpi_ev_initialize_gpe_block(acpi_gbl_fadt_gpe_device,
127                                            acpi_gbl_gpe_fadt_blocks[0]);
128
129         /* FADT GPE Block 1 */
130
131         (void)acpi_ev_initialize_gpe_block(acpi_gbl_fadt_gpe_device,
132                                            acpi_gbl_gpe_fadt_blocks[1]);
133
134         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
135         return_ACPI_STATUS(AE_OK);
136 }
137
138 /*******************************************************************************
139  *
140  * FUNCTION:    acpi_ev_install_xrupt_handlers
141  *
142  * PARAMETERS:  None
143  *
144  * RETURN:      Status
145  *
146  * DESCRIPTION: Install interrupt handlers for the SCI and Global Lock
147  *
148  ******************************************************************************/
149
150 acpi_status acpi_ev_install_xrupt_handlers(void)
151 {
152         acpi_status status;
153
154         ACPI_FUNCTION_TRACE(ev_install_xrupt_handlers);
155
156         /* Install the SCI handler */
157
158         status = acpi_ev_install_sci_handler();
159         if (ACPI_FAILURE(status)) {
160                 ACPI_EXCEPTION((AE_INFO, status,
161                                 "Unable to install System Control Interrupt handler"));
162                 return_ACPI_STATUS(status);
163         }
164
165         /* Install the handler for the Global Lock */
166
167         status = acpi_ev_init_global_lock_handler();
168         if (ACPI_FAILURE(status)) {
169                 ACPI_EXCEPTION((AE_INFO, status,
170                                 "Unable to initialize Global Lock handler"));
171                 return_ACPI_STATUS(status);
172         }
173
174         acpi_gbl_events_initialized = TRUE;
175         return_ACPI_STATUS(status);
176 }
177
178 /*******************************************************************************
179  *
180  * FUNCTION:    acpi_ev_fixed_event_initialize
181  *
182  * PARAMETERS:  None
183  *
184  * RETURN:      Status
185  *
186  * DESCRIPTION: Install the fixed event handlers and enable the fixed events.
187  *
188  ******************************************************************************/
189
190 static acpi_status acpi_ev_fixed_event_initialize(void)
191 {
192         u32 i;
193         acpi_status status;
194
195         /*
196          * Initialize the structure that keeps track of fixed event handlers and
197          * enable the fixed events.
198          */
199         for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
200                 acpi_gbl_fixed_event_handlers[i].handler = NULL;
201                 acpi_gbl_fixed_event_handlers[i].context = NULL;
202
203                 /* Enable the fixed event */
204
205                 if (acpi_gbl_fixed_event_info[i].enable_register_id != 0xFF) {
206                         status =
207                             acpi_set_register(acpi_gbl_fixed_event_info[i].
208                                               enable_register_id, 0);
209                         if (ACPI_FAILURE(status)) {
210                                 return (status);
211                         }
212                 }
213         }
214
215         return (AE_OK);
216 }
217
218 /*******************************************************************************
219  *
220  * FUNCTION:    acpi_ev_fixed_event_detect
221  *
222  * PARAMETERS:  None
223  *
224  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
225  *
226  * DESCRIPTION: Checks the PM status register for active fixed events
227  *
228  ******************************************************************************/
229
230 u32 acpi_ev_fixed_event_detect(void)
231 {
232         u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
233         u32 fixed_status;
234         u32 fixed_enable;
235         u32 i;
236
237         ACPI_FUNCTION_NAME(ev_fixed_event_detect);
238
239         /*
240          * Read the fixed feature status and enable registers, as all the cases
241          * depend on their values. Ignore errors here.
242          */
243         (void)acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS, &fixed_status);
244         (void)acpi_hw_register_read(ACPI_REGISTER_PM1_ENABLE, &fixed_enable);
245
246         ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
247                           "Fixed Event Block: Enable %08X Status %08X\n",
248                           fixed_enable, fixed_status));
249
250         /*
251          * Check for all possible Fixed Events and dispatch those that are active
252          */
253         for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
254
255                 /* Both the status and enable bits must be on for this event */
256
257                 if ((fixed_status & acpi_gbl_fixed_event_info[i].
258                      status_bit_mask)
259                     && (fixed_enable & acpi_gbl_fixed_event_info[i].
260                         enable_bit_mask)) {
261
262                         /* Found an active (signalled) event */
263                         acpi_os_fixed_event_count(i);
264                         int_status |= acpi_ev_fixed_event_dispatch(i);
265                 }
266         }
267
268         return (int_status);
269 }
270
271 /*******************************************************************************
272  *
273  * FUNCTION:    acpi_ev_fixed_event_dispatch
274  *
275  * PARAMETERS:  Event               - Event type
276  *
277  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
278  *
279  * DESCRIPTION: Clears the status bit for the requested event, calls the
280  *              handler that previously registered for the event.
281  *
282  ******************************************************************************/
283
284 static u32 acpi_ev_fixed_event_dispatch(u32 event)
285 {
286
287         ACPI_FUNCTION_ENTRY();
288
289         /* Clear the status bit */
290
291         (void)acpi_set_register(acpi_gbl_fixed_event_info[event].
292                                 status_register_id, 1);
293
294         /*
295          * Make sure we've got a handler. If not, report an error. The event is
296          * disabled to prevent further interrupts.
297          */
298         if (NULL == acpi_gbl_fixed_event_handlers[event].handler) {
299                 (void)acpi_set_register(acpi_gbl_fixed_event_info[event].
300                                         enable_register_id, 0);
301
302                 ACPI_ERROR((AE_INFO,
303                             "No installed handler for fixed event [%08X]",
304                             event));
305
306                 return (ACPI_INTERRUPT_NOT_HANDLED);
307         }
308
309         /* Invoke the Fixed Event handler */
310
311         return ((acpi_gbl_fixed_event_handlers[event].
312                  handler) (acpi_gbl_fixed_event_handlers[event].context));
313 }