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