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