1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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
56#define ACPI_EC_FLAG_OBF 0x01
57#define ACPI_EC_FLAG_IBF 0x02
58#define ACPI_EC_FLAG_CMD 0x08
59#define ACPI_EC_FLAG_BURST 0x10
60#define ACPI_EC_FLAG_SCI 0x20
61
62
63enum 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
72#define ACPI_EC_UDELAY_GLK 1000
73#define ACPI_EC_MSI_UDELAY 550
74#define ACPI_EC_CLEAR_MAX 100
75
76
77enum {
78 EC_FLAGS_QUERY_PENDING,
79 EC_FLAGS_GPE_STORM,
80 EC_FLAGS_HANDLERS_INSTALLED,
81
82 EC_FLAGS_BLOCKED,
83};
84
85#define ACPI_EC_COMMAND_POLL 0x01
86#define ACPI_EC_COMMAND_COMPLETE 0x02
87
88
89static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
90module_param(ec_delay, uint, 0644);
91MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
92
93
94
95
96
97
98static unsigned int ec_storm_threshold __read_mostly = 8;
99module_param(ec_storm_threshold, uint, 0644);
100MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
101
102struct 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
110struct 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
122struct acpi_ec *boot_ec, *first_ec;
123EXPORT_SYMBOL(first_ec);
124
125static int EC_FLAGS_MSI;
126static int EC_FLAGS_VALIDATE_ECDT;
127static int EC_FLAGS_SKIP_DSDT_SCAN;
128static int EC_FLAGS_CLEAR_ON_RESUME;
129static int EC_FLAGS_QUERY_HANDSHAKE;
130
131
132
133
134
135static 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
150static 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
158static 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
164static 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
171static 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
191static 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
203static 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 }
256err:
257
258
259
260
261 if (!(status & ACPI_EC_FLAG_SCI)) {
262 if (in_interrupt() && t)
263 ++t->irq_count;
264 }
265 return wakeup;
266}
267
268static 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
275static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data);
276
277static 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
286static int ec_poll(struct acpi_ec *ec)
287{
288 unsigned long flags;
289 int repeat = 5;
290
291 while (repeat--) {
292 unsigned long delay = jiffies +
293 msecs_to_jiffies(ec_delay);
294 do {
295
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
318static 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
327 spin_lock_irqsave(&ec->lock, tmp);
328
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
347static 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
369 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
370
371 acpi_disable_gpe(NULL, ec->gpe);
372 }
373
374 status = acpi_ec_transaction_unlocked(ec, t);
375
376
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
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);
390unlock:
391 mutex_unlock(&ec->mutex);
392 return status;
393}
394
395static 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
405static 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
415static 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
428static 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
438int 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}
454EXPORT_SYMBOL(ec_read);
455
456int 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}
467EXPORT_SYMBOL(ec_write);
468
469int 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}
482EXPORT_SYMBOL(ec_transaction);
483
484
485acpi_handle ec_get_handle(void)
486{
487 if (!first_ec)
488 return NULL;
489 return first_ec->handle;
490}
491EXPORT_SYMBOL(ec_get_handle);
492
493
494
495
496
497static 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
514void 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
523 set_bit(EC_FLAGS_BLOCKED, &ec->flags);
524 mutex_unlock(&ec->mutex);
525}
526
527void 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
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
544void acpi_ec_unblock_transactions_early(void)
545{
546
547
548
549
550 if (first_ec)
551 clear_bit(EC_FLAGS_BLOCKED, &first_ec->flags);
552}
553
554static 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
566
567
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
580
581int 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}
600EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
601
602void 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}
615EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
616
617static 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
632static 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
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
661static 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
672static 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
684static 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
700
701
702static acpi_status
703acpi_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
742
743
744static acpi_status
745ec_parse_io_ports(struct acpi_resource *resource, void *context);
746
747static 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
761static acpi_status
762acpi_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
778static acpi_status
779ec_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
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
794
795 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
796 if (ACPI_FAILURE(status))
797 return status;
798 ec->gpe = tmp;
799
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
807static 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
828
829
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
845static void ec_remove_handlers(struct acpi_ec *ec)
846{
847 if (!test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
848 return;
849 acpi_disable_gpe(NULL, ec->gpe);
850 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
851 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
852 pr_err("failed to remove space handler\n");
853 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
854 &acpi_ec_gpe_handler)))
855 pr_err("failed to remove gpe handler\n");
856 clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
857}
858
859static int acpi_ec_add(struct acpi_device *device)
860{
861 struct acpi_ec *ec = NULL;
862 int ret;
863
864 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
865 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
866
867
868 if (boot_ec &&
869 (boot_ec->handle == device->handle ||
870 boot_ec->handle == ACPI_ROOT_OBJECT)) {
871 ec = boot_ec;
872 boot_ec = NULL;
873 } else {
874 ec = make_acpi_ec();
875 if (!ec)
876 return -ENOMEM;
877 }
878 if (ec_parse_device(device->handle, 0, ec, NULL) !=
879 AE_CTRL_TERMINATE) {
880 kfree(ec);
881 return -EINVAL;
882 }
883
884
885 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
886 acpi_ec_register_query_methods, NULL, ec, NULL);
887
888 if (!first_ec)
889 first_ec = ec;
890 device->driver_data = ec;
891
892 ret = !!request_region(ec->data_addr, 1, "EC data");
893 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
894 ret = !!request_region(ec->command_addr, 1, "EC cmd");
895 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
896
897 pr_info("GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
898 ec->gpe, ec->command_addr, ec->data_addr);
899
900 ret = ec_install_handlers(ec);
901
902
903 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
904
905
906 if (EC_FLAGS_CLEAR_ON_RESUME) {
907 mutex_lock(&ec->mutex);
908 acpi_ec_clear(ec);
909 mutex_unlock(&ec->mutex);
910 }
911 return ret;
912}
913
914static int acpi_ec_remove(struct acpi_device *device)
915{
916 struct acpi_ec *ec;
917 struct acpi_ec_query_handler *handler, *tmp;
918
919 if (!device)
920 return -EINVAL;
921
922 ec = acpi_driver_data(device);
923 ec_remove_handlers(ec);
924 mutex_lock(&ec->mutex);
925 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
926 list_del(&handler->node);
927 kfree(handler);
928 }
929 mutex_unlock(&ec->mutex);
930 release_region(ec->data_addr, 1);
931 release_region(ec->command_addr, 1);
932 device->driver_data = NULL;
933 if (ec == first_ec)
934 first_ec = NULL;
935 kfree(ec);
936 return 0;
937}
938
939static acpi_status
940ec_parse_io_ports(struct acpi_resource *resource, void *context)
941{
942 struct acpi_ec *ec = context;
943
944 if (resource->type != ACPI_RESOURCE_TYPE_IO)
945 return AE_OK;
946
947
948
949
950
951
952 if (ec->data_addr == 0)
953 ec->data_addr = resource->data.io.minimum;
954 else if (ec->command_addr == 0)
955 ec->command_addr = resource->data.io.minimum;
956 else
957 return AE_CTRL_TERMINATE;
958
959 return AE_OK;
960}
961
962int __init acpi_boot_ec_enable(void)
963{
964 if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
965 return 0;
966 if (!ec_install_handlers(boot_ec)) {
967 first_ec = boot_ec;
968 return 0;
969 }
970 return -EFAULT;
971}
972
973static const struct acpi_device_id ec_device_ids[] = {
974 {"PNP0C09", 0},
975 {"", 0},
976};
977
978
979static int ec_skip_dsdt_scan(const struct dmi_system_id *id)
980{
981 EC_FLAGS_SKIP_DSDT_SCAN = 1;
982 return 0;
983}
984
985
986static int ec_validate_ecdt(const struct dmi_system_id *id)
987{
988 EC_FLAGS_VALIDATE_ECDT = 1;
989 return 0;
990}
991
992
993static int ec_flag_msi(const struct dmi_system_id *id)
994{
995 pr_debug("Detected MSI hardware, enabling workarounds.\n");
996 EC_FLAGS_MSI = 1;
997 EC_FLAGS_VALIDATE_ECDT = 1;
998 return 0;
999}
1000
1001
1002
1003
1004
1005static int ec_enlarge_storm_threshold(const struct dmi_system_id *id)
1006{
1007 pr_debug("Setting the EC GPE storm threshold to 20\n");
1008 ec_storm_threshold = 20;
1009 return 0;
1010}
1011
1012
1013
1014
1015
1016
1017static int ec_flag_query_handshake(const struct dmi_system_id *id)
1018{
1019 pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1020 EC_FLAGS_QUERY_HANDSHAKE = 1;
1021 return 0;
1022}
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041static int ec_clear_on_resume(const struct dmi_system_id *id)
1042{
1043 pr_debug("Detected system needing EC poll on resume.\n");
1044 EC_FLAGS_CLEAR_ON_RESUME = 1;
1045 return 0;
1046}
1047
1048static struct dmi_system_id ec_dmi_table[] __initdata = {
1049 {
1050 ec_skip_dsdt_scan, "Compal JFL92", {
1051 DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
1052 DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL},
1053 {
1054 ec_flag_msi, "MSI hardware", {
1055 DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL},
1056 {
1057 ec_flag_msi, "MSI hardware", {
1058 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL},
1059 {
1060 ec_flag_msi, "MSI hardware", {
1061 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL},
1062 {
1063 ec_flag_msi, "MSI hardware", {
1064 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
1065 {
1066 ec_flag_msi, "Quanta hardware", {
1067 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1068 DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
1069 {
1070 ec_flag_msi, "Quanta hardware", {
1071 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1072 DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
1073 {
1074 ec_flag_msi, "Clevo W350etq", {
1075 DMI_MATCH(DMI_SYS_VENDOR, "CLEVO CO."),
1076 DMI_MATCH(DMI_PRODUCT_NAME, "W35_37ET"),}, NULL},
1077 {
1078 ec_validate_ecdt, "ASUS hardware", {
1079 DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
1080 {
1081 ec_validate_ecdt, "ASUS hardware", {
1082 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
1083 {
1084 ec_enlarge_storm_threshold, "CLEVO hardware", {
1085 DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
1086 DMI_MATCH(DMI_PRODUCT_NAME, "M720T/M730T"),}, NULL},
1087 {
1088 ec_skip_dsdt_scan, "HP Folio 13", {
1089 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1090 DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL},
1091 {
1092 ec_validate_ecdt, "ASUS hardware", {
1093 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."),
1094 DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL},
1095 {
1096 ec_clear_on_resume, "Samsung hardware", {
1097 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
1098 {
1099 ec_flag_query_handshake, "Acer hardware", {
1100 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), }, NULL},
1101 {},
1102};
1103
1104int __init acpi_ec_ecdt_probe(void)
1105{
1106 acpi_status status;
1107 struct acpi_ec *saved_ec = NULL;
1108 struct acpi_table_ecdt *ecdt_ptr;
1109
1110 boot_ec = make_acpi_ec();
1111 if (!boot_ec)
1112 return -ENOMEM;
1113
1114
1115
1116 dmi_check_system(ec_dmi_table);
1117 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1118 (struct acpi_table_header **)&ecdt_ptr);
1119 if (ACPI_SUCCESS(status)) {
1120 pr_info("EC description table is found, configuring boot EC\n");
1121 boot_ec->command_addr = ecdt_ptr->control.address;
1122 boot_ec->data_addr = ecdt_ptr->data.address;
1123 boot_ec->gpe = ecdt_ptr->gpe;
1124 boot_ec->handle = ACPI_ROOT_OBJECT;
1125 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id,
1126 &boot_ec->handle);
1127
1128 if (!EC_FLAGS_VALIDATE_ECDT)
1129 goto install;
1130 saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
1131 if (!saved_ec)
1132 return -ENOMEM;
1133
1134 }
1135
1136 if (EC_FLAGS_SKIP_DSDT_SCAN) {
1137 kfree(saved_ec);
1138 return -ENODEV;
1139 }
1140
1141
1142
1143 pr_debug("Look up EC in DSDT\n");
1144 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
1145 boot_ec, NULL);
1146
1147 if (ACPI_FAILURE(status) || !boot_ec->handle)
1148 goto error;
1149 if (saved_ec) {
1150
1151 if (saved_ec->command_addr != boot_ec->command_addr ||
1152 saved_ec->data_addr != boot_ec->data_addr ||
1153 saved_ec->gpe != boot_ec->gpe ||
1154 saved_ec->handle != boot_ec->handle)
1155 pr_info("ASUSTek keeps feeding us with broken "
1156 "ECDT tables, which are very hard to workaround. "
1157 "Trying to use DSDT EC info instead. Please send "
1158 "output of acpidump to linux-acpi@vger.kernel.org\n");
1159 kfree(saved_ec);
1160 saved_ec = NULL;
1161 } else {
1162
1163
1164
1165
1166 if (!dmi_name_in_vendors("ASUS") ||
1167 !acpi_has_method(boot_ec->handle, "_INI"))
1168 return -ENODEV;
1169 }
1170install:
1171 if (!ec_install_handlers(boot_ec)) {
1172 first_ec = boot_ec;
1173 return 0;
1174 }
1175error:
1176 kfree(boot_ec);
1177 kfree(saved_ec);
1178 boot_ec = NULL;
1179 return -ENODEV;
1180}
1181
1182static struct acpi_driver acpi_ec_driver = {
1183 .name = "ec",
1184 .class = ACPI_EC_CLASS,
1185 .ids = ec_device_ids,
1186 .ops = {
1187 .add = acpi_ec_add,
1188 .remove = acpi_ec_remove,
1189 },
1190};
1191
1192int __init acpi_ec_init(void)
1193{
1194 int result = 0;
1195
1196
1197 result = acpi_bus_register_driver(&acpi_ec_driver);
1198 if (result < 0)
1199 return -ENODEV;
1200
1201 return result;
1202}
1203
1204
1205#if 0
1206static void __exit acpi_ec_exit(void)
1207{
1208
1209 acpi_bus_unregister_driver(&acpi_ec_driver);
1210}
1211#endif
1212