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