ACPICA: Update all ACPICA copyrights and signons to 2010
[linux-3.10.git] / drivers / acpi / acpica / evevent.c
1 /******************************************************************************
2  *
3  * Module Name: evevent - Fixed Event handling and dispatch
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2010, 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 disable all 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                 /* Disable the fixed event */
204
205                 if (acpi_gbl_fixed_event_info[i].enable_register_id != 0xFF) {
206                         status =
207                             acpi_write_bit_register(acpi_gbl_fixed_event_info
208                                                     [i].enable_register_id,
209                                                     ACPI_DISABLE_EVENT);
210                         if (ACPI_FAILURE(status)) {
211                                 return (status);
212                         }
213                 }
214         }
215
216         return (AE_OK);
217 }
218
219 /*******************************************************************************
220  *
221  * FUNCTION:    acpi_ev_fixed_event_detect
222  *
223  * PARAMETERS:  None
224  *
225  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
226  *
227  * DESCRIPTION: Checks the PM status register for active fixed events
228  *
229  ******************************************************************************/
230
231 u32 acpi_ev_fixed_event_detect(void)
232 {
233         u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
234         u32 fixed_status;
235         u32 fixed_enable;
236         u32 i;
237
238         ACPI_FUNCTION_NAME(ev_fixed_event_detect);
239
240         /*
241          * Read the fixed feature status and enable registers, as all the cases
242          * depend on their values. Ignore errors here.
243          */
244         (void)acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS, &fixed_status);
245         (void)acpi_hw_register_read(ACPI_REGISTER_PM1_ENABLE, &fixed_enable);
246
247         ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
248                           "Fixed Event Block: Enable %08X Status %08X\n",
249                           fixed_enable, fixed_status));
250
251         /*
252          * Check for all possible Fixed Events and dispatch those that are active
253          */
254         for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
255
256                 /* Both the status and enable bits must be on for this event */
257
258                 if ((fixed_status & acpi_gbl_fixed_event_info[i].
259                      status_bit_mask)
260                     && (fixed_enable & acpi_gbl_fixed_event_info[i].
261                         enable_bit_mask)) {
262
263                         /* Found an active (signalled) event */
264                         acpi_os_fixed_event_count(i);
265                         int_status |= acpi_ev_fixed_event_dispatch(i);
266                 }
267         }
268
269         return (int_status);
270 }
271
272 /*******************************************************************************
273  *
274  * FUNCTION:    acpi_ev_fixed_event_dispatch
275  *
276  * PARAMETERS:  Event               - Event type
277  *
278  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
279  *
280  * DESCRIPTION: Clears the status bit for the requested event, calls the
281  *              handler that previously registered for the event.
282  *
283  ******************************************************************************/
284
285 static u32 acpi_ev_fixed_event_dispatch(u32 event)
286 {
287
288         ACPI_FUNCTION_ENTRY();
289
290         /* Clear the status bit */
291
292         (void)acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
293                                       status_register_id, ACPI_CLEAR_STATUS);
294
295         /*
296          * Make sure we've got a handler. If not, report an error. The event is
297          * disabled to prevent further interrupts.
298          */
299         if (NULL == acpi_gbl_fixed_event_handlers[event].handler) {
300                 (void)acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
301                                               enable_register_id,
302                                               ACPI_DISABLE_EVENT);
303
304                 ACPI_ERROR((AE_INFO,
305                             "No installed handler for fixed event [%08X]",
306                             event));
307
308                 return (ACPI_INTERRUPT_NOT_HANDLED);
309         }
310
311         /* Invoke the Fixed Event handler */
312
313         return ((acpi_gbl_fixed_event_handlers[event].
314                  handler) (acpi_gbl_fixed_event_handlers[event].context));
315 }