c24235d8fb52636dc05c2deb78d2bc4574c50ad9
[muen/linux.git] / drivers / acpi / ec.c
1 /*
2  *  ec.c - ACPI Embedded Controller Driver (v3)
3  *
4  *  Copyright (C) 2001-2015 Intel Corporation
5  *    Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
6  *            2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
7  *            2006       Denis Sadykov <denis.m.sadykov@intel.com>
8  *            2004       Luming Yu <luming.yu@intel.com>
9  *            2001, 2002 Andy Grover <andrew.grover@intel.com>
10  *            2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
11  *  Copyright (C) 2008      Alexey Starikovskiy <astarikovskiy@suse.de>
12  *
13  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
14  *
15  *  This program is free software; you can redistribute it and/or modify
16  *  it under the terms of the GNU General Public License as published by
17  *  the Free Software Foundation; either version 2 of the License, or (at
18  *  your option) any later version.
19  *
20  *  This program is distributed in the hope that it will be useful, but
21  *  WITHOUT ANY WARRANTY; without even the implied warranty of
22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23  *  General Public License for more details.
24  *
25  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26  */
27
28 /* Uncomment next line to get verbose printout */
29 /* #define DEBUG */
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 /* EC status register */
52 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
53 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
54 #define ACPI_EC_FLAG_CMD        0x08    /* Input buffer contains a command */
55 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
56 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
57
58 /*
59  * The SCI_EVT clearing timing is not defined by the ACPI specification.
60  * This leads to lots of practical timing issues for the host EC driver.
61  * The following variations are defined (from the target EC firmware's
62  * perspective):
63  * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
64  *         target can clear SCI_EVT at any time so long as the host can see
65  *         the indication by reading the status register (EC_SC). So the
66  *         host should re-check SCI_EVT after the first time the SCI_EVT
67  *         indication is seen, which is the same time the query request
68  *         (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
69  *         at any later time could indicate another event. Normally such
70  *         kind of EC firmware has implemented an event queue and will
71  *         return 0x00 to indicate "no outstanding event".
72  * QUERY: After seeing the query request (QR_EC) written to the command
73  *        register (EC_CMD) by the host and having prepared the responding
74  *        event value in the data register (EC_DATA), the target can safely
75  *        clear SCI_EVT because the target can confirm that the current
76  *        event is being handled by the host. The host then should check
77  *        SCI_EVT right after reading the event response from the data
78  *        register (EC_DATA).
79  * EVENT: After seeing the event response read from the data register
80  *        (EC_DATA) by the host, the target can clear SCI_EVT. As the
81  *        target requires time to notice the change in the data register
82  *        (EC_DATA), the host may be required to wait additional guarding
83  *        time before checking the SCI_EVT again. Such guarding may not be
84  *        necessary if the host is notified via another IRQ.
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 /* EC commands */
91 enum 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     /* Wait 500ms max. during EC ops */
100 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
101 #define ACPI_EC_UDELAY_POLL     550     /* Wait 1ms for EC transaction polling */
102 #define ACPI_EC_CLEAR_MAX       100     /* Maximum number of events to query
103                                          * when trying to clear the EC */
104 #define ACPI_EC_MAX_QUERIES     16      /* Maximum number of parallel queries */
105
106 enum {
107         EC_FLAGS_QUERY_ENABLED,         /* Query is enabled */
108         EC_FLAGS_QUERY_PENDING,         /* Query is pending */
109         EC_FLAGS_QUERY_GUARDING,        /* Guard for SCI_EVT check */
110         EC_FLAGS_GPE_HANDLER_INSTALLED, /* GPE handler installed */
111         EC_FLAGS_EC_HANDLER_INSTALLED,  /* OpReg handler installed */
112         EC_FLAGS_EVT_HANDLER_INSTALLED, /* _Qxx handlers installed */
113         EC_FLAGS_STARTED,               /* Driver is started */
114         EC_FLAGS_STOPPED,               /* Driver is stopped */
115         EC_FLAGS_COMMAND_STORM,         /* GPE storms occurred to the
116                                          * current command processing */
117 };
118
119 #define ACPI_EC_COMMAND_POLL            0x01 /* Available for command byte */
120 #define ACPI_EC_COMMAND_COMPLETE        0x02 /* Completed last byte */
121
122 /* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
123 static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
124 module_param(ec_delay, uint, 0644);
125 MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
126
127 static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
128 module_param(ec_max_queries, uint, 0644);
129 MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
130
131 static bool ec_busy_polling __read_mostly;
132 module_param(ec_busy_polling, bool, 0644);
133 MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
134
135 static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
136 module_param(ec_polling_guard, uint, 0644);
137 MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
138
139 static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
140
141 /*
142  * If the number of false interrupts per one transaction exceeds
143  * this threshold, will think there is a GPE storm happened and
144  * will disable the GPE for normal transaction.
145  */
146 static unsigned int ec_storm_threshold  __read_mostly = 8;
147 module_param(ec_storm_threshold, uint, 0644);
148 MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
149
150 static bool ec_freeze_events __read_mostly = true;
151 module_param(ec_freeze_events, bool, 0644);
152 MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
153
154 struct 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
163 struct 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
175 struct acpi_ec_query {
176         struct transaction transaction;
177         struct work_struct work;
178         struct acpi_ec_query_handler *handler;
179 };
180
181 static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
182 static void advance_transaction(struct acpi_ec *ec);
183 static void acpi_ec_event_handler(struct work_struct *work);
184 static void acpi_ec_event_processor(struct work_struct *work);
185
186 struct acpi_ec *boot_ec, *first_ec;
187 EXPORT_SYMBOL(first_ec);
188 static bool boot_ec_is_ecdt = false;
189 static struct workqueue_struct *ec_query_wq;
190
191 static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
192 static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
193
194 /* --------------------------------------------------------------------------
195  *                           Logging/Debugging
196  * -------------------------------------------------------------------------- */
197
198 /*
199  * Splitters used by the developers to track the boundary of the EC
200  * handling processes.
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  *                           Device Flags
240  * -------------------------------------------------------------------------- */
241
242 static 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
248 static bool acpi_ec_event_enabled(struct acpi_ec *ec)
249 {
250         /*
251          * There is an OSPM early stage logic. During the early stages
252          * (boot/resume), OSPMs shouldn't enable the event handling, only
253          * the EC transactions are allowed to be performed.
254          */
255         if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
256                 return false;
257         /*
258          * However, disabling the event handling is experimental for late
259          * stage (suspend), and is controlled by the boot parameter of
260          * "ec_freeze_events":
261          * 1. true:  The EC event handling is disabled before entering
262          *           the noirq stage.
263          * 2. false: The EC event handling is automatically disabled as
264          *           soon as the EC driver is stopped.
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
272 static bool acpi_ec_flushed(struct acpi_ec *ec)
273 {
274         return ec->reference_count == 1;
275 }
276
277 /* --------------------------------------------------------------------------
278  *                           EC Registers
279  * -------------------------------------------------------------------------- */
280
281 static 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
296 static 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
305 static 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
312 static 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
320 static 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  *                           GPE Registers
342  * -------------------------------------------------------------------------- */
343
344 static 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
352 static 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                  * On some platforms, EN=1 writes cannot trigger GPE. So
363                  * software need to manually trigger a pseudo GPE event on
364                  * EN=1 writes.
365                  */
366                 ec_dbg_raw("Polling quirk");
367                 advance_transaction(ec);
368         }
369 }
370
371 static 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
381 static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
382 {
383         /*
384          * GPE STS is a W1C register, which means:
385          * 1. Software can clear it without worrying about clearing other
386          *    GPEs' STS bits when the hardware sets them in parallel.
387          * 2. As long as software can ensure only clearing it when it is
388          *    set, hardware won't set it in parallel.
389          * So software can clear GPE in any contexts.
390          * Warning: do not move the check into advance_transaction() as the
391          * EC commands will be sent without GPE raised.
392          */
393         if (!acpi_ec_is_gpe_raised(ec))
394                 return;
395         acpi_clear_gpe(NULL, ec->gpe);
396 }
397
398 /* --------------------------------------------------------------------------
399  *                           Transaction Management
400  * -------------------------------------------------------------------------- */
401
402 static 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
410 static 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
423 static 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
432 static 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  * acpi_ec_submit_flushable_request() - Increase the reference count unless
443  *                                      the flush operation is not in
444  *                                      progress
445  * @ec: the EC device
446  *
447  * This function must be used before taking a new action that should hold
448  * the reference count.  If this function returns false, then the action
449  * must be discarded or it will prevent the flush operation from being
450  * completed.
451  */
452 static 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
460 static 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
471 static 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
480 static 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
488 static 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
494 static 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
505 static 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
516 static void __acpi_ec_flush_event(struct acpi_ec *ec)
517 {
518         /*
519          * When ec_freeze_events is true, we need to flush events in
520          * the proper position before entering the noirq stage.
521          */
522         wait_event(ec->wait, acpi_ec_query_flushed(ec));
523         if (ec_query_wq)
524                 flush_workqueue(ec_query_wq);
525 }
526
527 static 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 /* CONFIG_PM_SLEEP */
537
538 static 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          * If firmware SCI_EVT clearing timing is "event", we actually
546          * don't know when the SCI_EVT will be cleared by firmware after
547          * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
548          * acceptable period.
549          *
550          * The guarding period begins when EC_FLAGS_QUERY_PENDING is
551          * flagged, which means SCI_EVT check has just been performed.
552          * But if the current transaction is ACPI_EC_COMMAND_QUERY, the
553          * guarding should have already been performed (via
554          * EC_FLAGS_QUERY_GUARDING) and should not be applied so that the
555          * ACPI_EC_COMMAND_QUERY transaction can be transitioned into
556          * ACPI_EC_COMMAND_POLL state immediately.
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
567 static 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
579 static 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
591 static 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
607 static 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          * By always clearing STS before handling all indications, we can
617          * ensure a hardware STS 0->1 change after this clearing can always
618          * trigger a GPE interrupt.
619          */
620         acpi_ec_clear_gpe(ec);
621         status = acpi_ec_read_status(ec);
622         t = ec->curr;
623         /*
624          * Another IRQ or a guarded polling mode advancement is detected,
625          * the next QR_EC submission is then allowed.
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         }
678 err:
679         /*
680          * If SCI bit is set, then don't think it's a false IRQ
681          * otherwise will take a not handled IRQ as a false one.
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                         /* Allow triggering on 0 threshold */
688                         if (t->irq_count == ec_storm_threshold)
689                                 acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM);
690                 }
691         }
692 out:
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
699 static 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
705 static 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         /* Ensure guarding period before polling EC status */
711         do {
712                 if (ec->busy_polling) {
713                         /* Perform busy polling */
714                         if (ec_transaction_completed(ec))
715                                 return 0;
716                         udelay(jiffies_to_usecs(guard));
717                 } else {
718                         /*
719                          * Perform wait polling
720                          * 1. Wait the transaction to be completed by the
721                          *    GPE handler after the transaction enters
722                          *    ACPI_EC_COMMAND_POLL state.
723                          * 2. A special guarding logic is also required
724                          *    for event clearing mode "event" before the
725                          *    transaction enters ACPI_EC_COMMAND_POLL
726                          *    state.
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
740 static int ec_poll(struct acpi_ec *ec)
741 {
742         unsigned long flags;
743         int repeat = 5; /* number of command restarts */
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
763 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
764                                         struct transaction *t)
765 {
766         unsigned long tmp;
767         int ret = 0;
768
769         /* start transaction */
770         spin_lock_irqsave(&ec->lock, tmp);
771         /* Enable GPE for command processing (IBF=0/OBF=1) */
772         if (!acpi_ec_submit_flushable_request(ec)) {
773                 ret = -EINVAL;
774                 goto unlock;
775         }
776         ec_dbg_ref(ec, "Increase command");
777         /* following two actions should be kept atomic */
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         /* Disable GPE for command processing (IBF=0/OBF=1) */
791         acpi_ec_complete_request(ec);
792         ec_dbg_ref(ec, "Decrease command");
793 unlock:
794         spin_unlock_irqrestore(&ec->lock, tmp);
795         return ret;
796 }
797
798 static 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);
821 unlock:
822         mutex_unlock(&ec->mutex);
823         return status;
824 }
825
826 static 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
836 static 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
846 static 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
859 static 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
869 int 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 }
885 EXPORT_SYMBOL(ec_read);
886
887 int 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 }
898 EXPORT_SYMBOL(ec_write);
899
900 int 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 }
913 EXPORT_SYMBOL(ec_transaction);
914
915 /* Get the handle to the EC device */
916 acpi_handle ec_get_handle(void)
917 {
918         if (!first_ec)
919                 return NULL;
920         return first_ec->handle;
921 }
922 EXPORT_SYMBOL(ec_get_handle);
923
924 static 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                 /* Enable GPE for event processing (SCI_EVT=1) */
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
941 static 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
952 static 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                 /* Disable GPE for event processing (SCI_EVT=1) */
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
976 static 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
987 static 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
998 void 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         /* Prevent transactions from being carried out */
1007         acpi_ec_stop(ec, true);
1008         mutex_unlock(&ec->mutex);
1009 }
1010
1011 void acpi_ec_unblock_transactions(void)
1012 {
1013         /*
1014          * Allow transactions to happen again (this function is called from
1015          * atomic context during wakeup, so we don't need to acquire the mutex).
1016          */
1017         if (first_ec)
1018                 acpi_ec_start(first_ec, true);
1019 }
1020
1021 /* --------------------------------------------------------------------------
1022                                 Event Management
1023    -------------------------------------------------------------------------- */
1024 static struct acpi_ec_query_handler *
1025 acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler)
1026 {
1027         if (handler)
1028                 kref_get(&handler->kref);
1029         return handler;
1030 }
1031
1032 static struct acpi_ec_query_handler *
1033 acpi_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
1049 static 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
1057 static 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
1062 int 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 }
1082 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1083
1084 static 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
1102 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1103 {
1104         acpi_ec_remove_query_handlers(ec, false, query_bit);
1105 }
1106 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
1107
1108 static 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
1124 static 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
1133 static 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
1147 static 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          * Query the EC to find out which _Qxx method we need to evaluate.
1159          * Note that successful completion of the query causes the ACPI_EC_SCI
1160          * bit to be cleared (and thus clearing the interrupt source).
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          * It is reported that _Qxx are evaluated in a parallel way on
1176          * Windows:
1177          * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1178          *
1179          * Put this log entry before schedule_work() in order to make
1180          * it appearing before any other log entries occurred during the
1181          * work queue execution.
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
1189 err_exit:
1190         if (result)
1191                 acpi_ec_delete_query(q);
1192         if (data)
1193                 *data = value;
1194         return result;
1195 }
1196
1197 static 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                          * Take care of the SCI_EVT unless no one else is
1206                          * taking care of it.
1207                          */
1208                         if (!ec->curr)
1209                                 advance_transaction(ec);
1210                         spin_unlock_irqrestore(&ec->lock, flags);
1211                 }
1212         }
1213 }
1214
1215 static 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                  * Before exit, make sure that this work item can be
1230                  * scheduled again. There might be QR_EC failures, leaving
1231                  * EC_FLAGS_QUERY_PENDING uncleared and preventing this work
1232                  * item from being scheduled again.
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
1247 static 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  *                           Address Space Management
1261  * -------------------------------------------------------------------------- */
1262
1263 static acpi_status
1264 acpi_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  *                             Driver Interface
1303  * -------------------------------------------------------------------------- */
1304
1305 static acpi_status
1306 ec_parse_io_ports(struct acpi_resource *resource, void *context);
1307
1308 static 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
1317 static 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
1334 static acpi_status
1335 acpi_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
1351 static acpi_status
1352 ec_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         /* clear addr values, ec_parse_io_ports depend on it */
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         /* Get GPE bit assignment (EC events). */
1367         /* TODO: Add support for _GPE returning a package */
1368         status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1369         if (ACPI_FAILURE(status))
1370                 return status;
1371         ec->gpe = tmp;
1372         /* Use the global lock for all EC transactions? */
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  * Note: This function returns an error code only when the address space
1382  *       handler is not installed, which means "not able to handle
1383  *       transactions".
1384  */
1385 static 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                                  * Maybe OS fails in evaluating the _REG
1401                                  * object. The AE_NOT_FOUND error will be
1402                                  * ignored and OS * continue to initialize
1403                                  * EC.
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                 /* Find and register all query methods */
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                 /* This is not fatal as we can poll EC events */
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                         /* EC is fully operational, allow queries */
1438                         acpi_ec_enable_event(ec);
1439                 }
1440         }
1441
1442         return 0;
1443 }
1444
1445 static 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          * Stops handling the EC transactions after removing the operation
1456          * region handler. This is required because _REG(DISCONNECT)
1457          * invoked during the removal can result in new EC transactions.
1458          *
1459          * Flushes the EC requests and thus disables the GPE before
1460          * removing the GPE handler. This is required by the current ACPICA
1461          * GPE core. ACPICA GPE core will automatically disable a GPE when
1462          * it is indicated but there is no way to handle it. So the drivers
1463          * must disable the GPEs prior to removing the GPE handlers.
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
1479 static 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         /* First EC capable of handling transactions */
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
1499 static 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          * Changing the ACPI handle results in a re-configuration of the
1506          * boot EC. And if it happens after the namespace initialization,
1507          * it causes _REG evaluations.
1508          */
1509         if (boot_ec && boot_ec->handle != handle)
1510                 ec_remove_handlers(boot_ec);
1511
1512         /* Unset old boot EC */
1513         if (boot_ec != ec)
1514                 acpi_ec_free(boot_ec);
1515
1516         /*
1517          * ECDT device creation is split into acpi_ec_ecdt_probe() and
1518          * acpi_ec_ecdt_start(). This function takes care of completing the
1519          * ECDT parsing logic as the handle update should be performed
1520          * between the installation/uninstallation of the handlers.
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         /* Set new boot EC */
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
1542 static 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
1561 static 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
1573 static 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         /* Reprobe devices depending on the EC */
1609         acpi_walk_dep_device_list(ec->handle);
1610         acpi_handle_debug(ec->handle, "enumerated.\n");
1611         return 0;
1612
1613 err_query:
1614         if (ec != boot_ec)
1615                 acpi_ec_remove_query_handlers(ec, true, 0);
1616 err_alloc:
1617         if (ec != boot_ec)
1618                 acpi_ec_free(ec);
1619         return ret;
1620 }
1621
1622 static 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
1640 static acpi_status
1641 ec_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          * The first address region returned is the data port, and
1650          * the second address region returned is the status/command
1651          * port.
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
1663 static const struct acpi_device_id ec_device_ids[] = {
1664         {"PNP0C09", 0},
1665         {"", 0},
1666 };
1667
1668 int __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          * At this point, the namespace is initialized, so start to find
1679          * the namespace objects.
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          * When the DSDT EC is available, always re-configure boot EC to
1689          * have _REG evaluated. _REG can only be evaluated after the
1690          * namespace initialization.
1691          * At this point, the GPE is not fully initialized, so do not to
1692          * handle the events.
1693          */
1694         ret = acpi_config_boot_ec(ec, ec->handle, false, false);
1695 error:
1696         if (ret)
1697                 acpi_ec_free(ec);
1698         return ret;
1699 }
1700
1701 /*
1702  * If the DSDT EC is not functioning, we still need to prepare a fully
1703  * functioning ECDT EC first in order to handle the events.
1704  * https://bugzilla.kernel.org/show_bug.cgi?id=115021
1705  */
1706 int __init acpi_ec_ecdt_start(void)
1707 {
1708         acpi_handle handle;
1709
1710         if (!boot_ec)
1711                 return -ENODEV;
1712         /*
1713          * The DSDT EC should have already been started in
1714          * acpi_ec_add().
1715          */
1716         if (!boot_ec_is_ecdt)
1717                 return -ENODEV;
1718
1719         /*
1720          * At this point, the namespace and the GPE is initialized, so
1721          * start to find the namespace objects and handle the events.
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  * Some EC firmware variations refuses to respond QR_EC when SCI_EVT is not
1731  * set, for which case, we complete the QR_EC without issuing it to the
1732  * firmware.
1733  * https://bugzilla.kernel.org/show_bug.cgi?id=82611
1734  * https://bugzilla.kernel.org/show_bug.cgi?id=97381
1735  */
1736 static 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  * Some ECDTs contain wrong register addresses.
1746  * MSI MS-171F
1747  * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1748  */
1749 static 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
1756 static 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
1764 int __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          * Generate a boot ec context
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                  * Asus X50GL:
1788                  * https://bugzilla.kernel.org/show_bug.cgi?id=11880
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          * At this point, the namespace is not initialized, so do not find
1805          * the namespace objects, or handle the events.
1806          */
1807         ret = acpi_config_boot_ec(ec, ACPI_ROOT_OBJECT, false, true);
1808 error:
1809         if (ret)
1810                 acpi_ec_free(ec);
1811         return ret;
1812 }
1813
1814 #ifdef CONFIG_PM_SLEEP
1815 static 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
1824 static 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
1833 static 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
1843 static 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
1853 static 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
1858 static 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
1876 static 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
1891 module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
1892                   NULL, 0644);
1893 MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
1894
1895 static 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
1906 static 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
1917 static 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
1925 int __init acpi_ec_init(void)
1926 {
1927         int result;
1928
1929         /* register workqueue for _Qxx evaluations */
1930         result = acpi_ec_query_init();
1931         if (result)
1932                 goto err_exit;
1933         /* Now register the driver for the EC */
1934         result = acpi_bus_register_driver(&acpi_ec_driver);
1935         if (result)
1936                 goto err_exit;
1937
1938 err_exit:
1939         if (result)
1940                 acpi_ec_query_exit();
1941         return result;
1942 }
1943
1944 /* EC driver currently not unloadable */
1945 #if 0
1946 static void __exit acpi_ec_exit(void)
1947 {
1948
1949         acpi_bus_unregister_driver(&acpi_ec_driver);
1950         acpi_ec_query_exit();
1951 }
1952 #endif  /* 0 */