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