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