blob: 94cc8ab9400699fd4b985a4e3d903b4ad2a119b2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $)
3 *
4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 *
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or (at
13 * your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 */
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/types.h>
31#include <linux/delay.h>
32#include <linux/proc_fs.h>
33#include <linux/seq_file.h>
Dmitry Torokhov451566f2005-03-19 01:10:05 -050034#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/io.h>
36#include <acpi/acpi_bus.h>
37#include <acpi/acpi_drivers.h>
38#include <acpi/actypes.h>
39
40#define _COMPONENT ACPI_EC_COMPONENT
Len Brown50526df2005-08-11 17:32:05 -040041ACPI_MODULE_NAME("acpi_ec")
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#define ACPI_EC_COMPONENT 0x00100000
43#define ACPI_EC_CLASS "embedded_controller"
44#define ACPI_EC_HID "PNP0C09"
45#define ACPI_EC_DRIVER_NAME "ACPI Embedded Controller Driver"
46#define ACPI_EC_DEVICE_NAME "Embedded Controller"
47#define ACPI_EC_FILE_INFO "info"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
49#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
Dmitry Torokhov451566f2005-03-19 01:10:05 -050050#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define ACPI_EC_EVENT_OBF 0x01 /* Output buffer full */
53#define ACPI_EC_EVENT_IBE 0x02 /* Input buffer empty */
Dmitry Torokhov451566f2005-03-19 01:10:05 -050054#define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
Len Brown50526df2005-08-11 17:32:05 -040056#define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
57#define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#define ACPI_EC_COMMAND_READ 0x80
59#define ACPI_EC_COMMAND_WRITE 0x81
Dmitry Torokhov451566f2005-03-19 01:10:05 -050060#define ACPI_EC_BURST_ENABLE 0x82
61#define ACPI_EC_BURST_DISABLE 0x83
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#define ACPI_EC_COMMAND_QUERY 0x84
Len Brown02b28a32005-12-05 16:33:04 -050063#define EC_POLL 0xFF
64#define EC_INTR 0x00
Len Brown50526df2005-08-11 17:32:05 -040065static int acpi_ec_remove(struct acpi_device *device, int type);
66static int acpi_ec_start(struct acpi_device *device);
67static int acpi_ec_stop(struct acpi_device *device, int type);
Len Brown02b28a32005-12-05 16:33:04 -050068static int acpi_ec_intr_add(struct acpi_device *device);
69static int acpi_ec_poll_add(struct acpi_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71static struct acpi_driver acpi_ec_driver = {
Len Brown50526df2005-08-11 17:32:05 -040072 .name = ACPI_EC_DRIVER_NAME,
73 .class = ACPI_EC_CLASS,
74 .ids = ACPI_EC_HID,
75 .ops = {
Len Brown53f11d42005-12-05 16:46:36 -050076 .add = acpi_ec_intr_add,
Len Brown50526df2005-08-11 17:32:05 -040077 .remove = acpi_ec_remove,
78 .start = acpi_ec_start,
79 .stop = acpi_ec_stop,
80 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070081};
Luming Yu45bea152005-07-23 04:08:00 -040082union acpi_ec {
83 struct {
Len Brown50526df2005-08-11 17:32:05 -040084 u32 mode;
85 acpi_handle handle;
86 unsigned long uid;
87 unsigned long gpe_bit;
88 struct acpi_generic_address status_addr;
89 struct acpi_generic_address command_addr;
90 struct acpi_generic_address data_addr;
91 unsigned long global_lock;
Luming Yu45bea152005-07-23 04:08:00 -040092 } common;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Luming Yu45bea152005-07-23 04:08:00 -040094 struct {
Len Brown50526df2005-08-11 17:32:05 -040095 u32 mode;
96 acpi_handle handle;
97 unsigned long uid;
98 unsigned long gpe_bit;
99 struct acpi_generic_address status_addr;
100 struct acpi_generic_address command_addr;
101 struct acpi_generic_address data_addr;
102 unsigned long global_lock;
103 unsigned int expect_event;
104 atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
105 atomic_t pending_gpe;
106 struct semaphore sem;
107 wait_queue_head_t wait;
Len Brown02b28a32005-12-05 16:33:04 -0500108 } intr;
Luming Yu45bea152005-07-23 04:08:00 -0400109
110 struct {
Len Brown50526df2005-08-11 17:32:05 -0400111 u32 mode;
112 acpi_handle handle;
113 unsigned long uid;
114 unsigned long gpe_bit;
115 struct acpi_generic_address status_addr;
116 struct acpi_generic_address command_addr;
117 struct acpi_generic_address data_addr;
118 unsigned long global_lock;
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500119 struct semaphore sem;
Len Brown02b28a32005-12-05 16:33:04 -0500120 } poll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121};
122
Len Brown02b28a32005-12-05 16:33:04 -0500123static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event);
124static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event);
125static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data);
126static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data);
127static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data);
128static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data);
129static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data);
130static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data);
131static void acpi_ec_gpe_poll_query(void *ec_cxt);
132static void acpi_ec_gpe_intr_query(void *ec_cxt);
133static u32 acpi_ec_gpe_poll_handler(void *data);
134static u32 acpi_ec_gpe_intr_handler(void *data);
Luming Yu45bea152005-07-23 04:08:00 -0400135static acpi_status __init
Len Brown02b28a32005-12-05 16:33:04 -0500136acpi_fake_ecdt_poll_callback(acpi_handle handle,
Len Brown50526df2005-08-11 17:32:05 -0400137 u32 Level, void *context, void **retval);
Luming Yu45bea152005-07-23 04:08:00 -0400138
139static acpi_status __init
Len Brown02b28a32005-12-05 16:33:04 -0500140acpi_fake_ecdt_intr_callback(acpi_handle handle,
Len Brown50526df2005-08-11 17:32:05 -0400141 u32 Level, void *context, void **retval);
Luming Yu45bea152005-07-23 04:08:00 -0400142
Len Brown02b28a32005-12-05 16:33:04 -0500143static int __init acpi_ec_poll_get_real_ecdt(void);
144static int __init acpi_ec_intr_get_real_ecdt(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145/* If we find an EC via the ECDT, we need to keep a ptr to its context */
Len Brown50526df2005-08-11 17:32:05 -0400146static union acpi_ec *ec_ecdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148/* External interfaces use first EC only, so remember */
149static struct acpi_device *first_ec;
Len Brown53f11d42005-12-05 16:46:36 -0500150static int acpi_ec_poll_mode = EC_INTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152/* --------------------------------------------------------------------------
153 Transaction Management
154 -------------------------------------------------------------------------- */
155
Arjan van de Ven858119e2006-01-14 13:20:43 -0800156static u32 acpi_ec_read_status(union acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
Len Brown50526df2005-08-11 17:32:05 -0400158 u32 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
Luming Yu45bea152005-07-23 04:08:00 -0400160 acpi_hw_low_level_read(8, &status, &ec->common.status_addr);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500161 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
Len Brown50526df2005-08-11 17:32:05 -0400164static int acpi_ec_wait(union acpi_ec *ec, u8 event)
Luming Yu45bea152005-07-23 04:08:00 -0400165{
Len Brown02b28a32005-12-05 16:33:04 -0500166 if (acpi_ec_poll_mode)
167 return acpi_ec_poll_wait(ec, event);
Luming Yu45bea152005-07-23 04:08:00 -0400168 else
Len Brown02b28a32005-12-05 16:33:04 -0500169 return acpi_ec_intr_wait(ec, event);
Luming Yu45bea152005-07-23 04:08:00 -0400170}
171
Len Brown02b28a32005-12-05 16:33:04 -0500172static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event)
Luming Yu45bea152005-07-23 04:08:00 -0400173{
Len Brown50526df2005-08-11 17:32:05 -0400174 u32 acpi_ec_status = 0;
175 u32 i = ACPI_EC_UDELAY_COUNT;
Luming Yu45bea152005-07-23 04:08:00 -0400176
177 if (!ec)
178 return -EINVAL;
179
180 /* Poll the EC status register waiting for the event to occur. */
181 switch (event) {
182 case ACPI_EC_EVENT_OBF:
183 do {
Len Brown50526df2005-08-11 17:32:05 -0400184 acpi_hw_low_level_read(8, &acpi_ec_status,
185 &ec->common.status_addr);
Luming Yu45bea152005-07-23 04:08:00 -0400186 if (acpi_ec_status & ACPI_EC_FLAG_OBF)
187 return 0;
188 udelay(ACPI_EC_UDELAY);
Len Brown50526df2005-08-11 17:32:05 -0400189 } while (--i > 0);
Luming Yu45bea152005-07-23 04:08:00 -0400190 break;
191 case ACPI_EC_EVENT_IBE:
192 do {
Len Brown50526df2005-08-11 17:32:05 -0400193 acpi_hw_low_level_read(8, &acpi_ec_status,
194 &ec->common.status_addr);
Luming Yu45bea152005-07-23 04:08:00 -0400195 if (!(acpi_ec_status & ACPI_EC_FLAG_IBF))
196 return 0;
197 udelay(ACPI_EC_UDELAY);
Len Brown50526df2005-08-11 17:32:05 -0400198 } while (--i > 0);
Luming Yu45bea152005-07-23 04:08:00 -0400199 break;
200 default:
201 return -EINVAL;
202 }
203
204 return -ETIME;
205}
Len Brown02b28a32005-12-05 16:33:04 -0500206static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event)
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500207{
Len Brown50526df2005-08-11 17:32:05 -0400208 int result = 0;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500209
210 ACPI_FUNCTION_TRACE("acpi_ec_wait");
211
Len Brown02b28a32005-12-05 16:33:04 -0500212 ec->intr.expect_event = event;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500213 smp_mb();
214
Luming Yu716e0842005-08-10 01:40:00 -0400215 switch (event) {
Luming Yu716e0842005-08-10 01:40:00 -0400216 case ACPI_EC_EVENT_IBE:
217 if (~acpi_ec_read_status(ec) & event) {
Len Brown02b28a32005-12-05 16:33:04 -0500218 ec->intr.expect_event = 0;
Luming Yu716e0842005-08-10 01:40:00 -0400219 return_VALUE(0);
220 }
221 break;
Luming Yu06a2a382005-09-27 00:43:00 -0400222 default:
Luming Yu716e0842005-08-10 01:40:00 -0400223 break;
224 }
225
Len Brown02b28a32005-12-05 16:33:04 -0500226 result = wait_event_timeout(ec->intr.wait,
227 !ec->intr.expect_event,
Len Brown50526df2005-08-11 17:32:05 -0400228 msecs_to_jiffies(ACPI_EC_DELAY));
229
Len Brown02b28a32005-12-05 16:33:04 -0500230 ec->intr.expect_event = 0;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500231 smp_mb();
232
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500233 /*
234 * Verify that the event in question has actually happened by
235 * querying EC status. Do the check even if operation timed-out
236 * to make sure that we did not miss interrupt.
237 */
238 switch (event) {
239 case ACPI_EC_EVENT_OBF:
240 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF)
241 return_VALUE(0);
242 break;
243
244 case ACPI_EC_EVENT_IBE:
245 if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
246 return_VALUE(0);
247 break;
248 }
249
250 return_VALUE(-ETIME);
251}
252
Len Brown02b28a32005-12-05 16:33:04 -0500253#ifdef ACPI_FUTURE_USAGE
Luming Yu06a2a382005-09-27 00:43:00 -0400254/*
255 * Note: samsung nv5000 doesn't work with ec burst mode.
256 * http://bugzilla.kernel.org/show_bug.cgi?id=4980
257 */
258int acpi_ec_enter_burst_mode(union acpi_ec *ec)
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500259{
Len Brown50526df2005-08-11 17:32:05 -0400260 u32 tmp = 0;
261 int status = 0;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500262
263 ACPI_FUNCTION_TRACE("acpi_ec_enter_burst_mode");
264
265 status = acpi_ec_read_status(ec);
Len Brown50526df2005-08-11 17:32:05 -0400266 if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
Luming Yu716e0842005-08-10 01:40:00 -0400267 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
Len Brown50526df2005-08-11 17:32:05 -0400268 if (status)
Luming Yu716e0842005-08-10 01:40:00 -0400269 goto end;
Len Brown50526df2005-08-11 17:32:05 -0400270 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE,
271 &ec->common.command_addr);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500272 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
Luming Yu45bea152005-07-23 04:08:00 -0400273 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
Len Brown50526df2005-08-11 17:32:05 -0400274 if (tmp != 0x90) { /* Burst ACK byte */
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500275 return_VALUE(-EINVAL);
276 }
Luming Yu668d74c2005-07-23 00:26:33 -0400277 }
278
Len Brown02b28a32005-12-05 16:33:04 -0500279 atomic_set(&ec->intr.leaving_burst, 0);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500280 return_VALUE(0);
Len Brown50526df2005-08-11 17:32:05 -0400281 end:
Thomas Renningera6fc6722006-06-26 23:58:43 -0400282 ACPI_EXCEPTION ((AE_INFO, status, "EC wait, burst mode");
Luming Yu716e0842005-08-10 01:40:00 -0400283 return_VALUE(-1);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500284}
285
Luming Yu06a2a382005-09-27 00:43:00 -0400286int acpi_ec_leave_burst_mode(union acpi_ec *ec)
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500287{
Luming Yu06a2a382005-09-27 00:43:00 -0400288 int status = 0;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500289
290 ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode");
291
Luming Yu06a2a382005-09-27 00:43:00 -0400292 status = acpi_ec_read_status(ec);
293 if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
294 status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
295 if(status)
296 goto end;
297 acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->common.command_addr);
298 acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
299 }
Len Brown02b28a32005-12-05 16:33:04 -0500300 atomic_set(&ec->intr.leaving_burst, 1);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500301 return_VALUE(0);
Luming Yu06a2a382005-09-27 00:43:00 -0400302end:
Thomas Renningera6fc6722006-06-26 23:58:43 -0400303 ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode");
Luming Yu06a2a382005-09-27 00:43:00 -0400304 return_VALUE(-1);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500305}
Len Brown02b28a32005-12-05 16:33:04 -0500306#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Len Brown50526df2005-08-11 17:32:05 -0400308static int acpi_ec_read(union acpi_ec *ec, u8 address, u32 * data)
Luming Yu45bea152005-07-23 04:08:00 -0400309{
Len Brown02b28a32005-12-05 16:33:04 -0500310 if (acpi_ec_poll_mode)
311 return acpi_ec_poll_read(ec, address, data);
Luming Yu45bea152005-07-23 04:08:00 -0400312 else
Len Brown02b28a32005-12-05 16:33:04 -0500313 return acpi_ec_intr_read(ec, address, data);
Luming Yu45bea152005-07-23 04:08:00 -0400314}
Len Brown50526df2005-08-11 17:32:05 -0400315static int acpi_ec_write(union acpi_ec *ec, u8 address, u8 data)
Luming Yu45bea152005-07-23 04:08:00 -0400316{
Len Brown02b28a32005-12-05 16:33:04 -0500317 if (acpi_ec_poll_mode)
318 return acpi_ec_poll_write(ec, address, data);
Luming Yu45bea152005-07-23 04:08:00 -0400319 else
Len Brown02b28a32005-12-05 16:33:04 -0500320 return acpi_ec_intr_write(ec, address, data);
Luming Yu45bea152005-07-23 04:08:00 -0400321}
Len Brown02b28a32005-12-05 16:33:04 -0500322static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data)
Luming Yu45bea152005-07-23 04:08:00 -0400323{
Len Brown50526df2005-08-11 17:32:05 -0400324 acpi_status status = AE_OK;
325 int result = 0;
Len Brown50526df2005-08-11 17:32:05 -0400326 u32 glk = 0;
Luming Yu45bea152005-07-23 04:08:00 -0400327
328 ACPI_FUNCTION_TRACE("acpi_ec_read");
329
330 if (!ec || !data)
331 return_VALUE(-EINVAL);
332
333 *data = 0;
334
335 if (ec->common.global_lock) {
336 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
337 if (ACPI_FAILURE(status))
338 return_VALUE(-ENODEV);
339 }
340
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500341 if (down_interruptible(&ec->poll.sem)) {
342 result = -ERESTARTSYS;
343 goto end_nosem;
344 }
345
Len Brown50526df2005-08-11 17:32:05 -0400346 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
347 &ec->common.command_addr);
Luming Yu45bea152005-07-23 04:08:00 -0400348 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
349 if (result)
350 goto end;
351
352 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
353 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
354 if (result)
355 goto end;
356
357 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
358
359 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
Len Brown50526df2005-08-11 17:32:05 -0400360 *data, address));
361
362 end:
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500363 up(&ec->poll.sem);
364end_nosem:
Luming Yu45bea152005-07-23 04:08:00 -0400365 if (ec->common.global_lock)
366 acpi_release_global_lock(glk);
367
368 return_VALUE(result);
369}
370
Len Brown02b28a32005-12-05 16:33:04 -0500371static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data)
Luming Yu45bea152005-07-23 04:08:00 -0400372{
Len Brown50526df2005-08-11 17:32:05 -0400373 int result = 0;
374 acpi_status status = AE_OK;
Len Brown50526df2005-08-11 17:32:05 -0400375 u32 glk = 0;
Luming Yu45bea152005-07-23 04:08:00 -0400376
377 ACPI_FUNCTION_TRACE("acpi_ec_write");
378
379 if (!ec)
380 return_VALUE(-EINVAL);
381
382 if (ec->common.global_lock) {
383 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
384 if (ACPI_FAILURE(status))
385 return_VALUE(-ENODEV);
386 }
387
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500388 if (down_interruptible(&ec->poll.sem)) {
389 result = -ERESTARTSYS;
390 goto end_nosem;
391 }
392
Len Brown50526df2005-08-11 17:32:05 -0400393 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
394 &ec->common.command_addr);
Luming Yu45bea152005-07-23 04:08:00 -0400395 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
396 if (result)
397 goto end;
398
399 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
400 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
401 if (result)
402 goto end;
403
404 acpi_hw_low_level_write(8, data, &ec->common.data_addr);
405 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
406 if (result)
407 goto end;
408
409 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
Len Brown50526df2005-08-11 17:32:05 -0400410 data, address));
Luming Yu45bea152005-07-23 04:08:00 -0400411
Len Brown50526df2005-08-11 17:32:05 -0400412 end:
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500413 up(&ec->poll.sem);
414end_nosem:
Luming Yu45bea152005-07-23 04:08:00 -0400415 if (ec->common.global_lock)
416 acpi_release_global_lock(glk);
417
418 return_VALUE(result);
419}
420
Len Brown02b28a32005-12-05 16:33:04 -0500421static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
Len Brown50526df2005-08-11 17:32:05 -0400423 int status = 0;
424 u32 glk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 ACPI_FUNCTION_TRACE("acpi_ec_read");
427
428 if (!ec || !data)
429 return_VALUE(-EINVAL);
430
431 *data = 0;
432
Luming Yu45bea152005-07-23 04:08:00 -0400433 if (ec->common.global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
435 if (ACPI_FAILURE(status))
436 return_VALUE(-ENODEV);
437 }
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500438
439 WARN_ON(in_interrupt());
Len Brown02b28a32005-12-05 16:33:04 -0500440 down(&ec->intr.sem);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500441
Luming Yu716e0842005-08-10 01:40:00 -0400442 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
443 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500444 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500445 goto end;
Luming Yu716e0842005-08-10 01:40:00 -0400446 }
Len Brown50526df2005-08-11 17:32:05 -0400447 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
448 &ec->common.command_addr);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500449 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500450 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500451 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500452 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Luming Yu45bea152005-07-23 04:08:00 -0400454 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
Len Brown50526df2005-08-11 17:32:05 -0400455 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
456 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500457 printk(KERN_DEBUG PREFIX "read EC, OB not full\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 goto end;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500459 }
Luming Yu45bea152005-07-23 04:08:00 -0400460 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
Len Brown50526df2005-08-11 17:32:05 -0400462 *data, address));
463
464 end:
Len Brown02b28a32005-12-05 16:33:04 -0500465 up(&ec->intr.sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Luming Yu45bea152005-07-23 04:08:00 -0400467 if (ec->common.global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 acpi_release_global_lock(glk);
469
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500470 return_VALUE(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471}
472
Len Brown02b28a32005-12-05 16:33:04 -0500473static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
Len Brown50526df2005-08-11 17:32:05 -0400475 int status = 0;
476 u32 glk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 ACPI_FUNCTION_TRACE("acpi_ec_write");
479
480 if (!ec)
481 return_VALUE(-EINVAL);
Luming Yu716e0842005-08-10 01:40:00 -0400482
Luming Yu45bea152005-07-23 04:08:00 -0400483 if (ec->common.global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
485 if (ACPI_FAILURE(status))
486 return_VALUE(-ENODEV);
487 }
488
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500489 WARN_ON(in_interrupt());
Len Brown02b28a32005-12-05 16:33:04 -0500490 down(&ec->intr.sem);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500491
Luming Yu716e0842005-08-10 01:40:00 -0400492 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
Len Brown50526df2005-08-11 17:32:05 -0400493 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500494 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500495 }
Len Brown50526df2005-08-11 17:32:05 -0400496 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
497 &ec->common.command_addr);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500498 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
Luming Yu716e0842005-08-10 01:40:00 -0400499 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500500 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500501 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Luming Yu45bea152005-07-23 04:08:00 -0400503 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500504 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
Len Brown50526df2005-08-11 17:32:05 -0400505 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500506 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Luming Yu45bea152005-07-23 04:08:00 -0400509 acpi_hw_low_level_write(8, data, &ec->common.data_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
511 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
Len Brown50526df2005-08-11 17:32:05 -0400512 data, address));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
Len Brown02b28a32005-12-05 16:33:04 -0500514 up(&ec->intr.sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Luming Yu45bea152005-07-23 04:08:00 -0400516 if (ec->common.global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 acpi_release_global_lock(glk);
518
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500519 return_VALUE(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520}
521
522/*
523 * Externally callable EC access functions. For now, assume 1 EC only
524 */
Len Brown50526df2005-08-11 17:32:05 -0400525int ec_read(u8 addr, u8 * val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
Luming Yu45bea152005-07-23 04:08:00 -0400527 union acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 int err;
529 u32 temp_data;
530
531 if (!first_ec)
532 return -ENODEV;
533
534 ec = acpi_driver_data(first_ec);
535
536 err = acpi_ec_read(ec, addr, &temp_data);
537
538 if (!err) {
539 *val = temp_data;
540 return 0;
Len Brown50526df2005-08-11 17:32:05 -0400541 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 return err;
543}
Len Brown50526df2005-08-11 17:32:05 -0400544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545EXPORT_SYMBOL(ec_read);
546
Len Brown50526df2005-08-11 17:32:05 -0400547int ec_write(u8 addr, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
Luming Yu45bea152005-07-23 04:08:00 -0400549 union acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 int err;
551
552 if (!first_ec)
553 return -ENODEV;
554
555 ec = acpi_driver_data(first_ec);
556
557 err = acpi_ec_write(ec, addr, val);
558
559 return err;
560}
Len Brown50526df2005-08-11 17:32:05 -0400561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562EXPORT_SYMBOL(ec_write);
563
Len Brown50526df2005-08-11 17:32:05 -0400564static int acpi_ec_query(union acpi_ec *ec, u32 * data)
Luming Yu45bea152005-07-23 04:08:00 -0400565{
Len Brown02b28a32005-12-05 16:33:04 -0500566 if (acpi_ec_poll_mode)
567 return acpi_ec_poll_query(ec, data);
Luming Yu45bea152005-07-23 04:08:00 -0400568 else
Len Brown02b28a32005-12-05 16:33:04 -0500569 return acpi_ec_intr_query(ec, data);
Luming Yu45bea152005-07-23 04:08:00 -0400570}
Len Brown02b28a32005-12-05 16:33:04 -0500571static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data)
Luming Yu45bea152005-07-23 04:08:00 -0400572{
Len Brown50526df2005-08-11 17:32:05 -0400573 int result = 0;
574 acpi_status status = AE_OK;
Len Brown50526df2005-08-11 17:32:05 -0400575 u32 glk = 0;
Luming Yu45bea152005-07-23 04:08:00 -0400576
577 ACPI_FUNCTION_TRACE("acpi_ec_query");
578
579 if (!ec || !data)
580 return_VALUE(-EINVAL);
581
582 *data = 0;
583
584 if (ec->common.global_lock) {
585 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
586 if (ACPI_FAILURE(status))
587 return_VALUE(-ENODEV);
588 }
589
590 /*
591 * Query the EC to find out which _Qxx method we need to evaluate.
592 * Note that successful completion of the query causes the ACPI_EC_SCI
593 * bit to be cleared (and thus clearing the interrupt source).
594 */
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500595 if (down_interruptible(&ec->poll.sem)) {
596 result = -ERESTARTSYS;
597 goto end_nosem;
598 }
599
Len Brown50526df2005-08-11 17:32:05 -0400600 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
601 &ec->common.command_addr);
Luming Yu45bea152005-07-23 04:08:00 -0400602 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
603 if (result)
604 goto end;
605
606 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
607 if (!*data)
608 result = -ENODATA;
609
Len Brown50526df2005-08-11 17:32:05 -0400610 end:
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500611 up(&ec->poll.sem);
612end_nosem:
Luming Yu45bea152005-07-23 04:08:00 -0400613 if (ec->common.global_lock)
614 acpi_release_global_lock(glk);
615
616 return_VALUE(result);
617}
Len Brown02b28a32005-12-05 16:33:04 -0500618static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619{
Len Brown50526df2005-08-11 17:32:05 -0400620 int status = 0;
621 u32 glk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623 ACPI_FUNCTION_TRACE("acpi_ec_query");
624
625 if (!ec || !data)
626 return_VALUE(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 *data = 0;
628
Luming Yu45bea152005-07-23 04:08:00 -0400629 if (ec->common.global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
631 if (ACPI_FAILURE(status))
632 return_VALUE(-ENODEV);
633 }
634
Len Brown02b28a32005-12-05 16:33:04 -0500635 down(&ec->intr.sem);
Luming Yu716e0842005-08-10 01:40:00 -0400636
637 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
638 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500639 printk(KERN_DEBUG PREFIX "query EC, IB not empty\n");
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500640 goto end;
Luming Yu716e0842005-08-10 01:40:00 -0400641 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 /*
643 * Query the EC to find out which _Qxx method we need to evaluate.
644 * Note that successful completion of the query causes the ACPI_EC_SCI
645 * bit to be cleared (and thus clearing the interrupt source).
646 */
Len Brown50526df2005-08-11 17:32:05 -0400647 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
648 &ec->common.command_addr);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500649 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
Len Brown50526df2005-08-11 17:32:05 -0400650 if (status) {
Len Brown1e8df532005-12-05 16:47:46 -0500651 printk(KERN_DEBUG PREFIX "query EC, OB not full\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 goto end;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500653 }
654
Luming Yu45bea152005-07-23 04:08:00 -0400655 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 if (!*data)
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500657 status = -ENODATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Len Brown50526df2005-08-11 17:32:05 -0400659 end:
Len Brown02b28a32005-12-05 16:33:04 -0500660 up(&ec->intr.sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Luming Yu45bea152005-07-23 04:08:00 -0400662 if (ec->common.global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 acpi_release_global_lock(glk);
664
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500665 return_VALUE(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668/* --------------------------------------------------------------------------
669 Event Management
670 -------------------------------------------------------------------------- */
671
Luming Yu45bea152005-07-23 04:08:00 -0400672union acpi_ec_query_data {
Len Brown50526df2005-08-11 17:32:05 -0400673 acpi_handle handle;
674 u8 data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675};
676
Len Brown50526df2005-08-11 17:32:05 -0400677static void acpi_ec_gpe_query(void *ec_cxt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678{
Len Brown02b28a32005-12-05 16:33:04 -0500679 if (acpi_ec_poll_mode)
680 acpi_ec_gpe_poll_query(ec_cxt);
Luming Yu45bea152005-07-23 04:08:00 -0400681 else
Len Brown02b28a32005-12-05 16:33:04 -0500682 acpi_ec_gpe_intr_query(ec_cxt);
Luming Yu45bea152005-07-23 04:08:00 -0400683}
684
Len Brown02b28a32005-12-05 16:33:04 -0500685static void acpi_ec_gpe_poll_query(void *ec_cxt)
Luming Yu45bea152005-07-23 04:08:00 -0400686{
Len Brown50526df2005-08-11 17:32:05 -0400687 union acpi_ec *ec = (union acpi_ec *)ec_cxt;
688 u32 value = 0;
Len Brown50526df2005-08-11 17:32:05 -0400689 static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
690 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
691 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
692 };
Luming Yu45bea152005-07-23 04:08:00 -0400693
694 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
695
696 if (!ec_cxt)
697 goto end;
698
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500699 if (down_interruptible (&ec->poll.sem)) {
700 return_VOID;
701 }
Luming Yu45bea152005-07-23 04:08:00 -0400702 acpi_hw_low_level_read(8, &value, &ec->common.command_addr);
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -0500703 up(&ec->poll.sem);
Luming Yu45bea152005-07-23 04:08:00 -0400704
705 /* TBD: Implement asynch events!
706 * NOTE: All we care about are EC-SCI's. Other EC events are
707 * handled via polling (yuck!). This is because some systems
708 * treat EC-SCIs as level (versus EDGE!) triggered, preventing
709 * a purely interrupt-driven approach (grumble, grumble).
710 */
711 if (!(value & ACPI_EC_FLAG_SCI))
712 goto end;
713
714 if (acpi_ec_query(ec, &value))
715 goto end;
716
717 object_name[2] = hex[((value >> 4) & 0x0F)];
718 object_name[3] = hex[(value & 0x0F)];
719
720 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
721
722 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
723
Len Brown50526df2005-08-11 17:32:05 -0400724 end:
Luming Yu45bea152005-07-23 04:08:00 -0400725 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
726}
Len Brown02b28a32005-12-05 16:33:04 -0500727static void acpi_ec_gpe_intr_query(void *ec_cxt)
Luming Yu45bea152005-07-23 04:08:00 -0400728{
Len Brown50526df2005-08-11 17:32:05 -0400729 union acpi_ec *ec = (union acpi_ec *)ec_cxt;
730 u32 value;
731 int result = -ENODATA;
732 static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
733 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
734 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
735 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
737 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
738
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500739 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI)
740 result = acpi_ec_query(ec, &value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500742 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 goto end;
744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 object_name[2] = hex[((value >> 4) & 0x0F)];
746 object_name[3] = hex[(value & 0x0F)];
747
748 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
749
Luming Yu45bea152005-07-23 04:08:00 -0400750 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
Len Brown50526df2005-08-11 17:32:05 -0400751 end:
Len Brown02b28a32005-12-05 16:33:04 -0500752 atomic_dec(&ec->intr.pending_gpe);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500753 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754}
755
Len Brown50526df2005-08-11 17:32:05 -0400756static u32 acpi_ec_gpe_handler(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
Len Brown02b28a32005-12-05 16:33:04 -0500758 if (acpi_ec_poll_mode)
759 return acpi_ec_gpe_poll_handler(data);
Luming Yu45bea152005-07-23 04:08:00 -0400760 else
Len Brown02b28a32005-12-05 16:33:04 -0500761 return acpi_ec_gpe_intr_handler(data);
Luming Yu45bea152005-07-23 04:08:00 -0400762}
Len Brown02b28a32005-12-05 16:33:04 -0500763static u32 acpi_ec_gpe_poll_handler(void *data)
Luming Yu45bea152005-07-23 04:08:00 -0400764{
Len Brown50526df2005-08-11 17:32:05 -0400765 acpi_status status = AE_OK;
766 union acpi_ec *ec = (union acpi_ec *)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
768 if (!ec)
769 return ACPI_INTERRUPT_NOT_HANDLED;
770
Luming Yu45bea152005-07-23 04:08:00 -0400771 acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
772
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400773 status = acpi_os_execute(OSL_EC_POLL_HANDLER, acpi_ec_gpe_query, ec);
Luming Yu45bea152005-07-23 04:08:00 -0400774
775 if (status == AE_OK)
776 return ACPI_INTERRUPT_HANDLED;
777 else
778 return ACPI_INTERRUPT_NOT_HANDLED;
779}
Len Brown02b28a32005-12-05 16:33:04 -0500780static u32 acpi_ec_gpe_intr_handler(void *data)
Luming Yu45bea152005-07-23 04:08:00 -0400781{
Len Brown50526df2005-08-11 17:32:05 -0400782 acpi_status status = AE_OK;
783 u32 value;
784 union acpi_ec *ec = (union acpi_ec *)data;
Luming Yu45bea152005-07-23 04:08:00 -0400785
786 if (!ec)
787 return ACPI_INTERRUPT_NOT_HANDLED;
788
Luming Yu716e0842005-08-10 01:40:00 -0400789 acpi_clear_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500790 value = acpi_ec_read_status(ec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Len Brown02b28a32005-12-05 16:33:04 -0500792 switch (ec->intr.expect_event) {
Luming Yu716e0842005-08-10 01:40:00 -0400793 case ACPI_EC_EVENT_OBF:
794 if (!(value & ACPI_EC_FLAG_OBF))
795 break;
796 case ACPI_EC_EVENT_IBE:
797 if ((value & ACPI_EC_FLAG_IBF))
798 break;
Len Brown02b28a32005-12-05 16:33:04 -0500799 ec->intr.expect_event = 0;
800 wake_up(&ec->intr.wait);
Luming Yu716e0842005-08-10 01:40:00 -0400801 return ACPI_INTERRUPT_HANDLED;
802 default:
803 break;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500804 }
805
Len Brown50526df2005-08-11 17:32:05 -0400806 if (value & ACPI_EC_FLAG_SCI) {
Len Brown02b28a32005-12-05 16:33:04 -0500807 atomic_add(1, &ec->intr.pending_gpe);
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400808 status = acpi_os_execute(OSL_EC_BURST_HANDLER,
Len Brown50526df2005-08-11 17:32:05 -0400809 acpi_ec_gpe_query, ec);
Luming Yu17e9c782005-04-22 23:07:10 -0400810 return status == AE_OK ?
Len Brown50526df2005-08-11 17:32:05 -0400811 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
812 }
Luming Yu45bea152005-07-23 04:08:00 -0400813 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500814 return status == AE_OK ?
Len Brown50526df2005-08-11 17:32:05 -0400815 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816}
817
818/* --------------------------------------------------------------------------
819 Address Space Management
820 -------------------------------------------------------------------------- */
821
822static acpi_status
Len Brown50526df2005-08-11 17:32:05 -0400823acpi_ec_space_setup(acpi_handle region_handle,
824 u32 function, void *handler_context, void **return_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825{
826 /*
827 * The EC object is in the handler context and is needed
828 * when calling the acpi_ec_space_handler.
829 */
Len Brown50526df2005-08-11 17:32:05 -0400830 *return_context = (function != ACPI_REGION_DEACTIVATE) ?
831 handler_context : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 return AE_OK;
834}
835
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836static acpi_status
Len Brown50526df2005-08-11 17:32:05 -0400837acpi_ec_space_handler(u32 function,
838 acpi_physical_address address,
839 u32 bit_width,
840 acpi_integer * value,
841 void *handler_context, void *region_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
Len Brown50526df2005-08-11 17:32:05 -0400843 int result = 0;
844 union acpi_ec *ec = NULL;
845 u64 temp = *value;
846 acpi_integer f_v = 0;
847 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
849 ACPI_FUNCTION_TRACE("acpi_ec_space_handler");
850
851 if ((address > 0xFF) || !value || !handler_context)
852 return_VALUE(AE_BAD_PARAMETER);
853
Luming Yufa9cd542005-03-19 01:54:47 -0500854 if (bit_width != 8 && acpi_strict) {
Len Brown50526df2005-08-11 17:32:05 -0400855 printk(KERN_WARNING PREFIX
856 "acpi_ec_space_handler: bit_width should be 8\n");
Luming Yufa9cd542005-03-19 01:54:47 -0500857 return_VALUE(AE_BAD_PARAMETER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 }
859
Len Brown50526df2005-08-11 17:32:05 -0400860 ec = (union acpi_ec *)handler_context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Len Brown50526df2005-08-11 17:32:05 -0400862 next_byte:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 switch (function) {
864 case ACPI_READ:
Luming Yufa9cd542005-03-19 01:54:47 -0500865 temp = 0;
Len Brown50526df2005-08-11 17:32:05 -0400866 result = acpi_ec_read(ec, (u8) address, (u32 *) & temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 break;
868 case ACPI_WRITE:
Luming Yufa9cd542005-03-19 01:54:47 -0500869 result = acpi_ec_write(ec, (u8) address, (u8) temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 break;
871 default:
872 result = -EINVAL;
873 goto out;
874 break;
875 }
876
877 bit_width -= 8;
Luming Yufa9cd542005-03-19 01:54:47 -0500878 if (bit_width) {
879 if (function == ACPI_READ)
880 f_v |= temp << 8 * i;
881 if (function == ACPI_WRITE)
882 temp >>= 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 i++;
Andrew Morton83ea7442005-03-30 22:12:13 -0500884 address++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 goto next_byte;
886 }
887
Luming Yufa9cd542005-03-19 01:54:47 -0500888 if (function == ACPI_READ) {
889 f_v |= temp << 8 * i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 *value = f_v;
891 }
892
Len Brown50526df2005-08-11 17:32:05 -0400893 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 switch (result) {
895 case -EINVAL:
896 return_VALUE(AE_BAD_PARAMETER);
897 break;
898 case -ENODEV:
899 return_VALUE(AE_NOT_FOUND);
900 break;
901 case -ETIME:
902 return_VALUE(AE_TIME);
903 break;
904 default:
905 return_VALUE(AE_OK);
906 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907}
908
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909/* --------------------------------------------------------------------------
910 FS Interface (/proc)
911 -------------------------------------------------------------------------- */
912
Len Brown50526df2005-08-11 17:32:05 -0400913static struct proc_dir_entry *acpi_ec_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914
Len Brown50526df2005-08-11 17:32:05 -0400915static int acpi_ec_read_info(struct seq_file *seq, void *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
Len Brown50526df2005-08-11 17:32:05 -0400917 union acpi_ec *ec = (union acpi_ec *)seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 ACPI_FUNCTION_TRACE("acpi_ec_read_info");
920
921 if (!ec)
922 goto end;
923
924 seq_printf(seq, "gpe bit: 0x%02x\n",
Len Brown50526df2005-08-11 17:32:05 -0400925 (u32) ec->common.gpe_bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 seq_printf(seq, "ports: 0x%02x, 0x%02x\n",
Len Brown50526df2005-08-11 17:32:05 -0400927 (u32) ec->common.status_addr.address,
928 (u32) ec->common.data_addr.address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 seq_printf(seq, "use global lock: %s\n",
Len Brown50526df2005-08-11 17:32:05 -0400930 ec->common.global_lock ? "yes" : "no");
Luming Yu45bea152005-07-23 04:08:00 -0400931 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932
Len Brown50526df2005-08-11 17:32:05 -0400933 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 return_VALUE(0);
935}
936
937static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
938{
939 return single_open(file, acpi_ec_read_info, PDE(inode)->data);
940}
941
942static struct file_operations acpi_ec_info_ops = {
Len Brown50526df2005-08-11 17:32:05 -0400943 .open = acpi_ec_info_open_fs,
944 .read = seq_read,
945 .llseek = seq_lseek,
946 .release = single_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 .owner = THIS_MODULE,
948};
949
Len Brown50526df2005-08-11 17:32:05 -0400950static int acpi_ec_add_fs(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951{
Len Brown50526df2005-08-11 17:32:05 -0400952 struct proc_dir_entry *entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
954 ACPI_FUNCTION_TRACE("acpi_ec_add_fs");
955
956 if (!acpi_device_dir(device)) {
957 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
Len Brown50526df2005-08-11 17:32:05 -0400958 acpi_ec_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 if (!acpi_device_dir(device))
960 return_VALUE(-ENODEV);
961 }
962
963 entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
Len Brown50526df2005-08-11 17:32:05 -0400964 acpi_device_dir(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 if (!entry)
Thomas Renningera6fc6722006-06-26 23:58:43 -0400966 return_VALUE(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 else {
968 entry->proc_fops = &acpi_ec_info_ops;
969 entry->data = acpi_driver_data(device);
970 entry->owner = THIS_MODULE;
971 }
972
973 return_VALUE(0);
974}
975
Len Brown50526df2005-08-11 17:32:05 -0400976static int acpi_ec_remove_fs(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977{
978 ACPI_FUNCTION_TRACE("acpi_ec_remove_fs");
979
980 if (acpi_device_dir(device)) {
981 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
982 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
983 acpi_device_dir(device) = NULL;
984 }
985
986 return_VALUE(0);
987}
988
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989/* --------------------------------------------------------------------------
990 Driver Interface
991 -------------------------------------------------------------------------- */
992
Len Brown02b28a32005-12-05 16:33:04 -0500993static int acpi_ec_poll_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994{
Len Brown50526df2005-08-11 17:32:05 -0400995 int result = 0;
996 acpi_status status = AE_OK;
997 union acpi_ec *ec = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
999 ACPI_FUNCTION_TRACE("acpi_ec_add");
1000
1001 if (!device)
1002 return_VALUE(-EINVAL);
1003
Luming Yu45bea152005-07-23 04:08:00 -04001004 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 if (!ec)
1006 return_VALUE(-ENOMEM);
Luming Yu45bea152005-07-23 04:08:00 -04001007 memset(ec, 0, sizeof(union acpi_ec));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Luming Yu45bea152005-07-23 04:08:00 -04001009 ec->common.handle = device->handle;
1010 ec->common.uid = -1;
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -05001011 init_MUTEX(&ec->poll.sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1013 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1014 acpi_driver_data(device) = ec;
1015
1016 /* Use the global lock for all EC transactions? */
Len Brown50526df2005-08-11 17:32:05 -04001017 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1018 &ec->common.global_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
Jiri Slabyff2fc3e2006-03-28 17:04:00 -05001020 /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1021 http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1022 if (ec_ecdt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
Len Brown50526df2005-08-11 17:32:05 -04001024 ACPI_ADR_SPACE_EC,
1025 &acpi_ec_space_handler);
1026
1027 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1028 &acpi_ec_gpe_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
1030 kfree(ec_ecdt);
1031 }
1032
1033 /* Get GPE bit assignment (EC events). */
1034 /* TODO: Add support for _GPE returning a package */
Len Brown50526df2005-08-11 17:32:05 -04001035 status =
1036 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1037 &ec->common.gpe_bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001039 ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 result = -ENODEV;
1041 goto end;
1042 }
1043
1044 result = acpi_ec_add_fs(device);
1045 if (result)
1046 goto end;
1047
Len Brown02b28a32005-12-05 16:33:04 -05001048 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) polling mode.\n",
Len Brown50526df2005-08-11 17:32:05 -04001049 acpi_device_name(device), acpi_device_bid(device),
1050 (u32) ec->common.gpe_bit);
Luming Yu45bea152005-07-23 04:08:00 -04001051
1052 if (!first_ec)
1053 first_ec = device;
1054
Len Brown50526df2005-08-11 17:32:05 -04001055 end:
Luming Yu45bea152005-07-23 04:08:00 -04001056 if (result)
1057 kfree(ec);
1058
1059 return_VALUE(result);
1060}
Len Brown02b28a32005-12-05 16:33:04 -05001061static int acpi_ec_intr_add(struct acpi_device *device)
Luming Yu45bea152005-07-23 04:08:00 -04001062{
Len Brown50526df2005-08-11 17:32:05 -04001063 int result = 0;
1064 acpi_status status = AE_OK;
1065 union acpi_ec *ec = NULL;
Luming Yu45bea152005-07-23 04:08:00 -04001066
1067 ACPI_FUNCTION_TRACE("acpi_ec_add");
1068
1069 if (!device)
1070 return_VALUE(-EINVAL);
1071
1072 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1073 if (!ec)
1074 return_VALUE(-ENOMEM);
1075 memset(ec, 0, sizeof(union acpi_ec));
1076
1077 ec->common.handle = device->handle;
1078 ec->common.uid = -1;
Len Brown02b28a32005-12-05 16:33:04 -05001079 atomic_set(&ec->intr.pending_gpe, 0);
1080 atomic_set(&ec->intr.leaving_burst, 1);
1081 init_MUTEX(&ec->intr.sem);
1082 init_waitqueue_head(&ec->intr.wait);
Luming Yu45bea152005-07-23 04:08:00 -04001083 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1084 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1085 acpi_driver_data(device) = ec;
1086
1087 /* Use the global lock for all EC transactions? */
Len Brown50526df2005-08-11 17:32:05 -04001088 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1089 &ec->common.global_lock);
Luming Yu45bea152005-07-23 04:08:00 -04001090
Jiri Slabyff2fc3e2006-03-28 17:04:00 -05001091 /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1092 http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1093 if (ec_ecdt) {
Luming Yu45bea152005-07-23 04:08:00 -04001094 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
Len Brown50526df2005-08-11 17:32:05 -04001095 ACPI_ADR_SPACE_EC,
1096 &acpi_ec_space_handler);
Luming Yu45bea152005-07-23 04:08:00 -04001097
Len Brown50526df2005-08-11 17:32:05 -04001098 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1099 &acpi_ec_gpe_handler);
Luming Yu45bea152005-07-23 04:08:00 -04001100
1101 kfree(ec_ecdt);
1102 }
1103
1104 /* Get GPE bit assignment (EC events). */
1105 /* TODO: Add support for _GPE returning a package */
Len Brown50526df2005-08-11 17:32:05 -04001106 status =
1107 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1108 &ec->common.gpe_bit);
Luming Yu45bea152005-07-23 04:08:00 -04001109 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001110 ACPI_ERROR((AE_INFO, "Obtaining GPE bit assignment"));
Luming Yu45bea152005-07-23 04:08:00 -04001111 result = -ENODEV;
1112 goto end;
1113 }
1114
1115 result = acpi_ec_add_fs(device);
1116 if (result)
1117 goto end;
1118
Len Brown02b28a32005-12-05 16:33:04 -05001119 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) interrupt mode.\n",
Len Brown50526df2005-08-11 17:32:05 -04001120 acpi_device_name(device), acpi_device_bid(device),
1121 (u32) ec->common.gpe_bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
1123 if (!first_ec)
1124 first_ec = device;
1125
Len Brown50526df2005-08-11 17:32:05 -04001126 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 if (result)
1128 kfree(ec);
1129
1130 return_VALUE(result);
1131}
1132
Len Brown50526df2005-08-11 17:32:05 -04001133static int acpi_ec_remove(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134{
Len Brown50526df2005-08-11 17:32:05 -04001135 union acpi_ec *ec = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
1137 ACPI_FUNCTION_TRACE("acpi_ec_remove");
1138
1139 if (!device)
1140 return_VALUE(-EINVAL);
1141
1142 ec = acpi_driver_data(device);
1143
1144 acpi_ec_remove_fs(device);
1145
1146 kfree(ec);
1147
1148 return_VALUE(0);
1149}
1150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151static acpi_status
Len Brown50526df2005-08-11 17:32:05 -04001152acpi_ec_io_ports(struct acpi_resource *resource, void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153{
Len Brown50526df2005-08-11 17:32:05 -04001154 union acpi_ec *ec = (union acpi_ec *)context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 struct acpi_generic_address *addr;
1156
Bob Moore50eca3e2005-09-30 19:03:00 -04001157 if (resource->type != ACPI_RESOURCE_TYPE_IO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 return AE_OK;
1159 }
1160
1161 /*
1162 * The first address region returned is the data port, and
1163 * the second address region returned is the status/command
1164 * port.
1165 */
Luming Yu45bea152005-07-23 04:08:00 -04001166 if (ec->common.data_addr.register_bit_width == 0) {
1167 addr = &ec->common.data_addr;
1168 } else if (ec->common.command_addr.register_bit_width == 0) {
1169 addr = &ec->common.command_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 } else {
1171 return AE_CTRL_TERMINATE;
1172 }
1173
1174 addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1175 addr->register_bit_width = 8;
1176 addr->register_bit_offset = 0;
Bob Moore50eca3e2005-09-30 19:03:00 -04001177 addr->address = resource->data.io.minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
1179 return AE_OK;
1180}
1181
Len Brown50526df2005-08-11 17:32:05 -04001182static int acpi_ec_start(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183{
Len Brown50526df2005-08-11 17:32:05 -04001184 acpi_status status = AE_OK;
1185 union acpi_ec *ec = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
1187 ACPI_FUNCTION_TRACE("acpi_ec_start");
1188
1189 if (!device)
1190 return_VALUE(-EINVAL);
1191
1192 ec = acpi_driver_data(device);
1193
1194 if (!ec)
1195 return_VALUE(-EINVAL);
1196
1197 /*
1198 * Get I/O port addresses. Convert to GAS format.
1199 */
Luming Yu45bea152005-07-23 04:08:00 -04001200 status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS,
Len Brown50526df2005-08-11 17:32:05 -04001201 acpi_ec_io_ports, ec);
1202 if (ACPI_FAILURE(status)
1203 || ec->common.command_addr.register_bit_width == 0) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001204 ACPI_ERROR((AE_INFO, "Error getting I/O port addresses"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 return_VALUE(-ENODEV);
1206 }
1207
Luming Yu45bea152005-07-23 04:08:00 -04001208 ec->common.status_addr = ec->common.command_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
1210 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
Len Brown50526df2005-08-11 17:32:05 -04001211 (u32) ec->common.gpe_bit,
1212 (u32) ec->common.command_addr.address,
1213 (u32) ec->common.data_addr.address));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 /*
1216 * Install GPE handler
1217 */
Luming Yu45bea152005-07-23 04:08:00 -04001218 status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit,
Len Brown50526df2005-08-11 17:32:05 -04001219 ACPI_GPE_EDGE_TRIGGERED,
1220 &acpi_ec_gpe_handler, ec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 if (ACPI_FAILURE(status)) {
1222 return_VALUE(-ENODEV);
1223 }
Len Brown50526df2005-08-11 17:32:05 -04001224 acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1225 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226
Len Brown50526df2005-08-11 17:32:05 -04001227 status = acpi_install_address_space_handler(ec->common.handle,
1228 ACPI_ADR_SPACE_EC,
1229 &acpi_ec_space_handler,
1230 &acpi_ec_space_setup, ec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 if (ACPI_FAILURE(status)) {
Len Brown50526df2005-08-11 17:32:05 -04001232 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1233 &acpi_ec_gpe_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 return_VALUE(-ENODEV);
1235 }
1236
1237 return_VALUE(AE_OK);
1238}
1239
Len Brown50526df2005-08-11 17:32:05 -04001240static int acpi_ec_stop(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241{
Len Brown50526df2005-08-11 17:32:05 -04001242 acpi_status status = AE_OK;
1243 union acpi_ec *ec = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
1245 ACPI_FUNCTION_TRACE("acpi_ec_stop");
1246
1247 if (!device)
1248 return_VALUE(-EINVAL);
1249
1250 ec = acpi_driver_data(device);
1251
Luming Yu45bea152005-07-23 04:08:00 -04001252 status = acpi_remove_address_space_handler(ec->common.handle,
Len Brown50526df2005-08-11 17:32:05 -04001253 ACPI_ADR_SPACE_EC,
1254 &acpi_ec_space_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 if (ACPI_FAILURE(status))
1256 return_VALUE(-ENODEV);
1257
Len Brown50526df2005-08-11 17:32:05 -04001258 status =
1259 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1260 &acpi_ec_gpe_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 if (ACPI_FAILURE(status))
1262 return_VALUE(-ENODEV);
1263
1264 return_VALUE(0);
1265}
1266
1267static acpi_status __init
Len Brown50526df2005-08-11 17:32:05 -04001268acpi_fake_ecdt_callback(acpi_handle handle,
1269 u32 Level, void *context, void **retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270{
Luming Yu45bea152005-07-23 04:08:00 -04001271
Len Brown02b28a32005-12-05 16:33:04 -05001272 if (acpi_ec_poll_mode)
1273 return acpi_fake_ecdt_poll_callback(handle,
Len Brown50526df2005-08-11 17:32:05 -04001274 Level, context, retval);
Luming Yu45bea152005-07-23 04:08:00 -04001275 else
Len Brown02b28a32005-12-05 16:33:04 -05001276 return acpi_fake_ecdt_intr_callback(handle,
Len Brown50526df2005-08-11 17:32:05 -04001277 Level, context, retval);
Luming Yu45bea152005-07-23 04:08:00 -04001278}
1279
1280static acpi_status __init
Len Brown02b28a32005-12-05 16:33:04 -05001281acpi_fake_ecdt_poll_callback(acpi_handle handle,
Len Brown50526df2005-08-11 17:32:05 -04001282 u32 Level, void *context, void **retval)
Luming Yu45bea152005-07-23 04:08:00 -04001283{
Len Brown50526df2005-08-11 17:32:05 -04001284 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
1286 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
Len Brown50526df2005-08-11 17:32:05 -04001287 acpi_ec_io_ports, ec_ecdt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 if (ACPI_FAILURE(status))
1289 return status;
Luming Yu45bea152005-07-23 04:08:00 -04001290 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
Luming Yu45bea152005-07-23 04:08:00 -04001292 ec_ecdt->common.uid = -1;
1293 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294
Len Brown50526df2005-08-11 17:32:05 -04001295 status =
1296 acpi_evaluate_integer(handle, "_GPE", NULL,
1297 &ec_ecdt->common.gpe_bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 if (ACPI_FAILURE(status))
1299 return status;
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -05001300 init_MUTEX(&ec_ecdt->poll.sem);
Luming Yu45bea152005-07-23 04:08:00 -04001301 ec_ecdt->common.global_lock = TRUE;
1302 ec_ecdt->common.handle = handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
Len Brown50526df2005-08-11 17:32:05 -04001304 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1305 (u32) ec_ecdt->common.gpe_bit,
1306 (u32) ec_ecdt->common.command_addr.address,
1307 (u32) ec_ecdt->common.data_addr.address);
Luming Yu45bea152005-07-23 04:08:00 -04001308
1309 return AE_CTRL_TERMINATE;
1310}
1311
1312static acpi_status __init
Len Brown02b28a32005-12-05 16:33:04 -05001313acpi_fake_ecdt_intr_callback(acpi_handle handle,
Len Brown50526df2005-08-11 17:32:05 -04001314 u32 Level, void *context, void **retval)
Luming Yu45bea152005-07-23 04:08:00 -04001315{
Len Brown50526df2005-08-11 17:32:05 -04001316 acpi_status status;
Luming Yu45bea152005-07-23 04:08:00 -04001317
Len Brown02b28a32005-12-05 16:33:04 -05001318 init_MUTEX(&ec_ecdt->intr.sem);
1319 init_waitqueue_head(&ec_ecdt->intr.wait);
Luming Yu45bea152005-07-23 04:08:00 -04001320 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
Len Brown50526df2005-08-11 17:32:05 -04001321 acpi_ec_io_ports, ec_ecdt);
Luming Yu45bea152005-07-23 04:08:00 -04001322 if (ACPI_FAILURE(status))
1323 return status;
1324 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1325
1326 ec_ecdt->common.uid = -1;
1327 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1328
Len Brown50526df2005-08-11 17:32:05 -04001329 status =
1330 acpi_evaluate_integer(handle, "_GPE", NULL,
1331 &ec_ecdt->common.gpe_bit);
Luming Yu45bea152005-07-23 04:08:00 -04001332 if (ACPI_FAILURE(status))
1333 return status;
1334 ec_ecdt->common.global_lock = TRUE;
1335 ec_ecdt->common.handle = handle;
1336
Len Brown50526df2005-08-11 17:32:05 -04001337 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1338 (u32) ec_ecdt->common.gpe_bit,
1339 (u32) ec_ecdt->common.command_addr.address,
1340 (u32) ec_ecdt->common.data_addr.address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342 return AE_CTRL_TERMINATE;
1343}
1344
1345/*
1346 * Some BIOS (such as some from Gateway laptops) access EC region very early
1347 * such as in BAT0._INI or EC._INI before an EC device is found and
1348 * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
1349 * required, but if EC regison is accessed early, it is required.
1350 * The routine tries to workaround the BIOS bug by pre-scan EC device
1351 * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
1352 * op region (since _REG isn't invoked yet). The assumption is true for
1353 * all systems found.
1354 */
Len Brown50526df2005-08-11 17:32:05 -04001355static int __init acpi_ec_fake_ecdt(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356{
Len Brown50526df2005-08-11 17:32:05 -04001357 acpi_status status;
1358 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
1360 printk(KERN_INFO PREFIX "Try to make an fake ECDT\n");
1361
Luming Yu45bea152005-07-23 04:08:00 -04001362 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 if (!ec_ecdt) {
1364 ret = -ENOMEM;
1365 goto error;
1366 }
Luming Yu45bea152005-07-23 04:08:00 -04001367 memset(ec_ecdt, 0, sizeof(union acpi_ec));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
Len Brown50526df2005-08-11 17:32:05 -04001369 status = acpi_get_devices(ACPI_EC_HID,
1370 acpi_fake_ecdt_callback, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 if (ACPI_FAILURE(status)) {
1372 kfree(ec_ecdt);
1373 ec_ecdt = NULL;
1374 ret = -ENODEV;
1375 goto error;
1376 }
1377 return 0;
Len Brown50526df2005-08-11 17:32:05 -04001378 error:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 printk(KERN_ERR PREFIX "Can't make an fake ECDT\n");
1380 return ret;
1381}
1382
Len Brown50526df2005-08-11 17:32:05 -04001383static int __init acpi_ec_get_real_ecdt(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384{
Len Brown02b28a32005-12-05 16:33:04 -05001385 if (acpi_ec_poll_mode)
1386 return acpi_ec_poll_get_real_ecdt();
Luming Yu45bea152005-07-23 04:08:00 -04001387 else
Len Brown02b28a32005-12-05 16:33:04 -05001388 return acpi_ec_intr_get_real_ecdt();
Luming Yu45bea152005-07-23 04:08:00 -04001389}
1390
Len Brown02b28a32005-12-05 16:33:04 -05001391static int __init acpi_ec_poll_get_real_ecdt(void)
Luming Yu45bea152005-07-23 04:08:00 -04001392{
Len Brown50526df2005-08-11 17:32:05 -04001393 acpi_status status;
1394 struct acpi_table_ecdt *ecdt_ptr;
Luming Yu45bea152005-07-23 04:08:00 -04001395
Len Brown50526df2005-08-11 17:32:05 -04001396 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1397 (struct acpi_table_header **)
1398 &ecdt_ptr);
Luming Yu45bea152005-07-23 04:08:00 -04001399 if (ACPI_FAILURE(status))
1400 return -ENODEV;
1401
1402 printk(KERN_INFO PREFIX "Found ECDT\n");
1403
1404 /*
1405 * Generate a temporary ec context to use until the namespace is scanned
1406 */
1407 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1408 if (!ec_ecdt)
1409 return -ENOMEM;
1410 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1411
1412 ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1413 ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1414 ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1415 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
Rich Townsendf9a6ee1a2005-12-19 23:07:00 -05001416 init_MUTEX(&ec_ecdt->poll.sem);
Luming Yu45bea152005-07-23 04:08:00 -04001417 /* use the GL just to be safe */
1418 ec_ecdt->common.global_lock = TRUE;
1419 ec_ecdt->common.uid = ecdt_ptr->uid;
1420
Len Brown50526df2005-08-11 17:32:05 -04001421 status =
1422 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
Luming Yu45bea152005-07-23 04:08:00 -04001423 if (ACPI_FAILURE(status)) {
1424 goto error;
1425 }
1426
1427 return 0;
Len Brown50526df2005-08-11 17:32:05 -04001428 error:
Luming Yu45bea152005-07-23 04:08:00 -04001429 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1430 kfree(ec_ecdt);
1431 ec_ecdt = NULL;
1432
1433 return -ENODEV;
1434}
1435
Len Brown02b28a32005-12-05 16:33:04 -05001436static int __init acpi_ec_intr_get_real_ecdt(void)
Luming Yu45bea152005-07-23 04:08:00 -04001437{
Len Brown50526df2005-08-11 17:32:05 -04001438 acpi_status status;
1439 struct acpi_table_ecdt *ecdt_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
Dmitry Torokhov451566f2005-03-19 01:10:05 -05001441 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
Len Brown50526df2005-08-11 17:32:05 -04001442 (struct acpi_table_header **)
1443 &ecdt_ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 if (ACPI_FAILURE(status))
1445 return -ENODEV;
1446
1447 printk(KERN_INFO PREFIX "Found ECDT\n");
1448
1449 /*
1450 * Generate a temporary ec context to use until the namespace is scanned
1451 */
Luming Yu45bea152005-07-23 04:08:00 -04001452 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 if (!ec_ecdt)
1454 return -ENOMEM;
Luming Yu45bea152005-07-23 04:08:00 -04001455 memset(ec_ecdt, 0, sizeof(union acpi_ec));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
Len Brown02b28a32005-12-05 16:33:04 -05001457 init_MUTEX(&ec_ecdt->intr.sem);
1458 init_waitqueue_head(&ec_ecdt->intr.wait);
Luming Yu45bea152005-07-23 04:08:00 -04001459 ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1460 ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1461 ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1462 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 /* use the GL just to be safe */
Luming Yu45bea152005-07-23 04:08:00 -04001464 ec_ecdt->common.global_lock = TRUE;
1465 ec_ecdt->common.uid = ecdt_ptr->uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466
Len Brown50526df2005-08-11 17:32:05 -04001467 status =
1468 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 if (ACPI_FAILURE(status)) {
1470 goto error;
1471 }
1472
1473 return 0;
Len Brown50526df2005-08-11 17:32:05 -04001474 error:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1476 kfree(ec_ecdt);
1477 ec_ecdt = NULL;
1478
1479 return -ENODEV;
1480}
1481
1482static int __initdata acpi_fake_ecdt_enabled;
Len Brown50526df2005-08-11 17:32:05 -04001483int __init acpi_ec_ecdt_probe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484{
Len Brown50526df2005-08-11 17:32:05 -04001485 acpi_status status;
1486 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
1488 ret = acpi_ec_get_real_ecdt();
1489 /* Try to make a fake ECDT */
1490 if (ret && acpi_fake_ecdt_enabled) {
1491 ret = acpi_ec_fake_ecdt();
1492 }
1493
1494 if (ret)
1495 return 0;
1496
1497 /*
1498 * Install GPE handler
1499 */
Luming Yu45bea152005-07-23 04:08:00 -04001500 status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
Len Brown50526df2005-08-11 17:32:05 -04001501 ACPI_GPE_EDGE_TRIGGERED,
1502 &acpi_ec_gpe_handler, ec_ecdt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 if (ACPI_FAILURE(status)) {
1504 goto error;
1505 }
Len Brown50526df2005-08-11 17:32:05 -04001506 acpi_set_gpe_type(NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1507 acpi_enable_gpe(NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508
Len Brown50526df2005-08-11 17:32:05 -04001509 status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
1510 ACPI_ADR_SPACE_EC,
1511 &acpi_ec_space_handler,
1512 &acpi_ec_space_setup,
1513 ec_ecdt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 if (ACPI_FAILURE(status)) {
Luming Yu45bea152005-07-23 04:08:00 -04001515 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
Len Brown50526df2005-08-11 17:32:05 -04001516 &acpi_ec_gpe_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 goto error;
1518 }
1519
1520 return 0;
1521
Len Brown50526df2005-08-11 17:32:05 -04001522 error:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1524 kfree(ec_ecdt);
1525 ec_ecdt = NULL;
1526
1527 return -ENODEV;
1528}
1529
Len Brown50526df2005-08-11 17:32:05 -04001530static int __init acpi_ec_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531{
Len Brown50526df2005-08-11 17:32:05 -04001532 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
1534 ACPI_FUNCTION_TRACE("acpi_ec_init");
1535
1536 if (acpi_disabled)
1537 return_VALUE(0);
1538
1539 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1540 if (!acpi_ec_dir)
1541 return_VALUE(-ENODEV);
1542
1543 /* Now register the driver for the EC */
1544 result = acpi_bus_register_driver(&acpi_ec_driver);
1545 if (result < 0) {
1546 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1547 return_VALUE(-ENODEV);
1548 }
1549
1550 return_VALUE(result);
1551}
1552
1553subsys_initcall(acpi_ec_init);
1554
1555/* EC driver currently not unloadable */
1556#if 0
Len Brown50526df2005-08-11 17:32:05 -04001557static void __exit acpi_ec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558{
1559 ACPI_FUNCTION_TRACE("acpi_ec_exit");
1560
1561 acpi_bus_unregister_driver(&acpi_ec_driver);
1562
1563 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1564
1565 return_VOID;
1566}
Len Brown50526df2005-08-11 17:32:05 -04001567#endif /* 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
1569static int __init acpi_fake_ecdt_setup(char *str)
1570{
1571 acpi_fake_ecdt_enabled = 1;
OGAWA Hirofumi9b410462006-03-31 02:30:33 -08001572 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573}
Luming Yu7b15f5e2005-08-03 17:38:04 -04001574
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575__setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
Len Brown02b28a32005-12-05 16:33:04 -05001576static int __init acpi_ec_set_intr_mode(char *str)
Luming Yu45bea152005-07-23 04:08:00 -04001577{
Len Brown02b28a32005-12-05 16:33:04 -05001578 int intr;
Luming Yu7b15f5e2005-08-03 17:38:04 -04001579
Len Brown02b28a32005-12-05 16:33:04 -05001580 if (!get_option(&str, &intr))
Luming Yu7b15f5e2005-08-03 17:38:04 -04001581 return 0;
1582
Len Brown02b28a32005-12-05 16:33:04 -05001583 if (intr) {
1584 acpi_ec_poll_mode = EC_INTR;
1585 acpi_ec_driver.ops.add = acpi_ec_intr_add;
Luming Yu7b15f5e2005-08-03 17:38:04 -04001586 } else {
Len Brown02b28a32005-12-05 16:33:04 -05001587 acpi_ec_poll_mode = EC_POLL;
1588 acpi_ec_driver.ops.add = acpi_ec_poll_add;
Luming Yu7b15f5e2005-08-03 17:38:04 -04001589 }
Len Brown02b28a32005-12-05 16:33:04 -05001590 printk(KERN_INFO PREFIX "EC %s mode.\n", intr ? "interrupt" : "polling");
OGAWA Hirofumi9b410462006-03-31 02:30:33 -08001591 return 1;
Luming Yu45bea152005-07-23 04:08:00 -04001592}
Len Brown50526df2005-08-11 17:32:05 -04001593
Len Brown53f11d42005-12-05 16:46:36 -05001594__setup("ec_intr=", acpi_ec_set_intr_mode);