ACPI: EC: wait for last write gpe
[linux-2.6.git] / drivers / acpi / ec.c
1 /*
2  *  ec.c - ACPI Embedded Controller Driver (v2.1)
3  *
4  *  Copyright (C) 2006-2008 Alexey Starikovskiy <astarikovskiy@suse.de>
5  *  Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>
6  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
7  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
8  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
9  *
10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or (at
15  *  your option) any later version.
16  *
17  *  This program is distributed in the hope that it will be useful, but
18  *  WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  *  General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License along
23  *  with this program; if not, write to the Free Software Foundation, Inc.,
24  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25  *
26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27  */
28
29 /* Uncomment next line to get verbose printout */
30 /* #define DEBUG */
31
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/types.h>
36 #include <linux/delay.h>
37 #include <linux/proc_fs.h>
38 #include <linux/seq_file.h>
39 #include <linux/interrupt.h>
40 #include <linux/list.h>
41 #include <linux/spinlock.h>
42 #include <asm/io.h>
43 #include <acpi/acpi_bus.h>
44 #include <acpi/acpi_drivers.h>
45 #include <acpi/actypes.h>
46
47 #define ACPI_EC_CLASS                   "embedded_controller"
48 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
49 #define ACPI_EC_FILE_INFO               "info"
50
51 #undef PREFIX
52 #define PREFIX                          "ACPI: EC: "
53
54 /* EC status register */
55 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
56 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
57 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
58 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
59
60 /* EC commands */
61 enum ec_command {
62         ACPI_EC_COMMAND_READ = 0x80,
63         ACPI_EC_COMMAND_WRITE = 0x81,
64         ACPI_EC_BURST_ENABLE = 0x82,
65         ACPI_EC_BURST_DISABLE = 0x83,
66         ACPI_EC_COMMAND_QUERY = 0x84,
67 };
68
69 #define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
70 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
71 #define ACPI_EC_UDELAY          100     /* Wait 100us before polling EC again */
72
73 #define ACPI_EC_STORM_THRESHOLD 20      /* number of false interrupts
74                                            per one transaction */
75
76 enum {
77         EC_FLAGS_QUERY_PENDING,         /* Query is pending */
78         EC_FLAGS_GPE_MODE,              /* Expect GPE to be sent
79                                          * for status change */
80         EC_FLAGS_NO_GPE,                /* Don't use GPE mode */
81         EC_FLAGS_GPE_STORM,             /* GPE storm detected */
82         EC_FLAGS_HANDLERS_INSTALLED     /* Handlers for GPE and
83                                          * OpReg are installed */
84 };
85
86 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
87 /* External interfaces use first EC only, so remember */
88 typedef int (*acpi_ec_query_func) (void *data);
89
90 struct acpi_ec_query_handler {
91         struct list_head node;
92         acpi_ec_query_func func;
93         acpi_handle handle;
94         void *data;
95         u8 query_bit;
96 };
97
98 struct transaction {
99         const u8 *wdata;
100         u8 *rdata;
101         unsigned short irq_count;
102         u8 command;
103         u8 wlen;
104         u8 rlen;
105         bool done;
106 };
107
108 static struct acpi_ec {
109         acpi_handle handle;
110         unsigned long gpe;
111         unsigned long command_addr;
112         unsigned long data_addr;
113         unsigned long global_lock;
114         unsigned long flags;
115         struct mutex lock;
116         wait_queue_head_t wait;
117         struct list_head list;
118         struct transaction *curr;
119         spinlock_t curr_lock;
120 } *boot_ec, *first_ec;
121
122 /* 
123  * Some Asus system have exchanged ECDT data/command IO addresses.
124  */
125 static int print_ecdt_error(const struct dmi_system_id *id)
126 {
127         printk(KERN_NOTICE PREFIX "%s detected - "
128                 "ECDT has exchanged control/data I/O address\n",
129                 id->ident);
130         return 0;
131 }
132
133 static struct dmi_system_id __cpuinitdata ec_dmi_table[] = {
134         {
135         print_ecdt_error, "Asus L4R", {
136         DMI_MATCH(DMI_BIOS_VERSION, "1008.006"),
137         DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),
138         DMI_MATCH(DMI_BOARD_NAME, "L4R") }, NULL},
139         {
140         print_ecdt_error, "Asus M6R", {
141         DMI_MATCH(DMI_BIOS_VERSION, "0207"),
142         DMI_MATCH(DMI_PRODUCT_NAME, "M6R"),
143         DMI_MATCH(DMI_BOARD_NAME, "M6R") }, NULL},
144         {},
145 };
146
147 /* --------------------------------------------------------------------------
148                              Transaction Management
149    -------------------------------------------------------------------------- */
150
151 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
152 {
153         u8 x = inb(ec->command_addr);
154         pr_debug(PREFIX "---> status = 0x%2.2x\n", x);
155         return x;
156 }
157
158 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
159 {
160         u8 x = inb(ec->data_addr);
161         pr_debug(PREFIX "---> data = 0x%2.2x\n", x);
162         return x;
163 }
164
165 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
166 {
167         pr_debug(PREFIX "<--- command = 0x%2.2x\n", command);
168         outb(command, ec->command_addr);
169 }
170
171 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
172 {
173         pr_debug(PREFIX "<--- data = 0x%2.2x\n", data);
174         outb(data, ec->data_addr);
175 }
176
177 static int ec_transaction_done(struct acpi_ec *ec)
178 {
179         unsigned long flags;
180         int ret = 0;
181         spin_lock_irqsave(&ec->curr_lock, flags);
182         if (!ec->curr || ec->curr->done)
183                 ret = 1;
184         spin_unlock_irqrestore(&ec->curr_lock, flags);
185         return ret;
186 }
187
188 static void gpe_transaction(struct acpi_ec *ec, u8 status)
189 {
190         unsigned long flags;
191         spin_lock_irqsave(&ec->curr_lock, flags);
192         if (!ec->curr)
193                 goto unlock;
194         if (ec->curr->wlen > 0) {
195                 if ((status & ACPI_EC_FLAG_IBF) == 0) {
196                         acpi_ec_write_data(ec, *(ec->curr->wdata++));
197                         --ec->curr->wlen;
198                 } else
199                         goto err;
200         } else if (ec->curr->rlen > 0) {
201                 if ((status & ACPI_EC_FLAG_OBF) == 1) {
202                         *(ec->curr->rdata++) = acpi_ec_read_data(ec);
203                         if (--ec->curr->rlen == 0)
204                                 ec->curr->done = true;
205                 } else
206                         goto err;
207         } else if (ec->curr->wlen == 0 && (status & ACPI_EC_FLAG_IBF) == 0)
208                 ec->curr->done = true;
209         goto unlock;
210 err:
211         /* false interrupt, state didn't change */
212         ++ec->curr->irq_count;
213 unlock:
214         spin_unlock_irqrestore(&ec->curr_lock, flags);
215 }
216
217 static int acpi_ec_wait(struct acpi_ec *ec)
218 {
219         if (wait_event_timeout(ec->wait, ec_transaction_done(ec),
220                                msecs_to_jiffies(ACPI_EC_DELAY)))
221                 return 0;
222         /* missing GPEs, switch back to poll mode */
223         if (printk_ratelimit())
224                 pr_info(PREFIX "missing confirmations, "
225                                 "switch off interrupt mode.\n");
226         set_bit(EC_FLAGS_NO_GPE, &ec->flags);
227         clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
228         return 1;
229 }
230
231 static void acpi_ec_gpe_query(void *ec_cxt);
232
233 static int ec_check_sci(struct acpi_ec *ec, u8 state)
234 {
235         if (state & ACPI_EC_FLAG_SCI) {
236                 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
237                         return acpi_os_execute(OSL_EC_BURST_HANDLER,
238                                 acpi_ec_gpe_query, ec);
239         }
240         return 0;
241 }
242
243 static int ec_poll(struct acpi_ec *ec)
244 {
245         unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
246         udelay(ACPI_EC_UDELAY);
247         while (time_before(jiffies, delay)) {
248                 gpe_transaction(ec, acpi_ec_read_status(ec));
249                 udelay(ACPI_EC_UDELAY);
250                 if (ec_transaction_done(ec))
251                         return 0;
252         }
253         return -ETIME;
254 }
255
256 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
257                                         struct transaction *t,
258                                         int force_poll)
259 {
260         unsigned long tmp;
261         int ret = 0;
262         pr_debug(PREFIX "transaction start\n");
263         /* disable GPE during transaction if storm is detected */
264         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
265                 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
266                 acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
267         }
268         /* start transaction */
269         spin_lock_irqsave(&ec->curr_lock, tmp);
270         /* following two actions should be kept atomic */
271         t->irq_count = 0;
272         t->done = false;
273         ec->curr = t;
274         acpi_ec_write_cmd(ec, ec->curr->command);
275         if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
276                 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
277         spin_unlock_irqrestore(&ec->curr_lock, tmp);
278         /* if we selected poll mode or failed in GPE-mode do a poll loop */
279         if (force_poll ||
280             !test_bit(EC_FLAGS_GPE_MODE, &ec->flags) ||
281             acpi_ec_wait(ec))
282                 ret = ec_poll(ec);
283         pr_debug(PREFIX "transaction end\n");
284         spin_lock_irqsave(&ec->curr_lock, tmp);
285         ec->curr = NULL;
286         spin_unlock_irqrestore(&ec->curr_lock, tmp);
287         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
288                 /* check if we received SCI during transaction */
289                 ec_check_sci(ec, acpi_ec_read_status(ec));
290                 /* it is safe to enable GPE outside of transaction */
291                 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
292         } else if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
293                    t->irq_count > ACPI_EC_STORM_THRESHOLD) {
294                 pr_info(PREFIX "GPE storm detected, "
295                         "transactions will use polling mode\n");
296                 set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
297         }
298         return ret;
299 }
300
301 static int ec_check_ibf0(struct acpi_ec *ec)
302 {
303         u8 status = acpi_ec_read_status(ec);
304         return (status & ACPI_EC_FLAG_IBF) == 0;
305 }
306
307 static int ec_wait_ibf0(struct acpi_ec *ec)
308 {
309         unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
310         /* interrupt wait manually if GPE mode is not active */
311         unsigned long timeout = test_bit(EC_FLAGS_GPE_MODE, &ec->flags) ?
312                 msecs_to_jiffies(ACPI_EC_DELAY) : msecs_to_jiffies(1);
313         while (time_before(jiffies, delay))
314                 if (wait_event_timeout(ec->wait, ec_check_ibf0(ec), timeout))
315                         return 0;
316         return -ETIME;
317 }
318
319 static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t,
320                                int force_poll)
321 {
322         int status;
323         u32 glk;
324         if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
325                 return -EINVAL;
326         if (t->rdata)
327                 memset(t->rdata, 0, t->rlen);
328         mutex_lock(&ec->lock);
329         if (ec->global_lock) {
330                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
331                 if (ACPI_FAILURE(status)) {
332                         status = -ENODEV;
333                         goto unlock;
334                 }
335         }
336         if (ec_wait_ibf0(ec)) {
337                 pr_err(PREFIX "input buffer is not empty, "
338                                 "aborting transaction\n");
339                 status = -ETIME;
340                 goto end;
341         }
342         status = acpi_ec_transaction_unlocked(ec, t, force_poll);
343 end:
344         if (ec->global_lock)
345                 acpi_release_global_lock(glk);
346 unlock:
347         mutex_unlock(&ec->lock);
348         return status;
349 }
350
351 /*
352  * Note: samsung nv5000 doesn't work with ec burst mode.
353  * http://bugzilla.kernel.org/show_bug.cgi?id=4980
354  */
355 int acpi_ec_burst_enable(struct acpi_ec *ec)
356 {
357         u8 d;
358         struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
359                                 .wdata = NULL, .rdata = &d,
360                                 .wlen = 0, .rlen = 1};
361
362         return acpi_ec_transaction(ec, &t, 0);
363 }
364
365 int acpi_ec_burst_disable(struct acpi_ec *ec)
366 {
367         struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
368                                 .wdata = NULL, .rdata = NULL,
369                                 .wlen = 0, .rlen = 0};
370
371         return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
372                                 acpi_ec_transaction(ec, &t, 0) : 0;
373 }
374
375 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
376 {
377         int result;
378         u8 d;
379         struct transaction t = {.command = ACPI_EC_COMMAND_READ,
380                                 .wdata = &address, .rdata = &d,
381                                 .wlen = 1, .rlen = 1};
382
383         result = acpi_ec_transaction(ec, &t, 0);
384         *data = d;
385         return result;
386 }
387
388 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
389 {
390         u8 wdata[2] = { address, data };
391         struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
392                                 .wdata = wdata, .rdata = NULL,
393                                 .wlen = 2, .rlen = 0};
394
395         return acpi_ec_transaction(ec, &t, 0);
396 }
397
398 /*
399  * Externally callable EC access functions. For now, assume 1 EC only
400  */
401 int ec_burst_enable(void)
402 {
403         if (!first_ec)
404                 return -ENODEV;
405         return acpi_ec_burst_enable(first_ec);
406 }
407
408 EXPORT_SYMBOL(ec_burst_enable);
409
410 int ec_burst_disable(void)
411 {
412         if (!first_ec)
413                 return -ENODEV;
414         return acpi_ec_burst_disable(first_ec);
415 }
416
417 EXPORT_SYMBOL(ec_burst_disable);
418
419 int ec_read(u8 addr, u8 * val)
420 {
421         int err;
422         u8 temp_data;
423
424         if (!first_ec)
425                 return -ENODEV;
426
427         err = acpi_ec_read(first_ec, addr, &temp_data);
428
429         if (!err) {
430                 *val = temp_data;
431                 return 0;
432         } else
433                 return err;
434 }
435
436 EXPORT_SYMBOL(ec_read);
437
438 int ec_write(u8 addr, u8 val)
439 {
440         int err;
441
442         if (!first_ec)
443                 return -ENODEV;
444
445         err = acpi_ec_write(first_ec, addr, val);
446
447         return err;
448 }
449
450 EXPORT_SYMBOL(ec_write);
451
452 int ec_transaction(u8 command,
453                    const u8 * wdata, unsigned wdata_len,
454                    u8 * rdata, unsigned rdata_len,
455                    int force_poll)
456 {
457         struct transaction t = {.command = command,
458                                 .wdata = wdata, .rdata = rdata,
459                                 .wlen = wdata_len, .rlen = rdata_len};
460         if (!first_ec)
461                 return -ENODEV;
462
463         return acpi_ec_transaction(first_ec, &t, force_poll);
464 }
465
466 EXPORT_SYMBOL(ec_transaction);
467
468 static int acpi_ec_query(struct acpi_ec *ec, u8 * data)
469 {
470         int result;
471         u8 d;
472         struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
473                                 .wdata = NULL, .rdata = &d,
474                                 .wlen = 0, .rlen = 1};
475         if (!ec || !data)
476                 return -EINVAL;
477
478         /*
479          * Query the EC to find out which _Qxx method we need to evaluate.
480          * Note that successful completion of the query causes the ACPI_EC_SCI
481          * bit to be cleared (and thus clearing the interrupt source).
482          */
483
484         result = acpi_ec_transaction(ec, &t, 0);
485         if (result)
486                 return result;
487
488         if (!d)
489                 return -ENODATA;
490
491         *data = d;
492         return 0;
493 }
494
495 /* --------------------------------------------------------------------------
496                                 Event Management
497    -------------------------------------------------------------------------- */
498 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
499                               acpi_handle handle, acpi_ec_query_func func,
500                               void *data)
501 {
502         struct acpi_ec_query_handler *handler =
503             kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
504         if (!handler)
505                 return -ENOMEM;
506
507         handler->query_bit = query_bit;
508         handler->handle = handle;
509         handler->func = func;
510         handler->data = data;
511         mutex_lock(&ec->lock);
512         list_add(&handler->node, &ec->list);
513         mutex_unlock(&ec->lock);
514         return 0;
515 }
516
517 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
518
519 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
520 {
521         struct acpi_ec_query_handler *handler, *tmp;
522         mutex_lock(&ec->lock);
523         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
524                 if (query_bit == handler->query_bit) {
525                         list_del(&handler->node);
526                         kfree(handler);
527                 }
528         }
529         mutex_unlock(&ec->lock);
530 }
531
532 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
533
534 static void acpi_ec_gpe_query(void *ec_cxt)
535 {
536         struct acpi_ec *ec = ec_cxt;
537         u8 value = 0;
538         struct acpi_ec_query_handler *handler, copy;
539
540         if (!ec || acpi_ec_query(ec, &value))
541                 return;
542         mutex_lock(&ec->lock);
543         list_for_each_entry(handler, &ec->list, node) {
544                 if (value == handler->query_bit) {
545                         /* have custom handler for this bit */
546                         memcpy(&copy, handler, sizeof(copy));
547                         mutex_unlock(&ec->lock);
548                         if (copy.func) {
549                                 copy.func(copy.data);
550                         } else if (copy.handle) {
551                                 acpi_evaluate_object(copy.handle, NULL, NULL, NULL);
552                         }
553                         return;
554                 }
555         }
556         mutex_unlock(&ec->lock);
557 }
558
559 static u32 acpi_ec_gpe_handler(void *data)
560 {
561         struct acpi_ec *ec = data;
562         u8 status;
563
564         pr_debug(PREFIX "~~~> interrupt\n");
565         status = acpi_ec_read_status(ec);
566
567         gpe_transaction(ec, status);
568         if (ec_transaction_done(ec) && (status & ACPI_EC_FLAG_IBF) == 0)
569                 wake_up(&ec->wait);
570
571         ec_check_sci(ec, status);
572         if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
573             !test_bit(EC_FLAGS_NO_GPE, &ec->flags)) {
574                 /* this is non-query, must be confirmation */
575                 if (!test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
576                         if (printk_ratelimit())
577                                 pr_info(PREFIX "non-query interrupt received,"
578                                         " switching to interrupt mode\n");
579                 } else {
580                         /* hush, STORM switches the mode every transaction */
581                         pr_debug(PREFIX "non-query interrupt received,"
582                                 " switching to interrupt mode\n");
583                 }
584                 set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
585         }
586         return ACPI_INTERRUPT_HANDLED;
587 }
588
589 /* --------------------------------------------------------------------------
590                              Address Space Management
591    -------------------------------------------------------------------------- */
592
593 static acpi_status
594 acpi_ec_space_handler(u32 function, acpi_physical_address address,
595                       u32 bits, acpi_integer *value,
596                       void *handler_context, void *region_context)
597 {
598         struct acpi_ec *ec = handler_context;
599         int result = 0, i;
600         u8 temp = 0;
601
602         if ((address > 0xFF) || !value || !handler_context)
603                 return AE_BAD_PARAMETER;
604
605         if (function != ACPI_READ && function != ACPI_WRITE)
606                 return AE_BAD_PARAMETER;
607
608         if (bits != 8 && acpi_strict)
609                 return AE_BAD_PARAMETER;
610
611         acpi_ec_burst_enable(ec);
612
613         if (function == ACPI_READ) {
614                 result = acpi_ec_read(ec, address, &temp);
615                 *value = temp;
616         } else {
617                 temp = 0xff & (*value);
618                 result = acpi_ec_write(ec, address, temp);
619         }
620
621         for (i = 8; unlikely(bits - i > 0); i += 8) {
622                 ++address;
623                 if (function == ACPI_READ) {
624                         result = acpi_ec_read(ec, address, &temp);
625                         (*value) |= ((acpi_integer)temp) << i;
626                 } else {
627                         temp = 0xff & ((*value) >> i);
628                         result = acpi_ec_write(ec, address, temp);
629                 }
630         }
631
632         acpi_ec_burst_disable(ec);
633
634         switch (result) {
635         case -EINVAL:
636                 return AE_BAD_PARAMETER;
637                 break;
638         case -ENODEV:
639                 return AE_NOT_FOUND;
640                 break;
641         case -ETIME:
642                 return AE_TIME;
643                 break;
644         default:
645                 return AE_OK;
646         }
647 }
648
649 /* --------------------------------------------------------------------------
650                               FS Interface (/proc)
651    -------------------------------------------------------------------------- */
652
653 static struct proc_dir_entry *acpi_ec_dir;
654
655 static int acpi_ec_read_info(struct seq_file *seq, void *offset)
656 {
657         struct acpi_ec *ec = seq->private;
658
659         if (!ec)
660                 goto end;
661
662         seq_printf(seq, "gpe:\t\t\t0x%02x\n", (u32) ec->gpe);
663         seq_printf(seq, "ports:\t\t\t0x%02x, 0x%02x\n",
664                    (unsigned)ec->command_addr, (unsigned)ec->data_addr);
665         seq_printf(seq, "use global lock:\t%s\n",
666                    ec->global_lock ? "yes" : "no");
667       end:
668         return 0;
669 }
670
671 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
672 {
673         return single_open(file, acpi_ec_read_info, PDE(inode)->data);
674 }
675
676 static struct file_operations acpi_ec_info_ops = {
677         .open = acpi_ec_info_open_fs,
678         .read = seq_read,
679         .llseek = seq_lseek,
680         .release = single_release,
681         .owner = THIS_MODULE,
682 };
683
684 static int acpi_ec_add_fs(struct acpi_device *device)
685 {
686         struct proc_dir_entry *entry = NULL;
687
688         if (!acpi_device_dir(device)) {
689                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
690                                                      acpi_ec_dir);
691                 if (!acpi_device_dir(device))
692                         return -ENODEV;
693         }
694
695         entry = proc_create_data(ACPI_EC_FILE_INFO, S_IRUGO,
696                                  acpi_device_dir(device),
697                                  &acpi_ec_info_ops, acpi_driver_data(device));
698         if (!entry)
699                 return -ENODEV;
700         return 0;
701 }
702
703 static int acpi_ec_remove_fs(struct acpi_device *device)
704 {
705
706         if (acpi_device_dir(device)) {
707                 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
708                 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
709                 acpi_device_dir(device) = NULL;
710         }
711
712         return 0;
713 }
714
715 /* --------------------------------------------------------------------------
716                                Driver Interface
717    -------------------------------------------------------------------------- */
718 static acpi_status
719 ec_parse_io_ports(struct acpi_resource *resource, void *context);
720
721 static struct acpi_ec *make_acpi_ec(void)
722 {
723         struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
724         if (!ec)
725                 return NULL;
726         ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
727         mutex_init(&ec->lock);
728         init_waitqueue_head(&ec->wait);
729         INIT_LIST_HEAD(&ec->list);
730         spin_lock_init(&ec->curr_lock);
731         return ec;
732 }
733
734 static acpi_status
735 acpi_ec_register_query_methods(acpi_handle handle, u32 level,
736                                void *context, void **return_value)
737 {
738         struct acpi_namespace_node *node = handle;
739         struct acpi_ec *ec = context;
740         int value = 0;
741         if (sscanf(node->name.ascii, "_Q%x", &value) == 1) {
742                 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
743         }
744         return AE_OK;
745 }
746
747 static acpi_status
748 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
749 {
750         acpi_status status;
751         unsigned long long tmp;
752
753         struct acpi_ec *ec = context;
754         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
755                                      ec_parse_io_ports, ec);
756         if (ACPI_FAILURE(status))
757                 return status;
758
759         /* Get GPE bit assignment (EC events). */
760         /* TODO: Add support for _GPE returning a package */
761         status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
762         if (ACPI_FAILURE(status))
763                 return status;
764         ec->gpe = tmp;
765         /* Use the global lock for all EC transactions? */
766         acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
767         ec->global_lock = tmp;
768         ec->handle = handle;
769         return AE_CTRL_TERMINATE;
770 }
771
772 static void ec_remove_handlers(struct acpi_ec *ec)
773 {
774         if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
775                                 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
776                 pr_err(PREFIX "failed to remove space handler\n");
777         if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
778                                 &acpi_ec_gpe_handler)))
779                 pr_err(PREFIX "failed to remove gpe handler\n");
780         clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
781 }
782
783 static int acpi_ec_add(struct acpi_device *device)
784 {
785         struct acpi_ec *ec = NULL;
786
787         if (!device)
788                 return -EINVAL;
789         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
790         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
791
792         /* Check for boot EC */
793         if (boot_ec &&
794             (boot_ec->handle == device->handle ||
795              boot_ec->handle == ACPI_ROOT_OBJECT)) {
796                 ec = boot_ec;
797                 boot_ec = NULL;
798         } else {
799                 ec = make_acpi_ec();
800                 if (!ec)
801                         return -ENOMEM;
802                 if (ec_parse_device(device->handle, 0, ec, NULL) !=
803                     AE_CTRL_TERMINATE) {
804                         kfree(ec);
805                         return -EINVAL;
806                 }
807         }
808
809         ec->handle = device->handle;
810
811         /* Find and register all query methods */
812         acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
813                             acpi_ec_register_query_methods, ec, NULL);
814
815         if (!first_ec)
816                 first_ec = ec;
817         device->driver_data = ec;
818         acpi_ec_add_fs(device);
819         pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
820                           ec->gpe, ec->command_addr, ec->data_addr);
821         pr_info(PREFIX "driver started in %s mode\n",
822                 (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))?"interrupt":"poll");
823         return 0;
824 }
825
826 static int acpi_ec_remove(struct acpi_device *device, int type)
827 {
828         struct acpi_ec *ec;
829         struct acpi_ec_query_handler *handler, *tmp;
830
831         if (!device)
832                 return -EINVAL;
833
834         ec = acpi_driver_data(device);
835         mutex_lock(&ec->lock);
836         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
837                 list_del(&handler->node);
838                 kfree(handler);
839         }
840         mutex_unlock(&ec->lock);
841         acpi_ec_remove_fs(device);
842         device->driver_data = NULL;
843         if (ec == first_ec)
844                 first_ec = NULL;
845         kfree(ec);
846         return 0;
847 }
848
849 static acpi_status
850 ec_parse_io_ports(struct acpi_resource *resource, void *context)
851 {
852         struct acpi_ec *ec = context;
853
854         if (resource->type != ACPI_RESOURCE_TYPE_IO)
855                 return AE_OK;
856
857         /*
858          * The first address region returned is the data port, and
859          * the second address region returned is the status/command
860          * port.
861          */
862         if (ec->data_addr == 0)
863                 ec->data_addr = resource->data.io.minimum;
864         else if (ec->command_addr == 0)
865                 ec->command_addr = resource->data.io.minimum;
866         else
867                 return AE_CTRL_TERMINATE;
868
869         return AE_OK;
870 }
871
872 static int ec_install_handlers(struct acpi_ec *ec)
873 {
874         acpi_status status;
875         if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
876                 return 0;
877         status = acpi_install_gpe_handler(NULL, ec->gpe,
878                                   ACPI_GPE_EDGE_TRIGGERED,
879                                   &acpi_ec_gpe_handler, ec);
880         if (ACPI_FAILURE(status))
881                 return -ENODEV;
882         acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
883         acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
884         status = acpi_install_address_space_handler(ec->handle,
885                                                     ACPI_ADR_SPACE_EC,
886                                                     &acpi_ec_space_handler,
887                                                     NULL, ec);
888         if (ACPI_FAILURE(status)) {
889                 if (status == AE_NOT_FOUND) {
890                         /*
891                          * Maybe OS fails in evaluating the _REG object.
892                          * The AE_NOT_FOUND error will be ignored and OS
893                          * continue to initialize EC.
894                          */
895                         printk(KERN_ERR "Fail in evaluating the _REG object"
896                                 " of EC device. Broken bios is suspected.\n");
897                 } else {
898                         acpi_remove_gpe_handler(NULL, ec->gpe,
899                                 &acpi_ec_gpe_handler);
900                         return -ENODEV;
901                 }
902         }
903
904         set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
905         return 0;
906 }
907
908 static int acpi_ec_start(struct acpi_device *device)
909 {
910         struct acpi_ec *ec;
911         int ret = 0;
912
913         if (!device)
914                 return -EINVAL;
915
916         ec = acpi_driver_data(device);
917
918         if (!ec)
919                 return -EINVAL;
920
921         ret = ec_install_handlers(ec);
922
923         /* EC is fully operational, allow queries */
924         clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
925         return ret;
926 }
927
928 static int acpi_ec_stop(struct acpi_device *device, int type)
929 {
930         struct acpi_ec *ec;
931         if (!device)
932                 return -EINVAL;
933         ec = acpi_driver_data(device);
934         if (!ec)
935                 return -EINVAL;
936         ec_remove_handlers(ec);
937
938         return 0;
939 }
940
941 int __init acpi_boot_ec_enable(void)
942 {
943         if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
944                 return 0;
945         if (!ec_install_handlers(boot_ec)) {
946                 first_ec = boot_ec;
947                 return 0;
948         }
949         return -EFAULT;
950 }
951
952 static const struct acpi_device_id ec_device_ids[] = {
953         {"PNP0C09", 0},
954         {"", 0},
955 };
956
957 int __init acpi_ec_ecdt_probe(void)
958 {
959         int ret;
960         acpi_status status;
961         struct acpi_table_ecdt *ecdt_ptr;
962
963         boot_ec = make_acpi_ec();
964         if (!boot_ec)
965                 return -ENOMEM;
966         /*
967          * Generate a boot ec context
968          */
969         status = acpi_get_table(ACPI_SIG_ECDT, 1,
970                                 (struct acpi_table_header **)&ecdt_ptr);
971         if (ACPI_SUCCESS(status)) {
972                 pr_info(PREFIX "EC description table is found, configuring boot EC\n");
973                 boot_ec->command_addr = ecdt_ptr->control.address;
974                 boot_ec->data_addr = ecdt_ptr->data.address;
975                 if (dmi_check_system(ec_dmi_table)) {
976                         /*
977                          * If the board falls into ec_dmi_table, it means
978                          * that ECDT table gives the incorrect command/status
979                          * & data I/O address. Just fix it.
980                          */
981                         boot_ec->data_addr = ecdt_ptr->control.address;
982                         boot_ec->command_addr = ecdt_ptr->data.address;
983                 }
984                 boot_ec->gpe = ecdt_ptr->gpe;
985                 boot_ec->handle = ACPI_ROOT_OBJECT;
986                 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle);
987         } else {
988                 /* This workaround is needed only on some broken machines,
989                  * which require early EC, but fail to provide ECDT */
990                 acpi_handle x;
991                 printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n");
992                 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
993                                                 boot_ec, NULL);
994                 /* Check that acpi_get_devices actually find something */
995                 if (ACPI_FAILURE(status) || !boot_ec->handle)
996                         goto error;
997                 /* We really need to limit this workaround, the only ASUS,
998                  * which needs it, has fake EC._INI method, so use it as flag.
999                  * Keep boot_ec struct as it will be needed soon.
1000                  */
1001                 if (ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI", &x)))
1002                         return -ENODEV;
1003         }
1004
1005         ret = ec_install_handlers(boot_ec);
1006         if (!ret) {
1007                 first_ec = boot_ec;
1008                 return 0;
1009         }
1010       error:
1011         kfree(boot_ec);
1012         boot_ec = NULL;
1013         return -ENODEV;
1014 }
1015
1016 static int acpi_ec_suspend(struct acpi_device *device, pm_message_t state)
1017 {
1018         struct acpi_ec *ec = acpi_driver_data(device);
1019         /* Stop using GPE */
1020         set_bit(EC_FLAGS_NO_GPE, &ec->flags);
1021         clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
1022         acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
1023         return 0;
1024 }
1025
1026 static int acpi_ec_resume(struct acpi_device *device)
1027 {
1028         struct acpi_ec *ec = acpi_driver_data(device);
1029         /* Enable use of GPE back */
1030         clear_bit(EC_FLAGS_NO_GPE, &ec->flags);
1031         acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
1032         return 0;
1033 }
1034
1035 static struct acpi_driver acpi_ec_driver = {
1036         .name = "ec",
1037         .class = ACPI_EC_CLASS,
1038         .ids = ec_device_ids,
1039         .ops = {
1040                 .add = acpi_ec_add,
1041                 .remove = acpi_ec_remove,
1042                 .start = acpi_ec_start,
1043                 .stop = acpi_ec_stop,
1044                 .suspend = acpi_ec_suspend,
1045                 .resume = acpi_ec_resume,
1046                 },
1047 };
1048
1049 static int __init acpi_ec_init(void)
1050 {
1051         int result = 0;
1052
1053         if (acpi_disabled)
1054                 return 0;
1055
1056         acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1057         if (!acpi_ec_dir)
1058                 return -ENODEV;
1059
1060         /* Now register the driver for the EC */
1061         result = acpi_bus_register_driver(&acpi_ec_driver);
1062         if (result < 0) {
1063                 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1064                 return -ENODEV;
1065         }
1066
1067         return result;
1068 }
1069
1070 subsys_initcall(acpi_ec_init);
1071
1072 /* EC driver currently not unloadable */
1073 #if 0
1074 static void __exit acpi_ec_exit(void)
1075 {
1076
1077         acpi_bus_unregister_driver(&acpi_ec_driver);
1078
1079         remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1080
1081         return;
1082 }
1083 #endif  /* 0 */