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