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