1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#define pr_fmt(fmt) "ACPI: EC: " fmt
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/types.h>
23#include <linux/delay.h>
24#include <linux/interrupt.h>
25#include <linux/list.h>
26#include <linux/spinlock.h>
27#include <linux/slab.h>
28#include <linux/suspend.h>
29#include <linux/acpi.h>
30#include <linux/dmi.h>
31#include <asm/io.h>
32
33#include "internal.h"
34
35#define ACPI_EC_CLASS "embedded_controller"
36#define ACPI_EC_DEVICE_NAME "Embedded Controller"
37
38
39#define ACPI_EC_FLAG_OBF 0x01
40#define ACPI_EC_FLAG_IBF 0x02
41#define ACPI_EC_FLAG_CMD 0x08
42#define ACPI_EC_FLAG_BURST 0x10
43#define ACPI_EC_FLAG_SCI 0x20
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73#define ACPI_EC_EVT_TIMING_STATUS 0x00
74#define ACPI_EC_EVT_TIMING_QUERY 0x01
75#define ACPI_EC_EVT_TIMING_EVENT 0x02
76
77
78enum ec_command {
79 ACPI_EC_COMMAND_READ = 0x80,
80 ACPI_EC_COMMAND_WRITE = 0x81,
81 ACPI_EC_BURST_ENABLE = 0x82,
82 ACPI_EC_BURST_DISABLE = 0x83,
83 ACPI_EC_COMMAND_QUERY = 0x84,
84};
85
86#define ACPI_EC_DELAY 500
87#define ACPI_EC_UDELAY_GLK 1000
88#define ACPI_EC_UDELAY_POLL 550
89#define ACPI_EC_CLEAR_MAX 100
90
91#define ACPI_EC_MAX_QUERIES 16
92
93enum {
94 EC_FLAGS_QUERY_ENABLED,
95 EC_FLAGS_QUERY_PENDING,
96 EC_FLAGS_QUERY_GUARDING,
97 EC_FLAGS_EVENT_HANDLER_INSTALLED,
98 EC_FLAGS_EC_HANDLER_INSTALLED,
99 EC_FLAGS_QUERY_METHODS_INSTALLED,
100 EC_FLAGS_STARTED,
101 EC_FLAGS_STOPPED,
102 EC_FLAGS_EVENTS_MASKED,
103};
104
105#define ACPI_EC_COMMAND_POLL 0x01
106#define ACPI_EC_COMMAND_COMPLETE 0x02
107
108
109static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
110module_param(ec_delay, uint, 0644);
111MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
112
113static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
114module_param(ec_max_queries, uint, 0644);
115MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
116
117static bool ec_busy_polling __read_mostly;
118module_param(ec_busy_polling, bool, 0644);
119MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
120
121static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
122module_param(ec_polling_guard, uint, 0644);
123MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
124
125static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
126
127
128
129
130
131
132static unsigned int ec_storm_threshold __read_mostly = 8;
133module_param(ec_storm_threshold, uint, 0644);
134MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
135
136static bool ec_freeze_events __read_mostly = false;
137module_param(ec_freeze_events, bool, 0644);
138MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
139
140static bool ec_no_wakeup __read_mostly;
141module_param(ec_no_wakeup, bool, 0644);
142MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
143
144struct acpi_ec_query_handler {
145 struct list_head node;
146 acpi_ec_query_func func;
147 acpi_handle handle;
148 void *data;
149 u8 query_bit;
150 struct kref kref;
151};
152
153struct transaction {
154 const u8 *wdata;
155 u8 *rdata;
156 unsigned short irq_count;
157 u8 command;
158 u8 wi;
159 u8 ri;
160 u8 wlen;
161 u8 rlen;
162 u8 flags;
163};
164
165struct acpi_ec_query {
166 struct transaction transaction;
167 struct work_struct work;
168 struct acpi_ec_query_handler *handler;
169};
170
171static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
172static void advance_transaction(struct acpi_ec *ec);
173static void acpi_ec_event_handler(struct work_struct *work);
174static void acpi_ec_event_processor(struct work_struct *work);
175
176struct acpi_ec *first_ec;
177EXPORT_SYMBOL(first_ec);
178
179static struct acpi_ec *boot_ec;
180static bool boot_ec_is_ecdt = false;
181static struct workqueue_struct *ec_wq;
182static struct workqueue_struct *ec_query_wq;
183
184static int EC_FLAGS_CORRECT_ECDT;
185static int EC_FLAGS_IGNORE_DSDT_GPE;
186static int EC_FLAGS_CLEAR_ON_RESUME;
187
188
189
190
191
192
193
194
195
196#ifdef DEBUG
197#define EC_DBG_SEP " "
198#define EC_DBG_DRV "+++++"
199#define EC_DBG_STM "====="
200#define EC_DBG_REQ "*****"
201#define EC_DBG_EVT "#####"
202#else
203#define EC_DBG_SEP ""
204#define EC_DBG_DRV
205#define EC_DBG_STM
206#define EC_DBG_REQ
207#define EC_DBG_EVT
208#endif
209
210#define ec_log_raw(fmt, ...) \
211 pr_info(fmt "\n", ##__VA_ARGS__)
212#define ec_dbg_raw(fmt, ...) \
213 pr_debug(fmt "\n", ##__VA_ARGS__)
214#define ec_log(filter, fmt, ...) \
215 ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
216#define ec_dbg(filter, fmt, ...) \
217 ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
218
219#define ec_log_drv(fmt, ...) \
220 ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
221#define ec_dbg_drv(fmt, ...) \
222 ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
223#define ec_dbg_stm(fmt, ...) \
224 ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
225#define ec_dbg_req(fmt, ...) \
226 ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
227#define ec_dbg_evt(fmt, ...) \
228 ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
229#define ec_dbg_ref(ec, fmt, ...) \
230 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
231
232
233
234
235
236static bool acpi_ec_started(struct acpi_ec *ec)
237{
238 return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
239 !test_bit(EC_FLAGS_STOPPED, &ec->flags);
240}
241
242static bool acpi_ec_event_enabled(struct acpi_ec *ec)
243{
244
245
246
247
248
249 if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
250 return false;
251
252
253
254
255
256
257
258
259
260 if (ec_freeze_events)
261 return acpi_ec_started(ec);
262 else
263 return test_bit(EC_FLAGS_STARTED, &ec->flags);
264}
265
266static bool acpi_ec_flushed(struct acpi_ec *ec)
267{
268 return ec->reference_count == 1;
269}
270
271
272
273
274
275static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
276{
277 u8 x = inb(ec->command_addr);
278
279 ec_dbg_raw("EC_SC(R) = 0x%2.2x "
280 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
281 x,
282 !!(x & ACPI_EC_FLAG_SCI),
283 !!(x & ACPI_EC_FLAG_BURST),
284 !!(x & ACPI_EC_FLAG_CMD),
285 !!(x & ACPI_EC_FLAG_IBF),
286 !!(x & ACPI_EC_FLAG_OBF));
287 return x;
288}
289
290static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
291{
292 u8 x = inb(ec->data_addr);
293
294 ec->timestamp = jiffies;
295 ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
296 return x;
297}
298
299static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
300{
301 ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
302 outb(command, ec->command_addr);
303 ec->timestamp = jiffies;
304}
305
306static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
307{
308 ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
309 outb(data, ec->data_addr);
310 ec->timestamp = jiffies;
311}
312
313#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
314static const char *acpi_ec_cmd_string(u8 cmd)
315{
316 switch (cmd) {
317 case 0x80:
318 return "RD_EC";
319 case 0x81:
320 return "WR_EC";
321 case 0x82:
322 return "BE_EC";
323 case 0x83:
324 return "BD_EC";
325 case 0x84:
326 return "QR_EC";
327 }
328 return "UNKNOWN";
329}
330#else
331#define acpi_ec_cmd_string(cmd) "UNDEF"
332#endif
333
334
335
336
337
338static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
339{
340 acpi_event_status gpe_status = 0;
341
342 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
343 return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
344}
345
346static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
347{
348 if (open)
349 acpi_enable_gpe(NULL, ec->gpe);
350 else {
351 BUG_ON(ec->reference_count < 1);
352 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
353 }
354 if (acpi_ec_is_gpe_raised(ec)) {
355
356
357
358
359
360 ec_dbg_raw("Polling quirk");
361 advance_transaction(ec);
362 }
363}
364
365static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
366{
367 if (close)
368 acpi_disable_gpe(NULL, ec->gpe);
369 else {
370 BUG_ON(ec->reference_count < 1);
371 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
372 }
373}
374
375static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
376{
377
378
379
380
381
382
383
384
385
386
387 if (!acpi_ec_is_gpe_raised(ec))
388 return;
389 acpi_clear_gpe(NULL, ec->gpe);
390}
391
392
393
394
395
396static void acpi_ec_submit_request(struct acpi_ec *ec)
397{
398 ec->reference_count++;
399 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
400 ec->gpe >= 0 && ec->reference_count == 1)
401 acpi_ec_enable_gpe(ec, true);
402}
403
404static void acpi_ec_complete_request(struct acpi_ec *ec)
405{
406 bool flushed = false;
407
408 ec->reference_count--;
409 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
410 ec->gpe >= 0 && ec->reference_count == 0)
411 acpi_ec_disable_gpe(ec, true);
412 flushed = acpi_ec_flushed(ec);
413 if (flushed)
414 wake_up(&ec->wait);
415}
416
417static void acpi_ec_mask_events(struct acpi_ec *ec)
418{
419 if (!test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
420 if (ec->gpe >= 0)
421 acpi_ec_disable_gpe(ec, false);
422 else
423 disable_irq_nosync(ec->irq);
424
425 ec_dbg_drv("Polling enabled");
426 set_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
427 }
428}
429
430static void acpi_ec_unmask_events(struct acpi_ec *ec)
431{
432 if (test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
433 clear_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
434 if (ec->gpe >= 0)
435 acpi_ec_enable_gpe(ec, false);
436 else
437 enable_irq(ec->irq);
438
439 ec_dbg_drv("Polling disabled");
440 }
441}
442
443
444
445
446
447
448
449
450
451
452
453
454static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
455{
456 if (!acpi_ec_started(ec))
457 return false;
458 acpi_ec_submit_request(ec);
459 return true;
460}
461
462static void acpi_ec_submit_query(struct acpi_ec *ec)
463{
464 acpi_ec_mask_events(ec);
465 if (!acpi_ec_event_enabled(ec))
466 return;
467 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
468 ec_dbg_evt("Command(%s) submitted/blocked",
469 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
470 ec->nr_pending_queries++;
471 queue_work(ec_wq, &ec->work);
472 }
473}
474
475static void acpi_ec_complete_query(struct acpi_ec *ec)
476{
477 if (test_and_clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
478 ec_dbg_evt("Command(%s) unblocked",
479 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
480 acpi_ec_unmask_events(ec);
481}
482
483static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
484{
485 if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
486 ec_log_drv("event unblocked");
487
488
489
490
491 advance_transaction(ec);
492}
493
494static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
495{
496 if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
497 ec_log_drv("event blocked");
498}
499
500
501
502
503
504static void acpi_ec_clear(struct acpi_ec *ec)
505{
506 int i, status;
507 u8 value = 0;
508
509 for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
510 status = acpi_ec_query(ec, &value);
511 if (status || !value)
512 break;
513 }
514 if (unlikely(i == ACPI_EC_CLEAR_MAX))
515 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
516 else
517 pr_info("%d stale EC events cleared\n", i);
518}
519
520static void acpi_ec_enable_event(struct acpi_ec *ec)
521{
522 unsigned long flags;
523
524 spin_lock_irqsave(&ec->lock, flags);
525 if (acpi_ec_started(ec))
526 __acpi_ec_enable_event(ec);
527 spin_unlock_irqrestore(&ec->lock, flags);
528
529
530 if (EC_FLAGS_CLEAR_ON_RESUME)
531 acpi_ec_clear(ec);
532}
533
534#ifdef CONFIG_PM_SLEEP
535static void __acpi_ec_flush_work(void)
536{
537 drain_workqueue(ec_wq);
538 flush_workqueue(ec_query_wq);
539}
540
541static void acpi_ec_disable_event(struct acpi_ec *ec)
542{
543 unsigned long flags;
544
545 spin_lock_irqsave(&ec->lock, flags);
546 __acpi_ec_disable_event(ec);
547 spin_unlock_irqrestore(&ec->lock, flags);
548
549
550
551
552
553 __acpi_ec_flush_work();
554}
555
556void acpi_ec_flush_work(void)
557{
558
559 if (!ec_wq)
560 return;
561
562 __acpi_ec_flush_work();
563}
564#endif
565
566static bool acpi_ec_guard_event(struct acpi_ec *ec)
567{
568 bool guarded = true;
569 unsigned long flags;
570
571 spin_lock_irqsave(&ec->lock, flags);
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
587 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY ||
588 !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
589 (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
590 guarded = false;
591 spin_unlock_irqrestore(&ec->lock, flags);
592 return guarded;
593}
594
595static int ec_transaction_polled(struct acpi_ec *ec)
596{
597 unsigned long flags;
598 int ret = 0;
599
600 spin_lock_irqsave(&ec->lock, flags);
601 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
602 ret = 1;
603 spin_unlock_irqrestore(&ec->lock, flags);
604 return ret;
605}
606
607static int ec_transaction_completed(struct acpi_ec *ec)
608{
609 unsigned long flags;
610 int ret = 0;
611
612 spin_lock_irqsave(&ec->lock, flags);
613 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
614 ret = 1;
615 spin_unlock_irqrestore(&ec->lock, flags);
616 return ret;
617}
618
619static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
620{
621 ec->curr->flags |= flag;
622 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
623 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS &&
624 flag == ACPI_EC_COMMAND_POLL)
625 acpi_ec_complete_query(ec);
626 if (ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY &&
627 flag == ACPI_EC_COMMAND_COMPLETE)
628 acpi_ec_complete_query(ec);
629 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
630 flag == ACPI_EC_COMMAND_COMPLETE)
631 set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
632 }
633}
634
635static void advance_transaction(struct acpi_ec *ec)
636{
637 struct transaction *t;
638 u8 status;
639 bool wakeup = false;
640
641 ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
642 smp_processor_id());
643
644
645
646
647
648 if (ec->gpe >= 0)
649 acpi_ec_clear_gpe(ec);
650
651 status = acpi_ec_read_status(ec);
652 t = ec->curr;
653
654
655
656
657 if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
658 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
659 (!ec->nr_pending_queries ||
660 test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
661 clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
662 acpi_ec_complete_query(ec);
663 }
664 }
665 if (!t)
666 goto err;
667 if (t->flags & ACPI_EC_COMMAND_POLL) {
668 if (t->wlen > t->wi) {
669 if ((status & ACPI_EC_FLAG_IBF) == 0)
670 acpi_ec_write_data(ec, t->wdata[t->wi++]);
671 else
672 goto err;
673 } else if (t->rlen > t->ri) {
674 if ((status & ACPI_EC_FLAG_OBF) == 1) {
675 t->rdata[t->ri++] = acpi_ec_read_data(ec);
676 if (t->rlen == t->ri) {
677 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
678 if (t->command == ACPI_EC_COMMAND_QUERY)
679 ec_dbg_evt("Command(%s) completed by hardware",
680 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
681 wakeup = true;
682 }
683 } else
684 goto err;
685 } else if (t->wlen == t->wi &&
686 (status & ACPI_EC_FLAG_IBF) == 0) {
687 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
688 wakeup = true;
689 }
690 goto out;
691 } else if (!(status & ACPI_EC_FLAG_IBF)) {
692 acpi_ec_write_cmd(ec, t->command);
693 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
694 goto out;
695 }
696err:
697
698
699
700
701 if (!(status & ACPI_EC_FLAG_SCI)) {
702 if (in_interrupt() && t) {
703 if (t->irq_count < ec_storm_threshold)
704 ++t->irq_count;
705
706 if (t->irq_count == ec_storm_threshold)
707 acpi_ec_mask_events(ec);
708 }
709 }
710out:
711 if (status & ACPI_EC_FLAG_SCI)
712 acpi_ec_submit_query(ec);
713 if (wakeup && in_interrupt())
714 wake_up(&ec->wait);
715}
716
717static void start_transaction(struct acpi_ec *ec)
718{
719 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
720 ec->curr->flags = 0;
721}
722
723static int ec_guard(struct acpi_ec *ec)
724{
725 unsigned long guard = usecs_to_jiffies(ec->polling_guard);
726 unsigned long timeout = ec->timestamp + guard;
727
728
729 do {
730 if (ec->busy_polling) {
731
732 if (ec_transaction_completed(ec))
733 return 0;
734 udelay(jiffies_to_usecs(guard));
735 } else {
736
737
738
739
740
741
742
743
744
745
746 if (!ec_transaction_polled(ec) &&
747 !acpi_ec_guard_event(ec))
748 break;
749 if (wait_event_timeout(ec->wait,
750 ec_transaction_completed(ec),
751 guard))
752 return 0;
753 }
754 } while (time_before(jiffies, timeout));
755 return -ETIME;
756}
757
758static int ec_poll(struct acpi_ec *ec)
759{
760 unsigned long flags;
761 int repeat = 5;
762
763 while (repeat--) {
764 unsigned long delay = jiffies +
765 msecs_to_jiffies(ec_delay);
766 do {
767 if (!ec_guard(ec))
768 return 0;
769 spin_lock_irqsave(&ec->lock, flags);
770 advance_transaction(ec);
771 spin_unlock_irqrestore(&ec->lock, flags);
772 } while (time_before(jiffies, delay));
773 pr_debug("controller reset, restart transaction\n");
774 spin_lock_irqsave(&ec->lock, flags);
775 start_transaction(ec);
776 spin_unlock_irqrestore(&ec->lock, flags);
777 }
778 return -ETIME;
779}
780
781static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
782 struct transaction *t)
783{
784 unsigned long tmp;
785 int ret = 0;
786
787
788 spin_lock_irqsave(&ec->lock, tmp);
789
790 if (!acpi_ec_submit_flushable_request(ec)) {
791 ret = -EINVAL;
792 goto unlock;
793 }
794 ec_dbg_ref(ec, "Increase command");
795
796 ec->curr = t;
797 ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
798 start_transaction(ec);
799 spin_unlock_irqrestore(&ec->lock, tmp);
800
801 ret = ec_poll(ec);
802
803 spin_lock_irqsave(&ec->lock, tmp);
804 if (t->irq_count == ec_storm_threshold)
805 acpi_ec_unmask_events(ec);
806 ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
807 ec->curr = NULL;
808
809 acpi_ec_complete_request(ec);
810 ec_dbg_ref(ec, "Decrease command");
811unlock:
812 spin_unlock_irqrestore(&ec->lock, tmp);
813 return ret;
814}
815
816static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
817{
818 int status;
819 u32 glk;
820
821 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
822 return -EINVAL;
823 if (t->rdata)
824 memset(t->rdata, 0, t->rlen);
825
826 mutex_lock(&ec->mutex);
827 if (ec->global_lock) {
828 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
829 if (ACPI_FAILURE(status)) {
830 status = -ENODEV;
831 goto unlock;
832 }
833 }
834
835 status = acpi_ec_transaction_unlocked(ec, t);
836
837 if (ec->global_lock)
838 acpi_release_global_lock(glk);
839unlock:
840 mutex_unlock(&ec->mutex);
841 return status;
842}
843
844static int acpi_ec_burst_enable(struct acpi_ec *ec)
845{
846 u8 d;
847 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
848 .wdata = NULL, .rdata = &d,
849 .wlen = 0, .rlen = 1};
850
851 return acpi_ec_transaction(ec, &t);
852}
853
854static int acpi_ec_burst_disable(struct acpi_ec *ec)
855{
856 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
857 .wdata = NULL, .rdata = NULL,
858 .wlen = 0, .rlen = 0};
859
860 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
861 acpi_ec_transaction(ec, &t) : 0;
862}
863
864static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
865{
866 int result;
867 u8 d;
868 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
869 .wdata = &address, .rdata = &d,
870 .wlen = 1, .rlen = 1};
871
872 result = acpi_ec_transaction(ec, &t);
873 *data = d;
874 return result;
875}
876
877static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
878{
879 u8 wdata[2] = { address, data };
880 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
881 .wdata = wdata, .rdata = NULL,
882 .wlen = 2, .rlen = 0};
883
884 return acpi_ec_transaction(ec, &t);
885}
886
887int ec_read(u8 addr, u8 *val)
888{
889 int err;
890 u8 temp_data;
891
892 if (!first_ec)
893 return -ENODEV;
894
895 err = acpi_ec_read(first_ec, addr, &temp_data);
896
897 if (!err) {
898 *val = temp_data;
899 return 0;
900 }
901 return err;
902}
903EXPORT_SYMBOL(ec_read);
904
905int ec_write(u8 addr, u8 val)
906{
907 int err;
908
909 if (!first_ec)
910 return -ENODEV;
911
912 err = acpi_ec_write(first_ec, addr, val);
913
914 return err;
915}
916EXPORT_SYMBOL(ec_write);
917
918int ec_transaction(u8 command,
919 const u8 *wdata, unsigned wdata_len,
920 u8 *rdata, unsigned rdata_len)
921{
922 struct transaction t = {.command = command,
923 .wdata = wdata, .rdata = rdata,
924 .wlen = wdata_len, .rlen = rdata_len};
925
926 if (!first_ec)
927 return -ENODEV;
928
929 return acpi_ec_transaction(first_ec, &t);
930}
931EXPORT_SYMBOL(ec_transaction);
932
933
934acpi_handle ec_get_handle(void)
935{
936 if (!first_ec)
937 return NULL;
938 return first_ec->handle;
939}
940EXPORT_SYMBOL(ec_get_handle);
941
942static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
943{
944 unsigned long flags;
945
946 spin_lock_irqsave(&ec->lock, flags);
947 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
948 ec_dbg_drv("Starting EC");
949
950 if (!resuming) {
951 acpi_ec_submit_request(ec);
952 ec_dbg_ref(ec, "Increase driver");
953 }
954 ec_log_drv("EC started");
955 }
956 spin_unlock_irqrestore(&ec->lock, flags);
957}
958
959static bool acpi_ec_stopped(struct acpi_ec *ec)
960{
961 unsigned long flags;
962 bool flushed;
963
964 spin_lock_irqsave(&ec->lock, flags);
965 flushed = acpi_ec_flushed(ec);
966 spin_unlock_irqrestore(&ec->lock, flags);
967 return flushed;
968}
969
970static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
971{
972 unsigned long flags;
973
974 spin_lock_irqsave(&ec->lock, flags);
975 if (acpi_ec_started(ec)) {
976 ec_dbg_drv("Stopping EC");
977 set_bit(EC_FLAGS_STOPPED, &ec->flags);
978 spin_unlock_irqrestore(&ec->lock, flags);
979 wait_event(ec->wait, acpi_ec_stopped(ec));
980 spin_lock_irqsave(&ec->lock, flags);
981
982 if (!suspending) {
983 acpi_ec_complete_request(ec);
984 ec_dbg_ref(ec, "Decrease driver");
985 } else if (!ec_freeze_events)
986 __acpi_ec_disable_event(ec);
987 clear_bit(EC_FLAGS_STARTED, &ec->flags);
988 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
989 ec_log_drv("EC stopped");
990 }
991 spin_unlock_irqrestore(&ec->lock, flags);
992}
993
994static void acpi_ec_enter_noirq(struct acpi_ec *ec)
995{
996 unsigned long flags;
997
998 spin_lock_irqsave(&ec->lock, flags);
999 ec->busy_polling = true;
1000 ec->polling_guard = 0;
1001 ec_log_drv("interrupt blocked");
1002 spin_unlock_irqrestore(&ec->lock, flags);
1003}
1004
1005static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1006{
1007 unsigned long flags;
1008
1009 spin_lock_irqsave(&ec->lock, flags);
1010 ec->busy_polling = ec_busy_polling;
1011 ec->polling_guard = ec_polling_guard;
1012 ec_log_drv("interrupt unblocked");
1013 spin_unlock_irqrestore(&ec->lock, flags);
1014}
1015
1016void acpi_ec_block_transactions(void)
1017{
1018 struct acpi_ec *ec = first_ec;
1019
1020 if (!ec)
1021 return;
1022
1023 mutex_lock(&ec->mutex);
1024
1025 acpi_ec_stop(ec, true);
1026 mutex_unlock(&ec->mutex);
1027}
1028
1029void acpi_ec_unblock_transactions(void)
1030{
1031
1032
1033
1034
1035 if (first_ec)
1036 acpi_ec_start(first_ec, true);
1037}
1038
1039
1040
1041
1042static struct acpi_ec_query_handler *
1043acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1044{
1045 struct acpi_ec_query_handler *handler;
1046
1047 mutex_lock(&ec->mutex);
1048 list_for_each_entry(handler, &ec->list, node) {
1049 if (value == handler->query_bit) {
1050 kref_get(&handler->kref);
1051 mutex_unlock(&ec->mutex);
1052 return handler;
1053 }
1054 }
1055 mutex_unlock(&ec->mutex);
1056 return NULL;
1057}
1058
1059static void acpi_ec_query_handler_release(struct kref *kref)
1060{
1061 struct acpi_ec_query_handler *handler =
1062 container_of(kref, struct acpi_ec_query_handler, kref);
1063
1064 kfree(handler);
1065}
1066
1067static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1068{
1069 kref_put(&handler->kref, acpi_ec_query_handler_release);
1070}
1071
1072int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1073 acpi_handle handle, acpi_ec_query_func func,
1074 void *data)
1075{
1076 struct acpi_ec_query_handler *handler =
1077 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
1078
1079 if (!handler)
1080 return -ENOMEM;
1081
1082 handler->query_bit = query_bit;
1083 handler->handle = handle;
1084 handler->func = func;
1085 handler->data = data;
1086 mutex_lock(&ec->mutex);
1087 kref_init(&handler->kref);
1088 list_add(&handler->node, &ec->list);
1089 mutex_unlock(&ec->mutex);
1090 return 0;
1091}
1092EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1093
1094static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1095 bool remove_all, u8 query_bit)
1096{
1097 struct acpi_ec_query_handler *handler, *tmp;
1098 LIST_HEAD(free_list);
1099
1100 mutex_lock(&ec->mutex);
1101 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1102 if (remove_all || query_bit == handler->query_bit) {
1103 list_del_init(&handler->node);
1104 list_add(&handler->node, &free_list);
1105 }
1106 }
1107 mutex_unlock(&ec->mutex);
1108 list_for_each_entry_safe(handler, tmp, &free_list, node)
1109 acpi_ec_put_query_handler(handler);
1110}
1111
1112void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1113{
1114 acpi_ec_remove_query_handlers(ec, false, query_bit);
1115}
1116EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
1117
1118static struct acpi_ec_query *acpi_ec_create_query(u8 *pval)
1119{
1120 struct acpi_ec_query *q;
1121 struct transaction *t;
1122
1123 q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1124 if (!q)
1125 return NULL;
1126 INIT_WORK(&q->work, acpi_ec_event_processor);
1127 t = &q->transaction;
1128 t->command = ACPI_EC_COMMAND_QUERY;
1129 t->rdata = pval;
1130 t->rlen = 1;
1131 return q;
1132}
1133
1134static void acpi_ec_delete_query(struct acpi_ec_query *q)
1135{
1136 if (q) {
1137 if (q->handler)
1138 acpi_ec_put_query_handler(q->handler);
1139 kfree(q);
1140 }
1141}
1142
1143static void acpi_ec_event_processor(struct work_struct *work)
1144{
1145 struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1146 struct acpi_ec_query_handler *handler = q->handler;
1147
1148 ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
1149 if (handler->func)
1150 handler->func(handler->data);
1151 else if (handler->handle)
1152 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
1153 ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
1154 acpi_ec_delete_query(q);
1155}
1156
1157static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
1158{
1159 u8 value = 0;
1160 int result;
1161 struct acpi_ec_query *q;
1162
1163 q = acpi_ec_create_query(&value);
1164 if (!q)
1165 return -ENOMEM;
1166
1167
1168
1169
1170
1171
1172 result = acpi_ec_transaction(ec, &q->transaction);
1173 if (!value)
1174 result = -ENODATA;
1175 if (result)
1176 goto err_exit;
1177
1178 q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1179 if (!q->handler) {
1180 result = -ENODATA;
1181 goto err_exit;
1182 }
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193 ec_dbg_evt("Query(0x%02x) scheduled", value);
1194 if (!queue_work(ec_query_wq, &q->work)) {
1195 ec_dbg_evt("Query(0x%02x) overlapped", value);
1196 result = -EBUSY;
1197 }
1198
1199err_exit:
1200 if (result)
1201 acpi_ec_delete_query(q);
1202 if (data)
1203 *data = value;
1204 return result;
1205}
1206
1207static void acpi_ec_check_event(struct acpi_ec *ec)
1208{
1209 unsigned long flags;
1210
1211 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1212 if (ec_guard(ec)) {
1213 spin_lock_irqsave(&ec->lock, flags);
1214
1215
1216
1217
1218 if (!ec->curr)
1219 advance_transaction(ec);
1220 spin_unlock_irqrestore(&ec->lock, flags);
1221 }
1222 }
1223}
1224
1225static void acpi_ec_event_handler(struct work_struct *work)
1226{
1227 unsigned long flags;
1228 struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
1229
1230 ec_dbg_evt("Event started");
1231
1232 spin_lock_irqsave(&ec->lock, flags);
1233 while (ec->nr_pending_queries) {
1234 spin_unlock_irqrestore(&ec->lock, flags);
1235 (void)acpi_ec_query(ec, NULL);
1236 spin_lock_irqsave(&ec->lock, flags);
1237 ec->nr_pending_queries--;
1238
1239
1240
1241
1242
1243
1244 if (!ec->nr_pending_queries) {
1245 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
1246 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY)
1247 acpi_ec_complete_query(ec);
1248 }
1249 }
1250 spin_unlock_irqrestore(&ec->lock, flags);
1251
1252 ec_dbg_evt("Event stopped");
1253
1254 acpi_ec_check_event(ec);
1255}
1256
1257static void acpi_ec_handle_interrupt(struct acpi_ec *ec)
1258{
1259 unsigned long flags;
1260
1261 spin_lock_irqsave(&ec->lock, flags);
1262 advance_transaction(ec);
1263 spin_unlock_irqrestore(&ec->lock, flags);
1264}
1265
1266static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1267 u32 gpe_number, void *data)
1268{
1269 acpi_ec_handle_interrupt(data);
1270 return ACPI_INTERRUPT_HANDLED;
1271}
1272
1273static irqreturn_t acpi_ec_irq_handler(int irq, void *data)
1274{
1275 acpi_ec_handle_interrupt(data);
1276 return IRQ_HANDLED;
1277}
1278
1279
1280
1281
1282
1283static acpi_status
1284acpi_ec_space_handler(u32 function, acpi_physical_address address,
1285 u32 bits, u64 *value64,
1286 void *handler_context, void *region_context)
1287{
1288 struct acpi_ec *ec = handler_context;
1289 int result = 0, i, bytes = bits / 8;
1290 u8 *value = (u8 *)value64;
1291
1292 if ((address > 0xFF) || !value || !handler_context)
1293 return AE_BAD_PARAMETER;
1294
1295 if (function != ACPI_READ && function != ACPI_WRITE)
1296 return AE_BAD_PARAMETER;
1297
1298 if (ec->busy_polling || bits > 8)
1299 acpi_ec_burst_enable(ec);
1300
1301 for (i = 0; i < bytes; ++i, ++address, ++value)
1302 result = (function == ACPI_READ) ?
1303 acpi_ec_read(ec, address, value) :
1304 acpi_ec_write(ec, address, *value);
1305
1306 if (ec->busy_polling || bits > 8)
1307 acpi_ec_burst_disable(ec);
1308
1309 switch (result) {
1310 case -EINVAL:
1311 return AE_BAD_PARAMETER;
1312 case -ENODEV:
1313 return AE_NOT_FOUND;
1314 case -ETIME:
1315 return AE_TIME;
1316 default:
1317 return AE_OK;
1318 }
1319}
1320
1321
1322
1323
1324
1325static acpi_status
1326ec_parse_io_ports(struct acpi_resource *resource, void *context);
1327
1328static void acpi_ec_free(struct acpi_ec *ec)
1329{
1330 if (first_ec == ec)
1331 first_ec = NULL;
1332 if (boot_ec == ec)
1333 boot_ec = NULL;
1334 kfree(ec);
1335}
1336
1337static struct acpi_ec *acpi_ec_alloc(void)
1338{
1339 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
1340
1341 if (!ec)
1342 return NULL;
1343 mutex_init(&ec->mutex);
1344 init_waitqueue_head(&ec->wait);
1345 INIT_LIST_HEAD(&ec->list);
1346 spin_lock_init(&ec->lock);
1347 INIT_WORK(&ec->work, acpi_ec_event_handler);
1348 ec->timestamp = jiffies;
1349 ec->busy_polling = true;
1350 ec->polling_guard = 0;
1351 ec->gpe = -1;
1352 ec->irq = -1;
1353 return ec;
1354}
1355
1356static acpi_status
1357acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1358 void *context, void **return_value)
1359{
1360 char node_name[5];
1361 struct acpi_buffer buffer = { sizeof(node_name), node_name };
1362 struct acpi_ec *ec = context;
1363 int value = 0;
1364 acpi_status status;
1365
1366 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1367
1368 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
1369 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
1370 return AE_OK;
1371}
1372
1373static acpi_status
1374ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
1375{
1376 acpi_status status;
1377 unsigned long long tmp = 0;
1378 struct acpi_ec *ec = context;
1379
1380
1381 ec->command_addr = ec->data_addr = 0;
1382
1383 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1384 ec_parse_io_ports, ec);
1385 if (ACPI_FAILURE(status))
1386 return status;
1387 if (ec->data_addr == 0 || ec->command_addr == 0)
1388 return AE_OK;
1389
1390 if (boot_ec && boot_ec_is_ecdt && EC_FLAGS_IGNORE_DSDT_GPE) {
1391
1392
1393
1394
1395 ec->gpe = boot_ec->gpe;
1396 } else {
1397
1398
1399 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1400 if (ACPI_SUCCESS(status))
1401 ec->gpe = tmp;
1402
1403
1404
1405
1406
1407 }
1408
1409 tmp = 0;
1410 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1411 ec->global_lock = tmp;
1412 ec->handle = handle;
1413 return AE_CTRL_TERMINATE;
1414}
1415
1416static bool install_gpe_event_handler(struct acpi_ec *ec)
1417{
1418 acpi_status status;
1419
1420 status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1421 ACPI_GPE_EDGE_TRIGGERED,
1422 &acpi_ec_gpe_handler, ec);
1423 if (ACPI_FAILURE(status))
1424 return false;
1425
1426 if (test_bit(EC_FLAGS_STARTED, &ec->flags) && ec->reference_count >= 1)
1427 acpi_ec_enable_gpe(ec, true);
1428
1429 return true;
1430}
1431
1432static bool install_gpio_irq_event_handler(struct acpi_ec *ec)
1433{
1434 return request_irq(ec->irq, acpi_ec_irq_handler, IRQF_SHARED,
1435 "ACPI EC", ec) >= 0;
1436}
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454static int ec_install_handlers(struct acpi_ec *ec, struct acpi_device *device)
1455{
1456 acpi_status status;
1457
1458 acpi_ec_start(ec, false);
1459
1460 if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1461 acpi_ec_enter_noirq(ec);
1462 status = acpi_install_address_space_handler(ec->handle,
1463 ACPI_ADR_SPACE_EC,
1464 &acpi_ec_space_handler,
1465 NULL, ec);
1466 if (ACPI_FAILURE(status)) {
1467 acpi_ec_stop(ec, false);
1468 return -ENODEV;
1469 }
1470 set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1471 }
1472
1473 if (!device)
1474 return 0;
1475
1476 if (ec->gpe < 0) {
1477
1478 int irq = acpi_dev_gpio_irq_get(device, 0);
1479
1480
1481
1482
1483 if (irq == -EPROBE_DEFER)
1484 return -EPROBE_DEFER;
1485 else if (irq >= 0)
1486 ec->irq = irq;
1487 }
1488
1489 if (!test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1490
1491 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1492 acpi_ec_register_query_methods,
1493 NULL, ec, NULL);
1494 set_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1495 }
1496 if (!test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1497 bool ready = false;
1498
1499 if (ec->gpe >= 0)
1500 ready = install_gpe_event_handler(ec);
1501 else if (ec->irq >= 0)
1502 ready = install_gpio_irq_event_handler(ec);
1503
1504 if (ready) {
1505 set_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1506 acpi_ec_leave_noirq(ec);
1507 }
1508
1509
1510
1511
1512 }
1513
1514 acpi_ec_enable_event(ec);
1515
1516 return 0;
1517}
1518
1519static void ec_remove_handlers(struct acpi_ec *ec)
1520{
1521 if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1522 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1523 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1524 pr_err("failed to remove space handler\n");
1525 clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1526 }
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539 acpi_ec_stop(ec, false);
1540
1541 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1542 if (ec->gpe >= 0 &&
1543 ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1544 &acpi_ec_gpe_handler)))
1545 pr_err("failed to remove gpe handler\n");
1546
1547 if (ec->irq >= 0)
1548 free_irq(ec->irq, ec);
1549
1550 clear_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1551 }
1552 if (test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1553 acpi_ec_remove_query_handlers(ec, true, 0);
1554 clear_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1555 }
1556}
1557
1558static int acpi_ec_setup(struct acpi_ec *ec, struct acpi_device *device)
1559{
1560 int ret;
1561
1562 ret = ec_install_handlers(ec, device);
1563 if (ret)
1564 return ret;
1565
1566
1567 if (!first_ec)
1568 first_ec = ec;
1569
1570 pr_info("EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", ec->command_addr,
1571 ec->data_addr);
1572
1573 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1574 if (ec->gpe >= 0)
1575 pr_info("GPE=0x%x\n", ec->gpe);
1576 else
1577 pr_info("IRQ=%d\n", ec->irq);
1578 }
1579
1580 return ret;
1581}
1582
1583static int acpi_ec_add(struct acpi_device *device)
1584{
1585 struct acpi_ec *ec;
1586 int ret;
1587
1588 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1589 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1590
1591 if (boot_ec && (boot_ec->handle == device->handle ||
1592 !strcmp(acpi_device_hid(device), ACPI_ECDT_HID))) {
1593
1594 ec = boot_ec;
1595 } else {
1596 acpi_status status;
1597
1598 ec = acpi_ec_alloc();
1599 if (!ec)
1600 return -ENOMEM;
1601
1602 status = ec_parse_device(device->handle, 0, ec, NULL);
1603 if (status != AE_CTRL_TERMINATE) {
1604 ret = -EINVAL;
1605 goto err;
1606 }
1607
1608 if (boot_ec && ec->command_addr == boot_ec->command_addr &&
1609 ec->data_addr == boot_ec->data_addr) {
1610
1611
1612
1613
1614
1615
1616 boot_ec->handle = ec->handle;
1617 acpi_handle_debug(ec->handle, "duplicated.\n");
1618 acpi_ec_free(ec);
1619 ec = boot_ec;
1620 }
1621 }
1622
1623 ret = acpi_ec_setup(ec, device);
1624 if (ret)
1625 goto err;
1626
1627 if (ec == boot_ec)
1628 acpi_handle_info(boot_ec->handle,
1629 "Boot %s EC initialization complete\n",
1630 boot_ec_is_ecdt ? "ECDT" : "DSDT");
1631
1632 acpi_handle_info(ec->handle,
1633 "EC: Used to handle transactions and events\n");
1634
1635 device->driver_data = ec;
1636
1637 ret = !!request_region(ec->data_addr, 1, "EC data");
1638 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1639 ret = !!request_region(ec->command_addr, 1, "EC cmd");
1640 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1641
1642
1643 acpi_walk_dep_device_list(ec->handle);
1644
1645 acpi_handle_debug(ec->handle, "enumerated.\n");
1646 return 0;
1647
1648err:
1649 if (ec != boot_ec)
1650 acpi_ec_free(ec);
1651
1652 return ret;
1653}
1654
1655static int acpi_ec_remove(struct acpi_device *device)
1656{
1657 struct acpi_ec *ec;
1658
1659 if (!device)
1660 return -EINVAL;
1661
1662 ec = acpi_driver_data(device);
1663 release_region(ec->data_addr, 1);
1664 release_region(ec->command_addr, 1);
1665 device->driver_data = NULL;
1666 if (ec != boot_ec) {
1667 ec_remove_handlers(ec);
1668 acpi_ec_free(ec);
1669 }
1670 return 0;
1671}
1672
1673static acpi_status
1674ec_parse_io_ports(struct acpi_resource *resource, void *context)
1675{
1676 struct acpi_ec *ec = context;
1677
1678 if (resource->type != ACPI_RESOURCE_TYPE_IO)
1679 return AE_OK;
1680
1681
1682
1683
1684
1685
1686 if (ec->data_addr == 0)
1687 ec->data_addr = resource->data.io.minimum;
1688 else if (ec->command_addr == 0)
1689 ec->command_addr = resource->data.io.minimum;
1690 else
1691 return AE_CTRL_TERMINATE;
1692
1693 return AE_OK;
1694}
1695
1696static const struct acpi_device_id ec_device_ids[] = {
1697 {"PNP0C09", 0},
1698 {ACPI_ECDT_HID, 0},
1699 {"", 0},
1700};
1701
1702
1703
1704
1705
1706
1707void __init acpi_ec_dsdt_probe(void)
1708{
1709 struct acpi_ec *ec;
1710 acpi_status status;
1711 int ret;
1712
1713
1714
1715
1716
1717
1718
1719 if (boot_ec)
1720 return;
1721
1722 ec = acpi_ec_alloc();
1723 if (!ec)
1724 return;
1725
1726
1727
1728
1729
1730 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
1731 if (ACPI_FAILURE(status) || !ec->handle) {
1732 acpi_ec_free(ec);
1733 return;
1734 }
1735
1736
1737
1738
1739
1740
1741
1742
1743 ret = acpi_ec_setup(ec, NULL);
1744 if (ret) {
1745 acpi_ec_free(ec);
1746 return;
1747 }
1748
1749 boot_ec = ec;
1750
1751 acpi_handle_info(ec->handle,
1752 "Boot DSDT EC used to handle transactions\n");
1753}
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768static void __init acpi_ec_ecdt_start(void)
1769{
1770 struct acpi_table_ecdt *ecdt_ptr;
1771 acpi_handle handle;
1772 acpi_status status;
1773
1774
1775 if (!boot_ec || boot_ec->handle != ACPI_ROOT_OBJECT)
1776 return;
1777
1778
1779 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1780 (struct acpi_table_header **)&ecdt_ptr);
1781 if (ACPI_FAILURE(status))
1782 return;
1783
1784 status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1785 if (ACPI_SUCCESS(status)) {
1786 boot_ec->handle = handle;
1787
1788
1789 acpi_bus_register_early_device(ACPI_BUS_TYPE_ECDT_EC);
1790 }
1791
1792 acpi_put_table((struct acpi_table_header *)ecdt_ptr);
1793}
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812static int ec_clear_on_resume(const struct dmi_system_id *id)
1813{
1814 pr_debug("Detected system needing EC poll on resume.\n");
1815 EC_FLAGS_CLEAR_ON_RESUME = 1;
1816 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1817 return 0;
1818}
1819
1820
1821
1822
1823
1824
1825static int ec_correct_ecdt(const struct dmi_system_id *id)
1826{
1827 pr_debug("Detected system needing ECDT address correction.\n");
1828 EC_FLAGS_CORRECT_ECDT = 1;
1829 return 0;
1830}
1831
1832
1833
1834
1835
1836
1837static int ec_honor_ecdt_gpe(const struct dmi_system_id *id)
1838{
1839 pr_debug("Detected system needing ignore DSDT GPE setting.\n");
1840 EC_FLAGS_IGNORE_DSDT_GPE = 1;
1841 return 0;
1842}
1843
1844static const struct dmi_system_id ec_dmi_table[] __initconst = {
1845 {
1846 ec_correct_ecdt, "MSI MS-171F", {
1847 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1848 DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
1849 {
1850 ec_honor_ecdt_gpe, "ASUS FX502VD", {
1851 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1852 DMI_MATCH(DMI_PRODUCT_NAME, "FX502VD"),}, NULL},
1853 {
1854 ec_honor_ecdt_gpe, "ASUS FX502VE", {
1855 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1856 DMI_MATCH(DMI_PRODUCT_NAME, "FX502VE"),}, NULL},
1857 {
1858 ec_honor_ecdt_gpe, "ASUS GL702VMK", {
1859 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1860 DMI_MATCH(DMI_PRODUCT_NAME, "GL702VMK"),}, NULL},
1861 {
1862 ec_honor_ecdt_gpe, "ASUS X550VXK", {
1863 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1864 DMI_MATCH(DMI_PRODUCT_NAME, "X550VXK"),}, NULL},
1865 {
1866 ec_honor_ecdt_gpe, "ASUS X580VD", {
1867 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1868 DMI_MATCH(DMI_PRODUCT_NAME, "X580VD"),}, NULL},
1869 {
1870 ec_clear_on_resume, "Samsung hardware", {
1871 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
1872 {},
1873};
1874
1875void __init acpi_ec_ecdt_probe(void)
1876{
1877 struct acpi_table_ecdt *ecdt_ptr;
1878 struct acpi_ec *ec;
1879 acpi_status status;
1880 int ret;
1881
1882
1883 dmi_check_system(ec_dmi_table);
1884 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1885 (struct acpi_table_header **)&ecdt_ptr);
1886 if (ACPI_FAILURE(status))
1887 return;
1888
1889 if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1890
1891
1892
1893
1894 goto out;
1895 }
1896
1897 ec = acpi_ec_alloc();
1898 if (!ec)
1899 goto out;
1900
1901 if (EC_FLAGS_CORRECT_ECDT) {
1902 ec->command_addr = ecdt_ptr->data.address;
1903 ec->data_addr = ecdt_ptr->control.address;
1904 } else {
1905 ec->command_addr = ecdt_ptr->control.address;
1906 ec->data_addr = ecdt_ptr->data.address;
1907 }
1908
1909
1910
1911
1912
1913 if (!acpi_gbl_reduced_hardware)
1914 ec->gpe = ecdt_ptr->gpe;
1915
1916 ec->handle = ACPI_ROOT_OBJECT;
1917
1918
1919
1920
1921
1922 ret = acpi_ec_setup(ec, NULL);
1923 if (ret) {
1924 acpi_ec_free(ec);
1925 goto out;
1926 }
1927
1928 boot_ec = ec;
1929 boot_ec_is_ecdt = true;
1930
1931 pr_info("Boot ECDT EC used to handle transactions\n");
1932
1933out:
1934 acpi_put_table((struct acpi_table_header *)ecdt_ptr);
1935}
1936
1937#ifdef CONFIG_PM_SLEEP
1938static int acpi_ec_suspend(struct device *dev)
1939{
1940 struct acpi_ec *ec =
1941 acpi_driver_data(to_acpi_device(dev));
1942
1943 if (!pm_suspend_no_platform() && ec_freeze_events)
1944 acpi_ec_disable_event(ec);
1945 return 0;
1946}
1947
1948static int acpi_ec_suspend_noirq(struct device *dev)
1949{
1950 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1951
1952
1953
1954
1955
1956 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1957 ec->gpe >= 0 && ec->reference_count >= 1)
1958 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1959
1960 acpi_ec_enter_noirq(ec);
1961
1962 return 0;
1963}
1964
1965static int acpi_ec_resume_noirq(struct device *dev)
1966{
1967 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1968
1969 acpi_ec_leave_noirq(ec);
1970
1971 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1972 ec->gpe >= 0 && ec->reference_count >= 1)
1973 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
1974
1975 return 0;
1976}
1977
1978static int acpi_ec_resume(struct device *dev)
1979{
1980 struct acpi_ec *ec =
1981 acpi_driver_data(to_acpi_device(dev));
1982
1983 acpi_ec_enable_event(ec);
1984 return 0;
1985}
1986
1987void acpi_ec_mark_gpe_for_wake(void)
1988{
1989 if (first_ec && !ec_no_wakeup)
1990 acpi_mark_gpe_for_wake(NULL, first_ec->gpe);
1991}
1992EXPORT_SYMBOL_GPL(acpi_ec_mark_gpe_for_wake);
1993
1994void acpi_ec_set_gpe_wake_mask(u8 action)
1995{
1996 if (pm_suspend_no_platform() && first_ec && !ec_no_wakeup)
1997 acpi_set_gpe_wake_mask(NULL, first_ec->gpe, action);
1998}
1999
2000bool acpi_ec_dispatch_gpe(void)
2001{
2002 u32 ret;
2003
2004 if (!first_ec)
2005 return acpi_any_gpe_status_set(U32_MAX);
2006
2007
2008
2009
2010
2011 if (acpi_any_gpe_status_set(first_ec->gpe))
2012 return true;
2013
2014 if (ec_no_wakeup)
2015 return false;
2016
2017
2018
2019
2020
2021 ret = acpi_dispatch_gpe(NULL, first_ec->gpe);
2022 if (ret == ACPI_INTERRUPT_HANDLED) {
2023 pm_pr_dbg("ACPI EC GPE dispatched\n");
2024
2025
2026 acpi_ec_flush_work();
2027 }
2028
2029 return false;
2030}
2031#endif
2032
2033static const struct dev_pm_ops acpi_ec_pm = {
2034 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
2035 SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
2036};
2037
2038static int param_set_event_clearing(const char *val,
2039 const struct kernel_param *kp)
2040{
2041 int result = 0;
2042
2043 if (!strncmp(val, "status", sizeof("status") - 1)) {
2044 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
2045 pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
2046 } else if (!strncmp(val, "query", sizeof("query") - 1)) {
2047 ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
2048 pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
2049 } else if (!strncmp(val, "event", sizeof("event") - 1)) {
2050 ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
2051 pr_info("Assuming SCI_EVT clearing on event reads\n");
2052 } else
2053 result = -EINVAL;
2054 return result;
2055}
2056
2057static int param_get_event_clearing(char *buffer,
2058 const struct kernel_param *kp)
2059{
2060 switch (ec_event_clearing) {
2061 case ACPI_EC_EVT_TIMING_STATUS:
2062 return sprintf(buffer, "status\n");
2063 case ACPI_EC_EVT_TIMING_QUERY:
2064 return sprintf(buffer, "query\n");
2065 case ACPI_EC_EVT_TIMING_EVENT:
2066 return sprintf(buffer, "event\n");
2067 default:
2068 return sprintf(buffer, "invalid\n");
2069 }
2070 return 0;
2071}
2072
2073module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
2074 NULL, 0644);
2075MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
2076
2077static struct acpi_driver acpi_ec_driver = {
2078 .name = "ec",
2079 .class = ACPI_EC_CLASS,
2080 .ids = ec_device_ids,
2081 .ops = {
2082 .add = acpi_ec_add,
2083 .remove = acpi_ec_remove,
2084 },
2085 .drv.pm = &acpi_ec_pm,
2086};
2087
2088static void acpi_ec_destroy_workqueues(void)
2089{
2090 if (ec_wq) {
2091 destroy_workqueue(ec_wq);
2092 ec_wq = NULL;
2093 }
2094 if (ec_query_wq) {
2095 destroy_workqueue(ec_query_wq);
2096 ec_query_wq = NULL;
2097 }
2098}
2099
2100static int acpi_ec_init_workqueues(void)
2101{
2102 if (!ec_wq)
2103 ec_wq = alloc_ordered_workqueue("kec", 0);
2104
2105 if (!ec_query_wq)
2106 ec_query_wq = alloc_workqueue("kec_query", 0, ec_max_queries);
2107
2108 if (!ec_wq || !ec_query_wq) {
2109 acpi_ec_destroy_workqueues();
2110 return -ENODEV;
2111 }
2112 return 0;
2113}
2114
2115static const struct dmi_system_id acpi_ec_no_wakeup[] = {
2116 {
2117 .ident = "Thinkpad X1 Carbon 6th",
2118 .matches = {
2119 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2120 DMI_MATCH(DMI_PRODUCT_FAMILY, "Thinkpad X1 Carbon 6th"),
2121 },
2122 },
2123 {
2124 .ident = "ThinkPad X1 Carbon 6th",
2125 .matches = {
2126 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2127 DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Carbon 6th"),
2128 },
2129 },
2130 {
2131 .ident = "ThinkPad X1 Yoga 3rd",
2132 .matches = {
2133 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2134 DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Yoga 3rd"),
2135 },
2136 },
2137 { },
2138};
2139
2140void __init acpi_ec_init(void)
2141{
2142 int result;
2143
2144 result = acpi_ec_init_workqueues();
2145 if (result)
2146 return;
2147
2148
2149
2150
2151
2152 if (dmi_check_system(acpi_ec_no_wakeup)) {
2153 ec_no_wakeup = true;
2154 pr_debug("Disabling EC wakeup on suspend-to-idle\n");
2155 }
2156
2157
2158 acpi_bus_register_driver(&acpi_ec_driver);
2159
2160 acpi_ec_ecdt_start();
2161}
2162
2163
2164#if 0
2165static void __exit acpi_ec_exit(void)
2166{
2167
2168 acpi_bus_unregister_driver(&acpi_ec_driver);
2169 acpi_ec_destroy_workqueues();
2170}
2171#endif
2172