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