Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/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 #define pr_fmt(fmt) "ACPI : EC: " fmt
 32 
 33 #include <linux/kernel.h>
 34 #include <linux/module.h>
 35 #include <linux/init.h>
 36 #include <linux/types.h>
 37 #include <linux/delay.h>
 38 #include <linux/interrupt.h>
 39 #include <linux/list.h>
 40 #include <linux/spinlock.h>
 41 #include <linux/slab.h>
 42 #include <linux/acpi.h>
 43 #include <linux/dmi.h>
 44 #include <asm/io.h>
 45 
 46 #include "internal.h"
 47 
 48 #define ACPI_EC_CLASS                   "embedded_controller"
 49 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
 50 #define ACPI_EC_FILE_INFO               "info"
 51 
 52 /* EC status register */
 53 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
 54 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
 55 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
 56 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
 57 
 58 /* EC commands */
 59 enum ec_command {
 60         ACPI_EC_COMMAND_READ = 0x80,
 61         ACPI_EC_COMMAND_WRITE = 0x81,
 62         ACPI_EC_BURST_ENABLE = 0x82,
 63         ACPI_EC_BURST_DISABLE = 0x83,
 64         ACPI_EC_COMMAND_QUERY = 0x84,
 65 };
 66 
 67 #define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
 68 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
 69 #define ACPI_EC_MSI_UDELAY      550     /* Wait 550us for MSI EC */
 70 #define ACPI_EC_CLEAR_MAX       100     /* Maximum number of events to query
 71                                          * when trying to clear the EC */
 72 
 73 enum {
 74         EC_FLAGS_QUERY_PENDING,         /* Query is pending */
 75         EC_FLAGS_GPE_STORM,             /* GPE storm detected */
 76         EC_FLAGS_HANDLERS_INSTALLED,    /* Handlers for GPE and
 77                                          * OpReg are installed */
 78         EC_FLAGS_BLOCKED,               /* Transactions are blocked */
 79 };
 80 
 81 /* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
 82 static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
 83 module_param(ec_delay, uint, 0644);
 84 MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
 85 
 86 /*
 87  * If the number of false interrupts per one transaction exceeds
 88  * this threshold, will think there is a GPE storm happened and
 89  * will disable the GPE for normal transaction.
 90  */
 91 static unsigned int ec_storm_threshold  __read_mostly = 8;
 92 module_param(ec_storm_threshold, uint, 0644);
 93 MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
 94 
 95 struct acpi_ec_query_handler {
 96         struct list_head node;
 97         acpi_ec_query_func func;
 98         acpi_handle handle;
 99         void *data;
100         u8 query_bit;
101 };
102 
103 struct transaction {
104         const u8 *wdata;
105         u8 *rdata;
106         unsigned short irq_count;
107         u8 command;
108         u8 wi;
109         u8 ri;
110         u8 wlen;
111         u8 rlen;
112         bool done;
113 };
114 
115 struct acpi_ec *boot_ec, *first_ec;
116 EXPORT_SYMBOL(first_ec);
117 
118 static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */
119 static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */
120 static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */
121 static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
122 
123 /* --------------------------------------------------------------------------
124                              Transaction Management
125    -------------------------------------------------------------------------- */
126 
127 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
128 {
129         u8 x = inb(ec->command_addr);
130         pr_debug("---> status = 0x%2.2x\n", x);
131         return x;
132 }
133 
134 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
135 {
136         u8 x = inb(ec->data_addr);
137         pr_debug("---> data = 0x%2.2x\n", x);
138         return x;
139 }
140 
141 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
142 {
143         pr_debug("<--- command = 0x%2.2x\n", command);
144         outb(command, ec->command_addr);
145 }
146 
147 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
148 {
149         pr_debug("<--- data = 0x%2.2x\n", data);
150         outb(data, ec->data_addr);
151 }
152 
153 static int ec_transaction_done(struct acpi_ec *ec)
154 {
155         unsigned long flags;
156         int ret = 0;
157         spin_lock_irqsave(&ec->lock, flags);
158         if (!ec->curr || ec->curr->done)
159                 ret = 1;
160         spin_unlock_irqrestore(&ec->lock, flags);
161         return ret;
162 }
163 
164 static void start_transaction(struct acpi_ec *ec)
165 {
166         ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
167         ec->curr->done = false;
168         acpi_ec_write_cmd(ec, ec->curr->command);
169 }
170 
171 static void advance_transaction(struct acpi_ec *ec, u8 status)
172 {
173         unsigned long flags;
174         struct transaction *t;
175 
176         spin_lock_irqsave(&ec->lock, flags);
177         t = ec->curr;
178         if (!t)
179                 goto unlock;
180         if (t->wlen > t->wi) {
181                 if ((status & ACPI_EC_FLAG_IBF) == 0)
182                         acpi_ec_write_data(ec,
183                                 t->wdata[t->wi++]);
184                 else
185                         goto err;
186         } else if (t->rlen > t->ri) {
187                 if ((status & ACPI_EC_FLAG_OBF) == 1) {
188                         t->rdata[t->ri++] = acpi_ec_read_data(ec);
189                         if (t->rlen == t->ri)
190                                 t->done = true;
191                 } else
192                         goto err;
193         } else if (t->wlen == t->wi &&
194                    (status & ACPI_EC_FLAG_IBF) == 0)
195                 t->done = true;
196         goto unlock;
197 err:
198         /*
199          * If SCI bit is set, then don't think it's a false IRQ
200          * otherwise will take a not handled IRQ as a false one.
201          */
202         if (in_interrupt() && !(status & ACPI_EC_FLAG_SCI))
203                 ++t->irq_count;
204 
205 unlock:
206         spin_unlock_irqrestore(&ec->lock, flags);
207 }
208 
209 static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data);
210 
211 static int ec_check_sci_sync(struct acpi_ec *ec, u8 state)
212 {
213         if (state & ACPI_EC_FLAG_SCI) {
214                 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
215                         return acpi_ec_sync_query(ec, NULL);
216         }
217         return 0;
218 }
219 
220 static int ec_poll(struct acpi_ec *ec)
221 {
222         unsigned long flags;
223         int repeat = 5; /* number of command restarts */
224         while (repeat--) {
225                 unsigned long delay = jiffies +
226                         msecs_to_jiffies(ec_delay);
227                 do {
228                         /* don't sleep with disabled interrupts */
229                         if (EC_FLAGS_MSI || irqs_disabled()) {
230                                 udelay(ACPI_EC_MSI_UDELAY);
231                                 if (ec_transaction_done(ec))
232                                         return 0;
233                         } else {
234                                 if (wait_event_timeout(ec->wait,
235                                                 ec_transaction_done(ec),
236                                                 msecs_to_jiffies(1)))
237                                         return 0;
238                         }
239                         advance_transaction(ec, acpi_ec_read_status(ec));
240                 } while (time_before(jiffies, delay));
241                 pr_debug("controller reset, restart transaction\n");
242                 spin_lock_irqsave(&ec->lock, flags);
243                 start_transaction(ec);
244                 spin_unlock_irqrestore(&ec->lock, flags);
245         }
246         return -ETIME;
247 }
248 
249 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
250                                         struct transaction *t)
251 {
252         unsigned long tmp;
253         int ret = 0;
254         if (EC_FLAGS_MSI)
255                 udelay(ACPI_EC_MSI_UDELAY);
256         /* start transaction */
257         spin_lock_irqsave(&ec->lock, tmp);
258         /* following two actions should be kept atomic */
259         ec->curr = t;
260         start_transaction(ec);
261         if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
262                 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
263         spin_unlock_irqrestore(&ec->lock, tmp);
264         ret = ec_poll(ec);
265         spin_lock_irqsave(&ec->lock, tmp);
266         ec->curr = NULL;
267         spin_unlock_irqrestore(&ec->lock, tmp);
268         return ret;
269 }
270 
271 static int ec_check_ibf0(struct acpi_ec *ec)
272 {
273         u8 status = acpi_ec_read_status(ec);
274         return (status & ACPI_EC_FLAG_IBF) == 0;
275 }
276 
277 static int ec_wait_ibf0(struct acpi_ec *ec)
278 {
279         unsigned long delay = jiffies + msecs_to_jiffies(ec_delay);
280         /* interrupt wait manually if GPE mode is not active */
281         while (time_before(jiffies, delay))
282                 if (wait_event_timeout(ec->wait, ec_check_ibf0(ec),
283                                         msecs_to_jiffies(1)))
284                         return 0;
285         return -ETIME;
286 }
287 
288 static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
289 {
290         int status;
291         u32 glk;
292         if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
293                 return -EINVAL;
294         if (t->rdata)
295                 memset(t->rdata, 0, t->rlen);
296         mutex_lock(&ec->mutex);
297         if (test_bit(EC_FLAGS_BLOCKED, &ec->flags)) {
298                 status = -EINVAL;
299                 goto unlock;
300         }
301         if (ec->global_lock) {
302                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
303                 if (ACPI_FAILURE(status)) {
304                         status = -ENODEV;
305                         goto unlock;
306                 }
307         }
308         if (ec_wait_ibf0(ec)) {
309                 pr_err("input buffer is not empty, "
310                                 "aborting transaction\n");
311                 status = -ETIME;
312                 goto end;
313         }
314         pr_debug("transaction start (cmd=0x%02x, addr=0x%02x)\n",
315                         t->command, t->wdata ? t->wdata[0] : 0);
316         /* disable GPE during transaction if storm is detected */
317         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
318                 /* It has to be disabled, so that it doesn't trigger. */
319                 acpi_disable_gpe(NULL, ec->gpe);
320         }
321 
322         status = acpi_ec_transaction_unlocked(ec, t);
323 
324         /* check if we received SCI during transaction */
325         ec_check_sci_sync(ec, acpi_ec_read_status(ec));
326         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
327                 msleep(1);
328                 /* It is safe to enable the GPE outside of the transaction. */
329                 acpi_enable_gpe(NULL, ec->gpe);
330         } else if (t->irq_count > ec_storm_threshold) {
331                 pr_info("GPE storm detected(%d GPEs), "
332                         "transactions will use polling mode\n",
333                         t->irq_count);
334                 set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
335         }
336         pr_debug("transaction end\n");
337 end:
338         if (ec->global_lock)
339                 acpi_release_global_lock(glk);
340 unlock:
341         mutex_unlock(&ec->mutex);
342         return status;
343 }
344 
345 static int acpi_ec_burst_enable(struct acpi_ec *ec)
346 {
347         u8 d;
348         struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
349                                 .wdata = NULL, .rdata = &d,
350                                 .wlen = 0, .rlen = 1};
351 
352         return acpi_ec_transaction(ec, &t);
353 }
354 
355 static int acpi_ec_burst_disable(struct acpi_ec *ec)
356 {
357         struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
358                                 .wdata = NULL, .rdata = NULL,
359                                 .wlen = 0, .rlen = 0};
360 
361         return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
362                                 acpi_ec_transaction(ec, &t) : 0;
363 }
364 
365 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
366 {
367         int result;
368         u8 d;
369         struct transaction t = {.command = ACPI_EC_COMMAND_READ,
370                                 .wdata = &address, .rdata = &d,
371                                 .wlen = 1, .rlen = 1};
372 
373         result = acpi_ec_transaction(ec, &t);
374         *data = d;
375         return result;
376 }
377 
378 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
379 {
380         u8 wdata[2] = { address, data };
381         struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
382                                 .wdata = wdata, .rdata = NULL,
383                                 .wlen = 2, .rlen = 0};
384 
385         return acpi_ec_transaction(ec, &t);
386 }
387 
388 int ec_read(u8 addr, u8 *val)
389 {
390         int err;
391         u8 temp_data;
392 
393         if (!first_ec)
394                 return -ENODEV;
395 
396         err = acpi_ec_read(first_ec, addr, &temp_data);
397 
398         if (!err) {
399                 *val = temp_data;
400                 return 0;
401         } else
402                 return err;
403 }
404 
405 EXPORT_SYMBOL(ec_read);
406 
407 int ec_write(u8 addr, u8 val)
408 {
409         int err;
410 
411         if (!first_ec)
412                 return -ENODEV;
413 
414         err = acpi_ec_write(first_ec, addr, val);
415 
416         return err;
417 }
418 
419 EXPORT_SYMBOL(ec_write);
420 
421 int ec_transaction(u8 command,
422                    const u8 * wdata, unsigned wdata_len,
423                    u8 * rdata, unsigned rdata_len)
424 {
425         struct transaction t = {.command = command,
426                                 .wdata = wdata, .rdata = rdata,
427                                 .wlen = wdata_len, .rlen = rdata_len};
428         if (!first_ec)
429                 return -ENODEV;
430 
431         return acpi_ec_transaction(first_ec, &t);
432 }
433 
434 EXPORT_SYMBOL(ec_transaction);
435 
436 /* Get the handle to the EC device */
437 acpi_handle ec_get_handle(void)
438 {
439         if (!first_ec)
440                 return NULL;
441         return first_ec->handle;
442 }
443 
444 EXPORT_SYMBOL(ec_get_handle);
445 
446 /*
447  * Process _Q events that might have accumulated in the EC.
448  * Run with locked ec mutex.
449  */
450 static void acpi_ec_clear(struct acpi_ec *ec)
451 {
452         int i, status;
453         u8 value = 0;
454 
455         for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
456                 status = acpi_ec_sync_query(ec, &value);
457                 if (status || !value)
458                         break;
459         }
460 
461         if (unlikely(i == ACPI_EC_CLEAR_MAX))
462                 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
463         else
464                 pr_info("%d stale EC events cleared\n", i);
465 }
466 
467 void acpi_ec_block_transactions(void)
468 {
469         struct acpi_ec *ec = first_ec;
470 
471         if (!ec)
472                 return;
473 
474         mutex_lock(&ec->mutex);
475         /* Prevent transactions from being carried out */
476         set_bit(EC_FLAGS_BLOCKED, &ec->flags);
477         mutex_unlock(&ec->mutex);
478 }
479 
480 void acpi_ec_unblock_transactions(void)
481 {
482         struct acpi_ec *ec = first_ec;
483 
484         if (!ec)
485                 return;
486 
487         mutex_lock(&ec->mutex);
488         /* Allow transactions to be carried out again */
489         clear_bit(EC_FLAGS_BLOCKED, &ec->flags);
490 
491         if (EC_FLAGS_CLEAR_ON_RESUME)
492                 acpi_ec_clear(ec);
493 
494         mutex_unlock(&ec->mutex);
495 }
496 
497 void acpi_ec_unblock_transactions_early(void)
498 {
499         /*
500          * Allow transactions to happen again (this function is called from
501          * atomic context during wakeup, so we don't need to acquire the mutex).
502          */
503         if (first_ec)
504                 clear_bit(EC_FLAGS_BLOCKED, &first_ec->flags);
505 }
506 
507 static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 * data)
508 {
509         int result;
510         u8 d;
511         struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
512                                 .wdata = NULL, .rdata = &d,
513                                 .wlen = 0, .rlen = 1};
514         if (!ec || !data)
515                 return -EINVAL;
516         /*
517          * Query the EC to find out which _Qxx method we need to evaluate.
518          * Note that successful completion of the query causes the ACPI_EC_SCI
519          * bit to be cleared (and thus clearing the interrupt source).
520          */
521         result = acpi_ec_transaction_unlocked(ec, &t);
522         if (result)
523                 return result;
524         if (!d)
525                 return -ENODATA;
526         *data = d;
527         return 0;
528 }
529 
530 /* --------------------------------------------------------------------------
531                                 Event Management
532    -------------------------------------------------------------------------- */
533 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
534                               acpi_handle handle, acpi_ec_query_func func,
535                               void *data)
536 {
537         struct acpi_ec_query_handler *handler =
538             kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
539         if (!handler)
540                 return -ENOMEM;
541 
542         handler->query_bit = query_bit;
543         handler->handle = handle;
544         handler->func = func;
545         handler->data = data;
546         mutex_lock(&ec->mutex);
547         list_add(&handler->node, &ec->list);
548         mutex_unlock(&ec->mutex);
549         return 0;
550 }
551 
552 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
553 
554 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
555 {
556         struct acpi_ec_query_handler *handler, *tmp;
557         mutex_lock(&ec->mutex);
558         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
559                 if (query_bit == handler->query_bit) {
560                         list_del(&handler->node);
561                         kfree(handler);
562                 }
563         }
564         mutex_unlock(&ec->mutex);
565 }
566 
567 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
568 
569 static void acpi_ec_run(void *cxt)
570 {
571         struct acpi_ec_query_handler *handler = cxt;
572         if (!handler)
573                 return;
574         pr_debug("start query execution\n");
575         if (handler->func)
576                 handler->func(handler->data);
577         else if (handler->handle)
578                 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
579         pr_debug("stop query execution\n");
580         kfree(handler);
581 }
582 
583 static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data)
584 {
585         u8 value = 0;
586         int status;
587         struct acpi_ec_query_handler *handler, *copy;
588 
589         status = acpi_ec_query_unlocked(ec, &value);
590         if (data)
591                 *data = value;
592         if (status)
593                 return status;
594 
595         list_for_each_entry(handler, &ec->list, node) {
596                 if (value == handler->query_bit) {
597                         /* have custom handler for this bit */
598                         copy = kmalloc(sizeof(*handler), GFP_KERNEL);
599                         if (!copy)
600                                 return -ENOMEM;
601                         memcpy(copy, handler, sizeof(*copy));
602                         pr_debug("push query execution (0x%2x) on queue\n",
603                                 value);
604                         return acpi_os_execute((copy->func) ?
605                                 OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER,
606                                 acpi_ec_run, copy);
607                 }
608         }
609         return 0;
610 }
611 
612 static void acpi_ec_gpe_query(void *ec_cxt)
613 {
614         struct acpi_ec *ec = ec_cxt;
615         if (!ec)
616                 return;
617         mutex_lock(&ec->mutex);
618         acpi_ec_sync_query(ec, NULL);
619         mutex_unlock(&ec->mutex);
620 }
621 
622 static int ec_check_sci(struct acpi_ec *ec, u8 state)
623 {
624         if (state & ACPI_EC_FLAG_SCI) {
625                 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
626                         pr_debug("push gpe query to the queue\n");
627                         return acpi_os_execute(OSL_NOTIFY_HANDLER,
628                                 acpi_ec_gpe_query, ec);
629                 }
630         }
631         return 0;
632 }
633 
634 static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
635         u32 gpe_number, void *data)
636 {
637         struct acpi_ec *ec = data;
638         u8 status = acpi_ec_read_status(ec);
639 
640         pr_debug("~~~> interrupt, status:0x%02x\n", status);
641 
642         advance_transaction(ec, status);
643         if (ec_transaction_done(ec) &&
644             (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) {
645                 wake_up(&ec->wait);
646                 ec_check_sci(ec, acpi_ec_read_status(ec));
647         }
648         return ACPI_INTERRUPT_HANDLED | ACPI_REENABLE_GPE;
649 }
650 
651 /* --------------------------------------------------------------------------
652                              Address Space Management
653    -------------------------------------------------------------------------- */
654 
655 static acpi_status
656 acpi_ec_space_handler(u32 function, acpi_physical_address address,
657                       u32 bits, u64 *value64,
658                       void *handler_context, void *region_context)
659 {
660         struct acpi_ec *ec = handler_context;
661         int result = 0, i, bytes = bits / 8;
662         u8 *value = (u8 *)value64;
663 
664         if ((address > 0xFF) || !value || !handler_context)
665                 return AE_BAD_PARAMETER;
666 
667         if (function != ACPI_READ && function != ACPI_WRITE)
668                 return AE_BAD_PARAMETER;
669 
670         if (EC_FLAGS_MSI || bits > 8)
671                 acpi_ec_burst_enable(ec);
672 
673         for (i = 0; i < bytes; ++i, ++address, ++value)
674                 result = (function == ACPI_READ) ?
675                         acpi_ec_read(ec, address, value) :
676                         acpi_ec_write(ec, address, *value);
677 
678         if (EC_FLAGS_MSI || bits > 8)
679                 acpi_ec_burst_disable(ec);
680 
681         switch (result) {
682         case -EINVAL:
683                 return AE_BAD_PARAMETER;
684                 break;
685         case -ENODEV:
686                 return AE_NOT_FOUND;
687                 break;
688         case -ETIME:
689                 return AE_TIME;
690                 break;
691         default:
692                 return AE_OK;
693         }
694 }
695 
696 /* --------------------------------------------------------------------------
697                                Driver Interface
698    -------------------------------------------------------------------------- */
699 static acpi_status
700 ec_parse_io_ports(struct acpi_resource *resource, void *context);
701 
702 static struct acpi_ec *make_acpi_ec(void)
703 {
704         struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
705         if (!ec)
706                 return NULL;
707         ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
708         mutex_init(&ec->mutex);
709         init_waitqueue_head(&ec->wait);
710         INIT_LIST_HEAD(&ec->list);
711         spin_lock_init(&ec->lock);
712         return ec;
713 }
714 
715 static acpi_status
716 acpi_ec_register_query_methods(acpi_handle handle, u32 level,
717                                void *context, void **return_value)
718 {
719         char node_name[5];
720         struct acpi_buffer buffer = { sizeof(node_name), node_name };
721         struct acpi_ec *ec = context;
722         int value = 0;
723         acpi_status status;
724 
725         status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
726 
727         if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1) {
728                 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
729         }
730         return AE_OK;
731 }
732 
733 static acpi_status
734 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
735 {
736         acpi_status status;
737         unsigned long long tmp = 0;
738 
739         struct acpi_ec *ec = context;
740 
741         /* clear addr values, ec_parse_io_ports depend on it */
742         ec->command_addr = ec->data_addr = 0;
743 
744         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
745                                      ec_parse_io_ports, ec);
746         if (ACPI_FAILURE(status))
747                 return status;
748 
749         /* Get GPE bit assignment (EC events). */
750         /* TODO: Add support for _GPE returning a package */
751         status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
752         if (ACPI_FAILURE(status))
753                 return status;
754         ec->gpe = tmp;
755         /* Use the global lock for all EC transactions? */
756         tmp = 0;
757         acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
758         ec->global_lock = tmp;
759         ec->handle = handle;
760         return AE_CTRL_TERMINATE;
761 }
762 
763 static int ec_install_handlers(struct acpi_ec *ec)
764 {
765         acpi_status status;
766         if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
767                 return 0;
768         status = acpi_install_gpe_handler(NULL, ec->gpe,
769                                   ACPI_GPE_EDGE_TRIGGERED,
770                                   &acpi_ec_gpe_handler, ec);
771         if (ACPI_FAILURE(status))
772                 return -ENODEV;
773 
774         acpi_enable_gpe(NULL, ec->gpe);
775         status = acpi_install_address_space_handler(ec->handle,
776                                                     ACPI_ADR_SPACE_EC,
777                                                     &acpi_ec_space_handler,
778                                                     NULL, ec);
779         if (ACPI_FAILURE(status)) {
780                 if (status == AE_NOT_FOUND) {
781                         /*
782                          * Maybe OS fails in evaluating the _REG object.
783                          * The AE_NOT_FOUND error will be ignored and OS
784                          * continue to initialize EC.
785                          */
786                         pr_err("Fail in evaluating the _REG object"
787                                 " of EC device. Broken bios is suspected.\n");
788                 } else {
789                         acpi_disable_gpe(NULL, ec->gpe);
790                         acpi_remove_gpe_handler(NULL, ec->gpe,
791                                 &acpi_ec_gpe_handler);
792                         return -ENODEV;
793                 }
794         }
795 
796         set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
797         return 0;
798 }
799 
800 static void ec_remove_handlers(struct acpi_ec *ec)
801 {
802         acpi_disable_gpe(NULL, ec->gpe);
803         if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
804                                 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
805                 pr_err("failed to remove space handler\n");
806         if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
807                                 &acpi_ec_gpe_handler)))
808                 pr_err("failed to remove gpe handler\n");
809         clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
810 }
811 
812 static int acpi_ec_add(struct acpi_device *device)
813 {
814         struct acpi_ec *ec = NULL;
815         int ret;
816 
817         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
818         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
819 
820         /* Check for boot EC */
821         if (boot_ec &&
822             (boot_ec->handle == device->handle ||
823              boot_ec->handle == ACPI_ROOT_OBJECT)) {
824                 ec = boot_ec;
825                 boot_ec = NULL;
826         } else {
827                 ec = make_acpi_ec();
828                 if (!ec)
829                         return -ENOMEM;
830         }
831         if (ec_parse_device(device->handle, 0, ec, NULL) !=
832                 AE_CTRL_TERMINATE) {
833                         kfree(ec);
834                         return -EINVAL;
835         }
836 
837         /* Find and register all query methods */
838         acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
839                             acpi_ec_register_query_methods, NULL, ec, NULL);
840 
841         if (!first_ec)
842                 first_ec = ec;
843         device->driver_data = ec;
844 
845         ret = !!request_region(ec->data_addr, 1, "EC data");
846         WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
847         ret = !!request_region(ec->command_addr, 1, "EC cmd");
848         WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
849 
850         pr_info("GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
851                           ec->gpe, ec->command_addr, ec->data_addr);
852 
853         ret = ec_install_handlers(ec);
854 
855         /* EC is fully operational, allow queries */
856         clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
857 
858         /* Clear stale _Q events if hardware might require that */
859         if (EC_FLAGS_CLEAR_ON_RESUME) {
860                 mutex_lock(&ec->mutex);
861                 acpi_ec_clear(ec);
862                 mutex_unlock(&ec->mutex);
863         }
864         return ret;
865 }
866 
867 static int acpi_ec_remove(struct acpi_device *device)
868 {
869         struct acpi_ec *ec;
870         struct acpi_ec_query_handler *handler, *tmp;
871 
872         if (!device)
873                 return -EINVAL;
874 
875         ec = acpi_driver_data(device);
876         ec_remove_handlers(ec);
877         mutex_lock(&ec->mutex);
878         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
879                 list_del(&handler->node);
880                 kfree(handler);
881         }
882         mutex_unlock(&ec->mutex);
883         release_region(ec->data_addr, 1);
884         release_region(ec->command_addr, 1);
885         device->driver_data = NULL;
886         if (ec == first_ec)
887                 first_ec = NULL;
888         kfree(ec);
889         return 0;
890 }
891 
892 static acpi_status
893 ec_parse_io_ports(struct acpi_resource *resource, void *context)
894 {
895         struct acpi_ec *ec = context;
896 
897         if (resource->type != ACPI_RESOURCE_TYPE_IO)
898                 return AE_OK;
899 
900         /*
901          * The first address region returned is the data port, and
902          * the second address region returned is the status/command
903          * port.
904          */
905         if (ec->data_addr == 0)
906                 ec->data_addr = resource->data.io.minimum;
907         else if (ec->command_addr == 0)
908                 ec->command_addr = resource->data.io.minimum;
909         else
910                 return AE_CTRL_TERMINATE;
911 
912         return AE_OK;
913 }
914 
915 int __init acpi_boot_ec_enable(void)
916 {
917         if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
918                 return 0;
919         if (!ec_install_handlers(boot_ec)) {
920                 first_ec = boot_ec;
921                 return 0;
922         }
923         return -EFAULT;
924 }
925 
926 static const struct acpi_device_id ec_device_ids[] = {
927         {"PNP0C09", 0},
928         {"", 0},
929 };
930 
931 /* Some BIOS do not survive early DSDT scan, skip it */
932 static int ec_skip_dsdt_scan(const struct dmi_system_id *id)
933 {
934         EC_FLAGS_SKIP_DSDT_SCAN = 1;
935         return 0;
936 }
937 
938 /* ASUStek often supplies us with broken ECDT, validate it */
939 static int ec_validate_ecdt(const struct dmi_system_id *id)
940 {
941         EC_FLAGS_VALIDATE_ECDT = 1;
942         return 0;
943 }
944 
945 /* MSI EC needs special treatment, enable it */
946 static int ec_flag_msi(const struct dmi_system_id *id)
947 {
948         pr_debug("Detected MSI hardware, enabling workarounds.\n");
949         EC_FLAGS_MSI = 1;
950         EC_FLAGS_VALIDATE_ECDT = 1;
951         return 0;
952 }
953 
954 /*
955  * Clevo M720 notebook actually works ok with IRQ mode, if we lifted
956  * the GPE storm threshold back to 20
957  */
958 static int ec_enlarge_storm_threshold(const struct dmi_system_id *id)
959 {
960         pr_debug("Setting the EC GPE storm threshold to 20\n");
961         ec_storm_threshold  = 20;
962         return 0;
963 }
964 
965 /*
966  * On some hardware it is necessary to clear events accumulated by the EC during
967  * sleep. These ECs stop reporting GPEs until they are manually polled, if too
968  * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
969  *
970  * https://bugzilla.kernel.org/show_bug.cgi?id=44161
971  *
972  * Ideally, the EC should also be instructed NOT to accumulate events during
973  * sleep (which Windows seems to do somehow), but the interface to control this
974  * behaviour is not known at this time.
975  *
976  * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
977  * however it is very likely that other Samsung models are affected.
978  *
979  * On systems which don't accumulate _Q events during sleep, this extra check
980  * should be harmless.
981  */
982 static int ec_clear_on_resume(const struct dmi_system_id *id)
983 {
984         pr_debug("Detected system needing EC poll on resume.\n");
985         EC_FLAGS_CLEAR_ON_RESUME = 1;
986         return 0;
987 }
988 
989 static struct dmi_system_id ec_dmi_table[] __initdata = {
990         {
991         ec_skip_dsdt_scan, "Compal JFL92", {
992         DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
993         DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL},
994         {
995         ec_flag_msi, "MSI hardware", {
996         DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL},
997         {
998         ec_flag_msi, "MSI hardware", {
999         DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL},
1000         {
1001         ec_flag_msi, "MSI hardware", {
1002         DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL},
1003         {
1004         ec_flag_msi, "MSI hardware", {
1005         DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
1006         {
1007         ec_flag_msi, "Quanta hardware", {
1008         DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1009         DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
1010         {
1011         ec_flag_msi, "Quanta hardware", {
1012         DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1013         DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
1014         {
1015         ec_validate_ecdt, "ASUS hardware", {
1016         DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
1017         {
1018         ec_validate_ecdt, "ASUS hardware", {
1019         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
1020         {
1021         ec_enlarge_storm_threshold, "CLEVO hardware", {
1022         DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
1023         DMI_MATCH(DMI_PRODUCT_NAME, "M720T/M730T"),}, NULL},
1024         {
1025         ec_skip_dsdt_scan, "HP Folio 13", {
1026         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1027         DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL},
1028         {
1029         ec_validate_ecdt, "ASUS hardware", {
1030         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."),
1031         DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL},
1032         {
1033         ec_clear_on_resume, "Samsung hardware", {
1034         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
1035         {},
1036 };
1037 
1038 int __init acpi_ec_ecdt_probe(void)
1039 {
1040         acpi_status status;
1041         struct acpi_ec *saved_ec = NULL;
1042         struct acpi_table_ecdt *ecdt_ptr;
1043 
1044         boot_ec = make_acpi_ec();
1045         if (!boot_ec)
1046                 return -ENOMEM;
1047         /*
1048          * Generate a boot ec context
1049          */
1050         dmi_check_system(ec_dmi_table);
1051         status = acpi_get_table(ACPI_SIG_ECDT, 1,
1052                                 (struct acpi_table_header **)&ecdt_ptr);
1053         if (ACPI_SUCCESS(status)) {
1054                 pr_info("EC description table is found, configuring boot EC\n");
1055                 boot_ec->command_addr = ecdt_ptr->control.address;
1056                 boot_ec->data_addr = ecdt_ptr->data.address;
1057                 boot_ec->gpe = ecdt_ptr->gpe;
1058                 boot_ec->handle = ACPI_ROOT_OBJECT;
1059                 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle);
1060                 /* Don't trust ECDT, which comes from ASUSTek */
1061                 if (!EC_FLAGS_VALIDATE_ECDT)
1062                         goto install;
1063                 saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
1064                 if (!saved_ec)
1065                         return -ENOMEM;
1066         /* fall through */
1067         }
1068 
1069         if (EC_FLAGS_SKIP_DSDT_SCAN)
1070                 return -ENODEV;
1071 
1072         /* This workaround is needed only on some broken machines,
1073          * which require early EC, but fail to provide ECDT */
1074         pr_debug("Look up EC in DSDT\n");
1075         status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
1076                                         boot_ec, NULL);
1077         /* Check that acpi_get_devices actually find something */
1078         if (ACPI_FAILURE(status) || !boot_ec->handle)
1079                 goto error;
1080         if (saved_ec) {
1081                 /* try to find good ECDT from ASUSTek */
1082                 if (saved_ec->command_addr != boot_ec->command_addr ||
1083                     saved_ec->data_addr != boot_ec->data_addr ||
1084                     saved_ec->gpe != boot_ec->gpe ||
1085                     saved_ec->handle != boot_ec->handle)
1086                         pr_info("ASUSTek keeps feeding us with broken "
1087                         "ECDT tables, which are very hard to workaround. "
1088                         "Trying to use DSDT EC info instead. Please send "
1089                         "output of acpidump to linux-acpi@vger.kernel.org\n");
1090                 kfree(saved_ec);
1091                 saved_ec = NULL;
1092         } else {
1093                 /* We really need to limit this workaround, the only ASUS,
1094                 * which needs it, has fake EC._INI method, so use it as flag.
1095                 * Keep boot_ec struct as it will be needed soon.
1096                 */
1097                 if (!dmi_name_in_vendors("ASUS") ||
1098                     !acpi_has_method(boot_ec->handle, "_INI"))
1099                         return -ENODEV;
1100         }
1101 install:
1102         if (!ec_install_handlers(boot_ec)) {
1103                 first_ec = boot_ec;
1104                 return 0;
1105         }
1106 error:
1107         kfree(boot_ec);
1108         boot_ec = NULL;
1109         return -ENODEV;
1110 }
1111 
1112 static struct acpi_driver acpi_ec_driver = {
1113         .name = "ec",
1114         .class = ACPI_EC_CLASS,
1115         .ids = ec_device_ids,
1116         .ops = {
1117                 .add = acpi_ec_add,
1118                 .remove = acpi_ec_remove,
1119                 },
1120 };
1121 
1122 int __init acpi_ec_init(void)
1123 {
1124         int result = 0;
1125 
1126         /* Now register the driver for the EC */
1127         result = acpi_bus_register_driver(&acpi_ec_driver);
1128         if (result < 0)
1129                 return -ENODEV;
1130 
1131         return result;
1132 }
1133 
1134 /* EC driver currently not unloadable */
1135 #if 0
1136 static void __exit acpi_ec_exit(void)
1137 {
1138 
1139         acpi_bus_unregister_driver(&acpi_ec_driver);
1140         return;
1141 }
1142 #endif  /* 0 */
1143 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us