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