projects / linux-2.6-block.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge tag 'probes-fixes-v6.16-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-block.git] / drivers / acpi / ec.c
... / ...
CommitLineData
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * ec.c - ACPI Embedded Controller Driver (v3)
4 *
5 * Copyright (C) 2001-2015 Intel Corporation
6 * Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
7 * 2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
8 * 2006 Denis Sadykov <denis.m.sadykov@intel.com>
9 * 2004 Luming Yu <luming.yu@intel.com>
10 * 2001, 2002 Andy Grover <andrew.grover@intel.com>
11 * 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
12 * Copyright (C) 2008 Alexey Starikovskiy <astarikovskiy@suse.de>
13 */
14
15/* Uncomment next line to get verbose printout */
16/* #define DEBUG */
17#define pr_fmt(fmt) "ACPI: EC: " fmt
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/types.h>
23#include <linux/delay.h>
24#include <linux/interrupt.h>
25#include <linux/list.h>
26#include <linux/printk.h>
27#include <linux/spinlock.h>
28#include <linux/slab.h>
29#include <linux/string.h>
30#include <linux/suspend.h>
31#include <linux/acpi.h>
32#include <linux/dmi.h>
33#include <asm/io.h>
34
35#include "internal.h"
36
37#define ACPI_EC_CLASS "embedded_controller"
38#define ACPI_EC_DEVICE_NAME "Embedded Controller"
39
40/* EC status register */
41#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
42#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
43#define ACPI_EC_FLAG_CMD 0x08 /* Input buffer contains a command */
44#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
45#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
46
47/*
48 * The SCI_EVT clearing timing is not defined by the ACPI specification.
49 * This leads to lots of practical timing issues for the host EC driver.
50 * The following variations are defined (from the target EC firmware's
51 * perspective):
52 * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
53 * target can clear SCI_EVT at any time so long as the host can see
54 * the indication by reading the status register (EC_SC). So the
55 * host should re-check SCI_EVT after the first time the SCI_EVT
56 * indication is seen, which is the same time the query request
57 * (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
58 * at any later time could indicate another event. Normally such
59 * kind of EC firmware has implemented an event queue and will
60 * return 0x00 to indicate "no outstanding event".
61 * QUERY: After seeing the query request (QR_EC) written to the command
62 * register (EC_CMD) by the host and having prepared the responding
63 * event value in the data register (EC_DATA), the target can safely
64 * clear SCI_EVT because the target can confirm that the current
65 * event is being handled by the host. The host then should check
66 * SCI_EVT right after reading the event response from the data
67 * register (EC_DATA).
68 * EVENT: After seeing the event response read from the data register
69 * (EC_DATA) by the host, the target can clear SCI_EVT. As the
70 * target requires time to notice the change in the data register
71 * (EC_DATA), the host may be required to wait additional guarding
72 * time before checking the SCI_EVT again. Such guarding may not be
73 * necessary if the host is notified via another IRQ.
74 */
75#define ACPI_EC_EVT_TIMING_STATUS 0x00
76#define ACPI_EC_EVT_TIMING_QUERY 0x01
77#define ACPI_EC_EVT_TIMING_EVENT 0x02
78
79/* EC commands */
80enum ec_command {
81 ACPI_EC_COMMAND_READ = 0x80,
82 ACPI_EC_COMMAND_WRITE = 0x81,
83 ACPI_EC_BURST_ENABLE = 0x82,
84 ACPI_EC_BURST_DISABLE = 0x83,
85 ACPI_EC_COMMAND_QUERY = 0x84,
86};
87
88#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
89#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
90#define ACPI_EC_UDELAY_POLL 550 /* Wait 1ms for EC transaction polling */
91#define ACPI_EC_CLEAR_MAX 100 /* Maximum number of events to query
92 * when trying to clear the EC */
93#define ACPI_EC_MAX_QUERIES 16 /* Maximum number of parallel queries */
94
95enum {
96 EC_FLAGS_QUERY_ENABLED, /* Query is enabled */
97 EC_FLAGS_EVENT_HANDLER_INSTALLED, /* Event handler installed */
98 EC_FLAGS_EC_HANDLER_INSTALLED, /* OpReg handler installed */
99 EC_FLAGS_EC_REG_CALLED, /* OpReg ACPI _REG method called */
100 EC_FLAGS_QUERY_METHODS_INSTALLED, /* _Qxx handlers installed */
101 EC_FLAGS_STARTED, /* Driver is started */
102 EC_FLAGS_STOPPED, /* Driver is stopped */
103 EC_FLAGS_EVENTS_MASKED, /* Events masked */
104};
105
106#define ACPI_EC_COMMAND_POLL 0x01 /* Available for command byte */
107#define ACPI_EC_COMMAND_COMPLETE 0x02 /* Completed last byte */
108
109/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
110static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
111module_param(ec_delay, uint, 0644);
112MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
113
114static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
115module_param(ec_max_queries, uint, 0644);
116MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
117
118static bool ec_busy_polling __read_mostly;
119module_param(ec_busy_polling, bool, 0644);
120MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
121
122static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
123module_param(ec_polling_guard, uint, 0644);
124MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
125
126static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
127
128/*
129 * If the number of false interrupts per one transaction exceeds
130 * this threshold, will think there is a GPE storm happened and
131 * will disable the GPE for normal transaction.
132 */
133static unsigned int ec_storm_threshold __read_mostly = 8;
134module_param(ec_storm_threshold, uint, 0644);
135MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
136
137static bool ec_freeze_events __read_mostly;
138module_param(ec_freeze_events, bool, 0644);
139MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
140
141static bool ec_no_wakeup __read_mostly;
142module_param(ec_no_wakeup, bool, 0644);
143MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
144
145struct acpi_ec_query_handler {
146 struct list_head node;
147 acpi_ec_query_func func;
148 acpi_handle handle;
149 void *data;
150 u8 query_bit;
151 struct kref kref;
152};
153
154struct transaction {
155 const u8 *wdata;
156 u8 *rdata;
157 unsigned short irq_count;
158 u8 command;
159 u8 wi;
160 u8 ri;
161 u8 wlen;
162 u8 rlen;
163 u8 flags;
164};
165
166struct acpi_ec_query {
167 struct transaction transaction;
168 struct work_struct work;
169 struct acpi_ec_query_handler *handler;
170 struct acpi_ec *ec;
171};
172
173static int acpi_ec_submit_query(struct acpi_ec *ec);
174static void advance_transaction(struct acpi_ec *ec, bool interrupt);
175static void acpi_ec_event_handler(struct work_struct *work);
176
177struct acpi_ec *first_ec;
178EXPORT_SYMBOL(first_ec);
179
180static struct acpi_ec *boot_ec;
181static bool boot_ec_is_ecdt;
182static struct workqueue_struct *ec_wq;
183static struct workqueue_struct *ec_query_wq;
184
185static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
186static int EC_FLAGS_TRUST_DSDT_GPE; /* Needs DSDT GPE as correction setting */
187static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
188
189/* --------------------------------------------------------------------------
190 * Logging/Debugging
191 * -------------------------------------------------------------------------- */
192
193/*
194 * Splitters used by the developers to track the boundary of the EC
195 * handling processes.
196 */
197#ifdef DEBUG
198#define EC_DBG_SEP " "
199#define EC_DBG_DRV "+++++"
200#define EC_DBG_STM "====="
201#define EC_DBG_REQ "*****"
202#define EC_DBG_EVT "#####"
203#else
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#endif
210
211#define ec_log_raw(fmt, ...) \
212 pr_info(fmt "\n", ##__VA_ARGS__)
213#define ec_dbg_raw(fmt, ...) \
214 pr_debug(fmt "\n", ##__VA_ARGS__)
215#define ec_log(filter, fmt, ...) \
216 ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
217#define ec_dbg(filter, fmt, ...) \
218 ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
219
220#define ec_log_drv(fmt, ...) \
221 ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
222#define ec_dbg_drv(fmt, ...) \
223 ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
224#define ec_dbg_stm(fmt, ...) \
225 ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
226#define ec_dbg_req(fmt, ...) \
227 ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
228#define ec_dbg_evt(fmt, ...) \
229 ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
230#define ec_dbg_ref(ec, fmt, ...) \
231 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
232
233/* --------------------------------------------------------------------------
234 * Device Flags
235 * -------------------------------------------------------------------------- */
236
237static bool acpi_ec_started(struct acpi_ec *ec)
238{
239 return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
240 !test_bit(EC_FLAGS_STOPPED, &ec->flags);
241}
242
243static bool acpi_ec_event_enabled(struct acpi_ec *ec)
244{
245 /*
246 * There is an OSPM early stage logic. During the early stages
247 * (boot/resume), OSPMs shouldn't enable the event handling, only
248 * the EC transactions are allowed to be performed.
249 */
250 if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
251 return false;
252 /*
253 * However, disabling the event handling is experimental for late
254 * stage (suspend), and is controlled by the boot parameter of
255 * "ec_freeze_events":
256 * 1. true: The EC event handling is disabled before entering
257 * the noirq stage.
258 * 2. false: The EC event handling is automatically disabled as
259 * soon as the EC driver is stopped.
260 */
261 if (ec_freeze_events)
262 return acpi_ec_started(ec);
263 else
264 return test_bit(EC_FLAGS_STARTED, &ec->flags);
265}
266
267static bool acpi_ec_flushed(struct acpi_ec *ec)
268{
269 return ec->reference_count == 1;
270}
271
272/* --------------------------------------------------------------------------
273 * EC Registers
274 * -------------------------------------------------------------------------- */
275
276static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
277{
278 u8 x = inb(ec->command_addr);
279
280 ec_dbg_raw("EC_SC(R) = 0x%2.2x "
281 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
282 x,
283 !!(x & ACPI_EC_FLAG_SCI),
284 !!(x & ACPI_EC_FLAG_BURST),
285 !!(x & ACPI_EC_FLAG_CMD),
286 !!(x & ACPI_EC_FLAG_IBF),
287 !!(x & ACPI_EC_FLAG_OBF));
288 return x;
289}
290
291static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
292{
293 u8 x = inb(ec->data_addr);
294
295 ec->timestamp = jiffies;
296 ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
297 return x;
298}
299
300static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
301{
302 ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
303 outb(command, ec->command_addr);
304 ec->timestamp = jiffies;
305}
306
307static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
308{
309 ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
310 outb(data, ec->data_addr);
311 ec->timestamp = jiffies;
312}
313
314#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
315static const char *acpi_ec_cmd_string(u8 cmd)
316{
317 switch (cmd) {
318 case 0x80:
319 return "RD_EC";
320 case 0x81:
321 return "WR_EC";
322 case 0x82:
323 return "BE_EC";
324 case 0x83:
325 return "BD_EC";
326 case 0x84:
327 return "QR_EC";
328 }
329 return "UNKNOWN";
330}
331#else
332#define acpi_ec_cmd_string(cmd) "UNDEF"
333#endif
334
335/* --------------------------------------------------------------------------
336 * GPE Registers
337 * -------------------------------------------------------------------------- */
338
339static inline bool acpi_ec_gpe_status_set(struct acpi_ec *ec)
340{
341 acpi_event_status gpe_status = 0;
342
343 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
344 return !!(gpe_status & ACPI_EVENT_FLAG_STATUS_SET);
345}
346
347static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
348{
349 if (open)
350 acpi_enable_gpe(NULL, ec->gpe);
351 else {
352 BUG_ON(ec->reference_count < 1);
353 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
354 }
355 if (acpi_ec_gpe_status_set(ec)) {
356 /*
357 * On some platforms, EN=1 writes cannot trigger GPE. So
358 * software need to manually trigger a pseudo GPE event on
359 * EN=1 writes.
360 */
361 ec_dbg_raw("Polling quirk");
362 advance_transaction(ec, false);
363 }
364}
365
366static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
367{
368 if (close)
369 acpi_disable_gpe(NULL, ec->gpe);
370 else {
371 BUG_ON(ec->reference_count < 1);
372 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
373 }
374}
375
376/* --------------------------------------------------------------------------
377 * Transaction Management
378 * -------------------------------------------------------------------------- */
379
380static void acpi_ec_submit_request(struct acpi_ec *ec)
381{
382 ec->reference_count++;
383 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
384 ec->gpe >= 0 && ec->reference_count == 1)
385 acpi_ec_enable_gpe(ec, true);
386}
387
388static void acpi_ec_complete_request(struct acpi_ec *ec)
389{
390 bool flushed = false;
391
392 ec->reference_count--;
393 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
394 ec->gpe >= 0 && ec->reference_count == 0)
395 acpi_ec_disable_gpe(ec, true);
396 flushed = acpi_ec_flushed(ec);
397 if (flushed)
398 wake_up(&ec->wait);
399}
400
401static void acpi_ec_mask_events(struct acpi_ec *ec)
402{
403 if (!test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
404 if (ec->gpe >= 0)
405 acpi_ec_disable_gpe(ec, false);
406 else
407 disable_irq_nosync(ec->irq);
408
409 ec_dbg_drv("Polling enabled");
410 set_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
411 }
412}
413
414static void acpi_ec_unmask_events(struct acpi_ec *ec)
415{
416 if (test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
417 clear_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
418 if (ec->gpe >= 0)
419 acpi_ec_enable_gpe(ec, false);
420 else
421 enable_irq(ec->irq);
422
423 ec_dbg_drv("Polling disabled");
424 }
425}
426
427/*
428 * acpi_ec_submit_flushable_request() - Increase the reference count unless
429 * the flush operation is not in
430 * progress
431 * @ec: the EC device
432 *
433 * This function must be used before taking a new action that should hold
434 * the reference count. If this function returns false, then the action
435 * must be discarded or it will prevent the flush operation from being
436 * completed.
437 */
438static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
439{
440 if (!acpi_ec_started(ec))
441 return false;
442 acpi_ec_submit_request(ec);
443 return true;
444}
445
446static void acpi_ec_submit_event(struct acpi_ec *ec)
447{
448 /*
449 * It is safe to mask the events here, because acpi_ec_close_event()
450 * will run at least once after this.
451 */
452 acpi_ec_mask_events(ec);
453 if (!acpi_ec_event_enabled(ec))
454 return;
455
456 if (ec->event_state != EC_EVENT_READY)
457 return;
458
459 ec_dbg_evt("Command(%s) submitted/blocked",
460 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
461
462 ec->event_state = EC_EVENT_IN_PROGRESS;
463 /*
464 * If events_to_process is greater than 0 at this point, the while ()
465 * loop in acpi_ec_event_handler() is still running and incrementing
466 * events_to_process will cause it to invoke acpi_ec_submit_query() once
467 * more, so it is not necessary to queue up the event work to start the
468 * same loop again.
469 */
470 if (ec->events_to_process++ > 0)
471 return;
472
473 ec->events_in_progress++;
474 queue_work(ec_wq, &ec->work);
475}
476
477static void acpi_ec_complete_event(struct acpi_ec *ec)
478{
479 if (ec->event_state == EC_EVENT_IN_PROGRESS)
480 ec->event_state = EC_EVENT_COMPLETE;
481}
482
483static void acpi_ec_close_event(struct acpi_ec *ec)
484{
485 if (ec->event_state != EC_EVENT_READY)
486 ec_dbg_evt("Command(%s) unblocked",
487 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
488
489 ec->event_state = EC_EVENT_READY;
490 acpi_ec_unmask_events(ec);
491}
492
493static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
494{
495 if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
496 ec_log_drv("event unblocked");
497 /*
498 * Unconditionally invoke this once after enabling the event
499 * handling mechanism to detect the pending events.
500 */
501 advance_transaction(ec, false);
502}
503
504static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
505{
506 if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
507 ec_log_drv("event blocked");
508}
509
510/*
511 * Process _Q events that might have accumulated in the EC.
512 * Run with locked ec mutex.
513 */
514static void acpi_ec_clear(struct acpi_ec *ec)
515{
516 int i;
517
518 for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
519 if (acpi_ec_submit_query(ec))
520 break;
521 }
522 if (unlikely(i == ACPI_EC_CLEAR_MAX))
523 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
524 else
525 pr_info("%d stale EC events cleared\n", i);
526}
527
528static void acpi_ec_enable_event(struct acpi_ec *ec)
529{
530 unsigned long flags;
531
532 spin_lock_irqsave(&ec->lock, flags);
533 if (acpi_ec_started(ec))
534 __acpi_ec_enable_event(ec);
535 spin_unlock_irqrestore(&ec->lock, flags);
536
537 /* Drain additional events if hardware requires that */
538 if (EC_FLAGS_CLEAR_ON_RESUME)
539 acpi_ec_clear(ec);
540}
541
542#ifdef CONFIG_PM_SLEEP
543static void __acpi_ec_flush_work(void)
544{
545 flush_workqueue(ec_wq); /* flush ec->work */
546 flush_workqueue(ec_query_wq); /* flush queries */
547}
548
549static void acpi_ec_disable_event(struct acpi_ec *ec)
550{
551 unsigned long flags;
552
553 spin_lock_irqsave(&ec->lock, flags);
554 __acpi_ec_disable_event(ec);
555 spin_unlock_irqrestore(&ec->lock, flags);
556
557 /*
558 * When ec_freeze_events is true, we need to flush events in
559 * the proper position before entering the noirq stage.
560 */
561 __acpi_ec_flush_work();
562}
563
564void acpi_ec_flush_work(void)
565{
566 /* Without ec_wq there is nothing to flush. */
567 if (!ec_wq)
568 return;
569
570 __acpi_ec_flush_work();
571}
572#endif /* CONFIG_PM_SLEEP */
573
574static bool acpi_ec_guard_event(struct acpi_ec *ec)
575{
576 unsigned long flags;
577 bool guarded;
578
579 spin_lock_irqsave(&ec->lock, flags);
580 /*
581 * If firmware SCI_EVT clearing timing is "event", we actually
582 * don't know when the SCI_EVT will be cleared by firmware after
583 * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
584 * acceptable period.
585 *
586 * The guarding period is applicable if the event state is not
587 * EC_EVENT_READY, but otherwise if the current transaction is of the
588 * ACPI_EC_COMMAND_QUERY type, the guarding should have elapsed already
589 * and it should not be applied to let the transaction transition into
590 * the ACPI_EC_COMMAND_POLL state immediately.
591 */
592 guarded = ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
593 ec->event_state != EC_EVENT_READY &&
594 (!ec->curr || ec->curr->command != ACPI_EC_COMMAND_QUERY);
595 spin_unlock_irqrestore(&ec->lock, flags);
596 return guarded;
597}
598
599static int ec_transaction_polled(struct acpi_ec *ec)
600{
601 unsigned long flags;
602 int ret = 0;
603
604 spin_lock_irqsave(&ec->lock, flags);
605 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
606 ret = 1;
607 spin_unlock_irqrestore(&ec->lock, flags);
608 return ret;
609}
610
611static int ec_transaction_completed(struct acpi_ec *ec)
612{
613 unsigned long flags;
614 int ret = 0;
615
616 spin_lock_irqsave(&ec->lock, flags);
617 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
618 ret = 1;
619 spin_unlock_irqrestore(&ec->lock, flags);
620 return ret;
621}
622
623static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
624{
625 ec->curr->flags |= flag;
626
627 if (ec->curr->command != ACPI_EC_COMMAND_QUERY)
628 return;
629
630 switch (ec_event_clearing) {
631 case ACPI_EC_EVT_TIMING_STATUS:
632 if (flag == ACPI_EC_COMMAND_POLL)
633 acpi_ec_close_event(ec);
634
635 return;
636
637 case ACPI_EC_EVT_TIMING_QUERY:
638 if (flag == ACPI_EC_COMMAND_COMPLETE)
639 acpi_ec_close_event(ec);
640
641 return;
642
643 case ACPI_EC_EVT_TIMING_EVENT:
644 if (flag == ACPI_EC_COMMAND_COMPLETE)
645 acpi_ec_complete_event(ec);
646 }
647}
648
649static void acpi_ec_spurious_interrupt(struct acpi_ec *ec, struct transaction *t)
650{
651 if (t->irq_count < ec_storm_threshold)
652 ++t->irq_count;
653
654 /* Trigger if the threshold is 0 too. */
655 if (t->irq_count == ec_storm_threshold)
656 acpi_ec_mask_events(ec);
657}
658
659static void advance_transaction(struct acpi_ec *ec, bool interrupt)
660{
661 struct transaction *t = ec->curr;
662 bool wakeup = false;
663 u8 status;
664
665 ec_dbg_stm("%s (%d)", interrupt ? "IRQ" : "TASK", smp_processor_id());
666
667 status = acpi_ec_read_status(ec);
668
669 /*
670 * Another IRQ or a guarded polling mode advancement is detected,
671 * the next QR_EC submission is then allowed.
672 */
673 if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
674 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
675 ec->event_state == EC_EVENT_COMPLETE)
676 acpi_ec_close_event(ec);
677
678 if (!t)
679 goto out;
680 }
681
682 if (t->flags & ACPI_EC_COMMAND_POLL) {
683 if (t->wlen > t->wi) {
684 if (!(status & ACPI_EC_FLAG_IBF))
685 acpi_ec_write_data(ec, t->wdata[t->wi++]);
686 else if (interrupt && !(status & ACPI_EC_FLAG_SCI))
687 acpi_ec_spurious_interrupt(ec, t);
688 } else if (t->rlen > t->ri) {
689 if (status & ACPI_EC_FLAG_OBF) {
690 t->rdata[t->ri++] = acpi_ec_read_data(ec);
691 if (t->rlen == t->ri) {
692 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
693 wakeup = true;
694 if (t->command == ACPI_EC_COMMAND_QUERY)
695 ec_dbg_evt("Command(%s) completed by hardware",
696 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
697 }
698 } else if (interrupt && !(status & ACPI_EC_FLAG_SCI)) {
699 acpi_ec_spurious_interrupt(ec, t);
700 }
701 } else if (t->wlen == t->wi && !(status & ACPI_EC_FLAG_IBF)) {
702 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
703 wakeup = true;
704 }
705 } else if (!(status & ACPI_EC_FLAG_IBF)) {
706 acpi_ec_write_cmd(ec, t->command);
707 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
708 }
709
710out:
711 if (status & ACPI_EC_FLAG_SCI)
712 acpi_ec_submit_event(ec);
713
714 if (wakeup && interrupt)
715 wake_up(&ec->wait);
716}
717
718static void start_transaction(struct acpi_ec *ec)
719{
720 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
721 ec->curr->flags = 0;
722}
723
724static int ec_guard(struct acpi_ec *ec)
725{
726 unsigned long guard = usecs_to_jiffies(ec->polling_guard);
727 unsigned long timeout = ec->timestamp + guard;
728
729 /* Ensure guarding period before polling EC status */
730 do {
731 if (ec->busy_polling) {
732 /* Perform busy polling */
733 if (ec_transaction_completed(ec))
734 return 0;
735 udelay(jiffies_to_usecs(guard));
736 } else {
737 /*
738 * Perform wait polling
739 * 1. Wait the transaction to be completed by the
740 * GPE handler after the transaction enters
741 * ACPI_EC_COMMAND_POLL state.
742 * 2. A special guarding logic is also required
743 * for event clearing mode "event" before the
744 * transaction enters ACPI_EC_COMMAND_POLL
745 * state.
746 */
747 if (!ec_transaction_polled(ec) &&
748 !acpi_ec_guard_event(ec))
749 break;
750 if (wait_event_timeout(ec->wait,
751 ec_transaction_completed(ec),
752 guard))
753 return 0;
754 }
755 } while (time_before(jiffies, timeout));
756 return -ETIME;
757}
758
759static int ec_poll(struct acpi_ec *ec)
760{
761 unsigned long flags;
762 int repeat = 5; /* number of command restarts */
763
764 while (repeat--) {
765 unsigned long delay = jiffies +
766 msecs_to_jiffies(ec_delay);
767 do {
768 if (!ec_guard(ec))
769 return 0;
770 spin_lock_irqsave(&ec->lock, flags);
771 advance_transaction(ec, false);
772 spin_unlock_irqrestore(&ec->lock, flags);
773 } while (time_before(jiffies, delay));
774 pr_debug("controller reset, restart transaction\n");
775 spin_lock_irqsave(&ec->lock, flags);
776 start_transaction(ec);
777 spin_unlock_irqrestore(&ec->lock, flags);
778 }
779 return -ETIME;
780}
781
782static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
783 struct transaction *t)
784{
785 unsigned long tmp;
786 int ret = 0;
787
788 if (t->rdata)
789 memset(t->rdata, 0, t->rlen);
790
791 /* start transaction */
792 spin_lock_irqsave(&ec->lock, tmp);
793 /* Enable GPE for command processing (IBF=0/OBF=1) */
794 if (!acpi_ec_submit_flushable_request(ec)) {
795 ret = -EINVAL;
796 goto unlock;
797 }
798 ec_dbg_ref(ec, "Increase command");
799 /* following two actions should be kept atomic */
800 ec->curr = t;
801 ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
802 start_transaction(ec);
803 spin_unlock_irqrestore(&ec->lock, tmp);
804
805 ret = ec_poll(ec);
806
807 spin_lock_irqsave(&ec->lock, tmp);
808 if (t->irq_count == ec_storm_threshold)
809 acpi_ec_unmask_events(ec);
810 ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
811 ec->curr = NULL;
812 /* Disable GPE for command processing (IBF=0/OBF=1) */
813 acpi_ec_complete_request(ec);
814 ec_dbg_ref(ec, "Decrease command");
815unlock:
816 spin_unlock_irqrestore(&ec->lock, tmp);
817 return ret;
818}
819
820static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
821{
822 int status;
823 u32 glk;
824
825 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
826 return -EINVAL;
827
828 mutex_lock(&ec->mutex);
829 if (ec->global_lock) {
830 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
831 if (ACPI_FAILURE(status)) {
832 status = -ENODEV;
833 goto unlock;
834 }
835 }
836
837 status = acpi_ec_transaction_unlocked(ec, t);
838
839 if (ec->global_lock)
840 acpi_release_global_lock(glk);
841unlock:
842 mutex_unlock(&ec->mutex);
843 return status;
844}
845
846static int acpi_ec_burst_enable(struct acpi_ec *ec)
847{
848 u8 d;
849 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
850 .wdata = NULL, .rdata = &d,
851 .wlen = 0, .rlen = 1};
852
853 return acpi_ec_transaction_unlocked(ec, &t);
854}
855
856static int acpi_ec_burst_disable(struct acpi_ec *ec)
857{
858 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
859 .wdata = NULL, .rdata = NULL,
860 .wlen = 0, .rlen = 0};
861
862 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
863 acpi_ec_transaction_unlocked(ec, &t) : 0;
864}
865
866static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
867{
868 int result;
869 u8 d;
870 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
871 .wdata = &address, .rdata = &d,
872 .wlen = 1, .rlen = 1};
873
874 result = acpi_ec_transaction(ec, &t);
875 *data = d;
876 return result;
877}
878
879static int acpi_ec_read_unlocked(struct acpi_ec *ec, u8 address, u8 *data)
880{
881 int result;
882 u8 d;
883 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
884 .wdata = &address, .rdata = &d,
885 .wlen = 1, .rlen = 1};
886
887 result = acpi_ec_transaction_unlocked(ec, &t);
888 *data = d;
889 return result;
890}
891
892static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
893{
894 u8 wdata[2] = { address, data };
895 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
896 .wdata = wdata, .rdata = NULL,
897 .wlen = 2, .rlen = 0};
898
899 return acpi_ec_transaction(ec, &t);
900}
901
902static int acpi_ec_write_unlocked(struct acpi_ec *ec, u8 address, u8 data)
903{
904 u8 wdata[2] = { address, data };
905 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
906 .wdata = wdata, .rdata = NULL,
907 .wlen = 2, .rlen = 0};
908
909 return acpi_ec_transaction_unlocked(ec, &t);
910}
911
912int ec_read(u8 addr, u8 *val)
913{
914 int err;
915 u8 temp_data;
916
917 if (!first_ec)
918 return -ENODEV;
919
920 err = acpi_ec_read(first_ec, addr, &temp_data);
921
922 if (!err) {
923 *val = temp_data;
924 return 0;
925 }
926 return err;
927}
928EXPORT_SYMBOL(ec_read);
929
930int ec_write(u8 addr, u8 val)
931{
932 if (!first_ec)
933 return -ENODEV;
934
935 return acpi_ec_write(first_ec, addr, val);
936}
937EXPORT_SYMBOL(ec_write);
938
939int ec_transaction(u8 command,
940 const u8 *wdata, unsigned wdata_len,
941 u8 *rdata, unsigned rdata_len)
942{
943 struct transaction t = {.command = command,
944 .wdata = wdata, .rdata = rdata,
945 .wlen = wdata_len, .rlen = rdata_len};
946
947 if (!first_ec)
948 return -ENODEV;
949
950 return acpi_ec_transaction(first_ec, &t);
951}
952EXPORT_SYMBOL(ec_transaction);
953
954/* Get the handle to the EC device */
955acpi_handle ec_get_handle(void)
956{
957 if (!first_ec)
958 return NULL;
959 return first_ec->handle;
960}
961EXPORT_SYMBOL(ec_get_handle);
962
963static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
964{
965 unsigned long flags;
966
967 spin_lock_irqsave(&ec->lock, flags);
968 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
969 ec_dbg_drv("Starting EC");
970 /* Enable GPE for event processing (SCI_EVT=1) */
971 if (!resuming) {
972 acpi_ec_submit_request(ec);
973 ec_dbg_ref(ec, "Increase driver");
974 }
975 ec_log_drv("EC started");
976 }
977 spin_unlock_irqrestore(&ec->lock, flags);
978}
979
980static bool acpi_ec_stopped(struct acpi_ec *ec)
981{
982 unsigned long flags;
983 bool flushed;
984
985 spin_lock_irqsave(&ec->lock, flags);
986 flushed = acpi_ec_flushed(ec);
987 spin_unlock_irqrestore(&ec->lock, flags);
988 return flushed;
989}
990
991static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
992{
993 unsigned long flags;
994
995 spin_lock_irqsave(&ec->lock, flags);
996 if (acpi_ec_started(ec)) {
997 ec_dbg_drv("Stopping EC");
998 set_bit(EC_FLAGS_STOPPED, &ec->flags);
999 spin_unlock_irqrestore(&ec->lock, flags);
1000 wait_event(ec->wait, acpi_ec_stopped(ec));
1001 spin_lock_irqsave(&ec->lock, flags);
1002 /* Disable GPE for event processing (SCI_EVT=1) */
1003 if (!suspending) {
1004 acpi_ec_complete_request(ec);
1005 ec_dbg_ref(ec, "Decrease driver");
1006 } else if (!ec_freeze_events)
1007 __acpi_ec_disable_event(ec);
1008 clear_bit(EC_FLAGS_STARTED, &ec->flags);
1009 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
1010 ec_log_drv("EC stopped");
1011 }
1012 spin_unlock_irqrestore(&ec->lock, flags);
1013}
1014
1015static void acpi_ec_enter_noirq(struct acpi_ec *ec)
1016{
1017 unsigned long flags;
1018
1019 spin_lock_irqsave(&ec->lock, flags);
1020 ec->busy_polling = true;
1021 ec->polling_guard = 0;
1022 ec_log_drv("interrupt blocked");
1023 spin_unlock_irqrestore(&ec->lock, flags);
1024}
1025
1026static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1027{
1028 unsigned long flags;
1029
1030 spin_lock_irqsave(&ec->lock, flags);
1031 ec->busy_polling = ec_busy_polling;
1032 ec->polling_guard = ec_polling_guard;
1033 ec_log_drv("interrupt unblocked");
1034 spin_unlock_irqrestore(&ec->lock, flags);
1035}
1036
1037void acpi_ec_block_transactions(void)
1038{
1039 struct acpi_ec *ec = first_ec;
1040
1041 if (!ec)
1042 return;
1043
1044 mutex_lock(&ec->mutex);
1045 /* Prevent transactions from being carried out */
1046 acpi_ec_stop(ec, true);
1047 mutex_unlock(&ec->mutex);
1048}
1049
1050void acpi_ec_unblock_transactions(void)
1051{
1052 /*
1053 * Allow transactions to happen again (this function is called from
1054 * atomic context during wakeup, so we don't need to acquire the mutex).
1055 */
1056 if (first_ec)
1057 acpi_ec_start(first_ec, true);
1058}
1059
1060/* --------------------------------------------------------------------------
1061 Event Management
1062 -------------------------------------------------------------------------- */
1063static struct acpi_ec_query_handler *
1064acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1065{
1066 struct acpi_ec_query_handler *handler;
1067
1068 mutex_lock(&ec->mutex);
1069 list_for_each_entry(handler, &ec->list, node) {
1070 if (value == handler->query_bit) {
1071 kref_get(&handler->kref);
1072 mutex_unlock(&ec->mutex);
1073 return handler;
1074 }
1075 }
1076 mutex_unlock(&ec->mutex);
1077 return NULL;
1078}
1079
1080static void acpi_ec_query_handler_release(struct kref *kref)
1081{
1082 struct acpi_ec_query_handler *handler =
1083 container_of(kref, struct acpi_ec_query_handler, kref);
1084
1085 kfree(handler);
1086}
1087
1088static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1089{
1090 kref_put(&handler->kref, acpi_ec_query_handler_release);
1091}
1092
1093int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1094 acpi_handle handle, acpi_ec_query_func func,
1095 void *data)
1096{
1097 struct acpi_ec_query_handler *handler;
1098
1099 if (!handle && !func)
1100 return -EINVAL;
1101
1102 handler = kzalloc(sizeof(*handler), GFP_KERNEL);
1103 if (!handler)
1104 return -ENOMEM;
1105
1106 handler->query_bit = query_bit;
1107 handler->handle = handle;
1108 handler->func = func;
1109 handler->data = data;
1110 mutex_lock(&ec->mutex);
1111 kref_init(&handler->kref);
1112 list_add(&handler->node, &ec->list);
1113 mutex_unlock(&ec->mutex);
1114
1115 return 0;
1116}
1117EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1118
1119static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1120 bool remove_all, u8 query_bit)
1121{
1122 struct acpi_ec_query_handler *handler, *tmp;
1123 LIST_HEAD(free_list);
1124
1125 mutex_lock(&ec->mutex);
1126 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1127 /*
1128 * When remove_all is false, only remove custom query handlers
1129 * which have handler->func set. This is done to preserve query
1130 * handlers discovered thru ACPI, as they should continue handling
1131 * EC queries.
1132 */
1133 if (remove_all || (handler->func && handler->query_bit == query_bit)) {
1134 list_del_init(&handler->node);
1135 list_add(&handler->node, &free_list);
1136
1137 }
1138 }
1139 mutex_unlock(&ec->mutex);
1140 list_for_each_entry_safe(handler, tmp, &free_list, node)
1141 acpi_ec_put_query_handler(handler);
1142}
1143
1144void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1145{
1146 acpi_ec_remove_query_handlers(ec, false, query_bit);
1147 flush_workqueue(ec_query_wq);
1148}
1149EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
1150
1151static void acpi_ec_event_processor(struct work_struct *work)
1152{
1153 struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1154 struct acpi_ec_query_handler *handler = q->handler;
1155 struct acpi_ec *ec = q->ec;
1156
1157 ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
1158
1159 if (handler->func)
1160 handler->func(handler->data);
1161 else if (handler->handle)
1162 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
1163
1164 ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
1165
1166 spin_lock_irq(&ec->lock);
1167 ec->queries_in_progress--;
1168 spin_unlock_irq(&ec->lock);
1169
1170 acpi_ec_put_query_handler(handler);
1171 kfree(q);
1172}
1173
1174static struct acpi_ec_query *acpi_ec_create_query(struct acpi_ec *ec, u8 *pval)
1175{
1176 struct acpi_ec_query *q;
1177 struct transaction *t;
1178
1179 q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1180 if (!q)
1181 return NULL;
1182
1183 INIT_WORK(&q->work, acpi_ec_event_processor);
1184 t = &q->transaction;
1185 t->command = ACPI_EC_COMMAND_QUERY;
1186 t->rdata = pval;
1187 t->rlen = 1;
1188 q->ec = ec;
1189 return q;
1190}
1191
1192static int acpi_ec_submit_query(struct acpi_ec *ec)
1193{
1194 struct acpi_ec_query *q;
1195 u8 value = 0;
1196 int result;
1197
1198 q = acpi_ec_create_query(ec, &value);
1199 if (!q)
1200 return -ENOMEM;
1201
1202 /*
1203 * Query the EC to find out which _Qxx method we need to evaluate.
1204 * Note that successful completion of the query causes the ACPI_EC_SCI
1205 * bit to be cleared (and thus clearing the interrupt source).
1206 */
1207 result = acpi_ec_transaction(ec, &q->transaction);
1208 if (result)
1209 goto err_exit;
1210
1211 if (!value) {
1212 result = -ENODATA;
1213 goto err_exit;
1214 }
1215
1216 q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1217 if (!q->handler) {
1218 result = -ENODATA;
1219 goto err_exit;
1220 }
1221
1222 /*
1223 * It is reported that _Qxx are evaluated in a parallel way on Windows:
1224 * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1225 *
1226 * Put this log entry before queue_work() to make it appear in the log
1227 * before any other messages emitted during workqueue handling.
1228 */
1229 ec_dbg_evt("Query(0x%02x) scheduled", value);
1230
1231 spin_lock_irq(&ec->lock);
1232
1233 ec->queries_in_progress++;
1234 queue_work(ec_query_wq, &q->work);
1235
1236 spin_unlock_irq(&ec->lock);
1237
1238 return 0;
1239
1240err_exit:
1241 kfree(q);
1242
1243 return result;
1244}
1245
1246static void acpi_ec_event_handler(struct work_struct *work)
1247{
1248 struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
1249
1250 ec_dbg_evt("Event started");
1251
1252 spin_lock_irq(&ec->lock);
1253
1254 while (ec->events_to_process) {
1255 spin_unlock_irq(&ec->lock);
1256
1257 acpi_ec_submit_query(ec);
1258
1259 spin_lock_irq(&ec->lock);
1260
1261 ec->events_to_process--;
1262 }
1263
1264 /*
1265 * Before exit, make sure that the it will be possible to queue up the
1266 * event handling work again regardless of whether or not the query
1267 * queued up above is processed successfully.
1268 */
1269 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1270 bool guard_timeout;
1271
1272 acpi_ec_complete_event(ec);
1273
1274 ec_dbg_evt("Event stopped");
1275
1276 spin_unlock_irq(&ec->lock);
1277
1278 guard_timeout = !!ec_guard(ec);
1279
1280 spin_lock_irq(&ec->lock);
1281
1282 /* Take care of SCI_EVT unless someone else is doing that. */
1283 if (guard_timeout && !ec->curr)
1284 advance_transaction(ec, false);
1285 } else {
1286 acpi_ec_close_event(ec);
1287
1288 ec_dbg_evt("Event stopped");
1289 }
1290
1291 ec->events_in_progress--;
1292
1293 spin_unlock_irq(&ec->lock);
1294}
1295
1296static void clear_gpe_and_advance_transaction(struct acpi_ec *ec, bool interrupt)
1297{
1298 /*
1299 * Clear GPE_STS upfront to allow subsequent hardware GPE_STS 0->1
1300 * changes to always trigger a GPE interrupt.
1301 *
1302 * GPE STS is a W1C register, which means:
1303 *
1304 * 1. Software can clear it without worrying about clearing the other
1305 * GPEs' STS bits when the hardware sets them in parallel.
1306 *
1307 * 2. As long as software can ensure only clearing it when it is set,
1308 * hardware won't set it in parallel.
1309 */
1310 if (ec->gpe >= 0 && acpi_ec_gpe_status_set(ec))
1311 acpi_clear_gpe(NULL, ec->gpe);
1312
1313 advance_transaction(ec, true);
1314}
1315
1316static void acpi_ec_handle_interrupt(struct acpi_ec *ec)
1317{
1318 unsigned long flags;
1319
1320 spin_lock_irqsave(&ec->lock, flags);
1321
1322 clear_gpe_and_advance_transaction(ec, true);
1323
1324 spin_unlock_irqrestore(&ec->lock, flags);
1325}
1326
1327static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1328 u32 gpe_number, void *data)
1329{
1330 acpi_ec_handle_interrupt(data);
1331 return ACPI_INTERRUPT_HANDLED;
1332}
1333
1334static irqreturn_t acpi_ec_irq_handler(int irq, void *data)
1335{
1336 acpi_ec_handle_interrupt(data);
1337 return IRQ_HANDLED;
1338}
1339
1340/* --------------------------------------------------------------------------
1341 * Address Space Management
1342 * -------------------------------------------------------------------------- */
1343
1344static acpi_status
1345acpi_ec_space_handler(u32 function, acpi_physical_address address,
1346 u32 bits, u64 *value64,
1347 void *handler_context, void *region_context)
1348{
1349 struct acpi_ec *ec = handler_context;
1350 int result = 0, i, bytes = bits / 8;
1351 u8 *value = (u8 *)value64;
1352 u32 glk;
1353
1354 if ((address > 0xFF) || !value || !handler_context)
1355 return AE_BAD_PARAMETER;
1356
1357 if (function != ACPI_READ && function != ACPI_WRITE)
1358 return AE_BAD_PARAMETER;
1359
1360 mutex_lock(&ec->mutex);
1361
1362 if (ec->global_lock) {
1363 acpi_status status;
1364
1365 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
1366 if (ACPI_FAILURE(status)) {
1367 result = -ENODEV;
1368 goto unlock;
1369 }
1370 }
1371
1372 if (ec->busy_polling || bits > 8)
1373 acpi_ec_burst_enable(ec);
1374
1375 for (i = 0; i < bytes; ++i, ++address, ++value) {
1376 result = (function == ACPI_READ) ?
1377 acpi_ec_read_unlocked(ec, address, value) :
1378 acpi_ec_write_unlocked(ec, address, *value);
1379 if (result < 0)
1380 break;
1381 }
1382
1383 if (ec->busy_polling || bits > 8)
1384 acpi_ec_burst_disable(ec);
1385
1386 if (ec->global_lock)
1387 acpi_release_global_lock(glk);
1388
1389unlock:
1390 mutex_unlock(&ec->mutex);
1391
1392 switch (result) {
1393 case -EINVAL:
1394 return AE_BAD_PARAMETER;
1395 case -ENODEV:
1396 return AE_NOT_FOUND;
1397 case -ETIME:
1398 return AE_TIME;
1399 case 0:
1400 return AE_OK;
1401 default:
1402 return AE_ERROR;
1403 }
1404}
1405
1406/* --------------------------------------------------------------------------
1407 * Driver Interface
1408 * -------------------------------------------------------------------------- */
1409
1410static acpi_status
1411ec_parse_io_ports(struct acpi_resource *resource, void *context);
1412
1413static void acpi_ec_free(struct acpi_ec *ec)
1414{
1415 if (first_ec == ec)
1416 first_ec = NULL;
1417 if (boot_ec == ec)
1418 boot_ec = NULL;
1419 kfree(ec);
1420}
1421
1422static struct acpi_ec *acpi_ec_alloc(void)
1423{
1424 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
1425
1426 if (!ec)
1427 return NULL;
1428 mutex_init(&ec->mutex);
1429 init_waitqueue_head(&ec->wait);
1430 INIT_LIST_HEAD(&ec->list);
1431 spin_lock_init(&ec->lock);
1432 INIT_WORK(&ec->work, acpi_ec_event_handler);
1433 ec->timestamp = jiffies;
1434 ec->busy_polling = true;
1435 ec->polling_guard = 0;
1436 ec->gpe = -1;
1437 ec->irq = -1;
1438 return ec;
1439}
1440
1441static acpi_status
1442acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1443 void *context, void **return_value)
1444{
1445 char node_name[5];
1446 struct acpi_buffer buffer = { sizeof(node_name), node_name };
1447 struct acpi_ec *ec = context;
1448 int value = 0;
1449 acpi_status status;
1450
1451 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1452
1453 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
1454 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
1455 return AE_OK;
1456}
1457
1458static acpi_status
1459ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
1460{
1461 acpi_status status;
1462 unsigned long long tmp = 0;
1463 struct acpi_ec *ec = context;
1464
1465 /* clear addr values, ec_parse_io_ports depend on it */
1466 ec->command_addr = ec->data_addr = 0;
1467
1468 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1469 ec_parse_io_ports, ec);
1470 if (ACPI_FAILURE(status))
1471 return status;
1472 if (ec->data_addr == 0 || ec->command_addr == 0)
1473 return AE_OK;
1474
1475 /* Get GPE bit assignment (EC events). */
1476 /* TODO: Add support for _GPE returning a package */
1477 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1478 if (ACPI_SUCCESS(status))
1479 ec->gpe = tmp;
1480 /*
1481 * Errors are non-fatal, allowing for ACPI Reduced Hardware
1482 * platforms which use GpioInt instead of GPE.
1483 */
1484
1485 /* Use the global lock for all EC transactions? */
1486 tmp = 0;
1487 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1488 ec->global_lock = tmp;
1489 ec->handle = handle;
1490 return AE_CTRL_TERMINATE;
1491}
1492
1493static bool install_gpe_event_handler(struct acpi_ec *ec)
1494{
1495 acpi_status status;
1496
1497 status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1498 ACPI_GPE_EDGE_TRIGGERED,
1499 &acpi_ec_gpe_handler, ec);
1500 if (ACPI_FAILURE(status))
1501 return false;
1502
1503 if (test_bit(EC_FLAGS_STARTED, &ec->flags) && ec->reference_count >= 1)
1504 acpi_ec_enable_gpe(ec, true);
1505
1506 return true;
1507}
1508
1509static bool install_gpio_irq_event_handler(struct acpi_ec *ec)
1510{
1511 return request_threaded_irq(ec->irq, NULL, acpi_ec_irq_handler,
1512 IRQF_SHARED | IRQF_ONESHOT, "ACPI EC", ec) >= 0;
1513}
1514
1515/**
1516 * ec_install_handlers - Install service callbacks and register query methods.
1517 * @ec: Target EC.
1518 * @device: ACPI device object corresponding to @ec.
1519 * @call_reg: If _REG should be called to notify OpRegion availability
1520 *
1521 * Install a handler for the EC address space type unless it has been installed
1522 * already. If @device is not NULL, also look for EC query methods in the
1523 * namespace and register them, and install an event (either GPE or GPIO IRQ)
1524 * handler for the EC, if possible.
1525 *
1526 * Return:
1527 * -ENODEV if the address space handler cannot be installed, which means
1528 * "unable to handle transactions",
1529 * -EPROBE_DEFER if GPIO IRQ acquisition needs to be deferred,
1530 * or 0 (success) otherwise.
1531 */
1532static int ec_install_handlers(struct acpi_ec *ec, struct acpi_device *device,
1533 bool call_reg)
1534{
1535 acpi_status status;
1536
1537 acpi_ec_start(ec, false);
1538
1539 if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1540 acpi_handle scope_handle = ec == first_ec ? ACPI_ROOT_OBJECT : ec->handle;
1541
1542 acpi_ec_enter_noirq(ec);
1543 status = acpi_install_address_space_handler_no_reg(scope_handle,
1544 ACPI_ADR_SPACE_EC,
1545 &acpi_ec_space_handler,
1546 NULL, ec);
1547 if (ACPI_FAILURE(status)) {
1548 acpi_ec_stop(ec, false);
1549 return -ENODEV;
1550 }
1551 set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1552 }
1553
1554 if (call_reg && !test_bit(EC_FLAGS_EC_REG_CALLED, &ec->flags)) {
1555 acpi_execute_reg_methods(ec->handle, ACPI_UINT32_MAX, ACPI_ADR_SPACE_EC);
1556 set_bit(EC_FLAGS_EC_REG_CALLED, &ec->flags);
1557 }
1558
1559 if (!device)
1560 return 0;
1561
1562 if (ec->gpe < 0) {
1563 /* ACPI reduced hardware platforms use a GpioInt from _CRS. */
1564 int irq = acpi_dev_gpio_irq_get(device, 0);
1565 /*
1566 * Bail out right away for deferred probing or complete the
1567 * initialization regardless of any other errors.
1568 */
1569 if (irq == -EPROBE_DEFER)
1570 return -EPROBE_DEFER;
1571 else if (irq >= 0)
1572 ec->irq = irq;
1573 }
1574
1575 if (!test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1576 /* Find and register all query methods */
1577 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1578 acpi_ec_register_query_methods,
1579 NULL, ec, NULL);
1580 set_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1581 }
1582 if (!test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1583 bool ready = false;
1584
1585 if (ec->gpe >= 0)
1586 ready = install_gpe_event_handler(ec);
1587 else if (ec->irq >= 0)
1588 ready = install_gpio_irq_event_handler(ec);
1589
1590 if (ready) {
1591 set_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1592 acpi_ec_leave_noirq(ec);
1593 }
1594 /*
1595 * Failures to install an event handler are not fatal, because
1596 * the EC can be polled for events.
1597 */
1598 }
1599 /* EC is fully operational, allow queries */
1600 acpi_ec_enable_event(ec);
1601
1602 return 0;
1603}
1604
1605static void ec_remove_handlers(struct acpi_ec *ec)
1606{
1607 acpi_handle scope_handle = ec == first_ec ? ACPI_ROOT_OBJECT : ec->handle;
1608
1609 if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1610 if (ACPI_FAILURE(acpi_remove_address_space_handler(
1611 scope_handle,
1612 ACPI_ADR_SPACE_EC,
1613 &acpi_ec_space_handler)))
1614 pr_err("failed to remove space handler\n");
1615 clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1616 }
1617
1618 /*
1619 * Stops handling the EC transactions after removing the operation
1620 * region handler. This is required because _REG(DISCONNECT)
1621 * invoked during the removal can result in new EC transactions.
1622 *
1623 * Flushes the EC requests and thus disables the GPE before
1624 * removing the GPE handler. This is required by the current ACPICA
1625 * GPE core. ACPICA GPE core will automatically disable a GPE when
1626 * it is indicated but there is no way to handle it. So the drivers
1627 * must disable the GPEs prior to removing the GPE handlers.
1628 */
1629 acpi_ec_stop(ec, false);
1630
1631 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1632 if (ec->gpe >= 0 &&
1633 ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1634 &acpi_ec_gpe_handler)))
1635 pr_err("failed to remove gpe handler\n");
1636
1637 if (ec->irq >= 0)
1638 free_irq(ec->irq, ec);
1639
1640 clear_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1641 }
1642 if (test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1643 acpi_ec_remove_query_handlers(ec, true, 0);
1644 clear_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1645 }
1646}
1647
1648static int acpi_ec_setup(struct acpi_ec *ec, struct acpi_device *device, bool call_reg)
1649{
1650 int ret;
1651
1652 /* First EC capable of handling transactions */
1653 if (!first_ec)
1654 first_ec = ec;
1655
1656 ret = ec_install_handlers(ec, device, call_reg);
1657 if (ret) {
1658 if (ec == first_ec)
1659 first_ec = NULL;
1660
1661 return ret;
1662 }
1663
1664 pr_info("EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", ec->command_addr,
1665 ec->data_addr);
1666
1667 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1668 if (ec->gpe >= 0)
1669 pr_info("GPE=0x%x\n", ec->gpe);
1670 else
1671 pr_info("IRQ=%d\n", ec->irq);
1672 }
1673
1674 return ret;
1675}
1676
1677static int acpi_ec_add(struct acpi_device *device)
1678{
1679 struct acpi_ec *ec;
1680 int ret;
1681
1682 strscpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1683 strscpy(acpi_device_class(device), ACPI_EC_CLASS);
1684
1685 if (boot_ec && (boot_ec->handle == device->handle ||
1686 !strcmp(acpi_device_hid(device), ACPI_ECDT_HID))) {
1687 /* Fast path: this device corresponds to the boot EC. */
1688 ec = boot_ec;
1689 } else {
1690 acpi_status status;
1691
1692 ec = acpi_ec_alloc();
1693 if (!ec)
1694 return -ENOMEM;
1695
1696 status = ec_parse_device(device->handle, 0, ec, NULL);
1697 if (status != AE_CTRL_TERMINATE) {
1698 ret = -EINVAL;
1699 goto err;
1700 }
1701
1702 if (boot_ec && ec->command_addr == boot_ec->command_addr &&
1703 ec->data_addr == boot_ec->data_addr) {
1704 /*
1705 * Trust PNP0C09 namespace location rather than ECDT ID.
1706 * But trust ECDT GPE rather than _GPE because of ASUS
1707 * quirks. So do not change boot_ec->gpe to ec->gpe,
1708 * except when the TRUST_DSDT_GPE quirk is set.
1709 */
1710 boot_ec->handle = ec->handle;
1711
1712 if (EC_FLAGS_TRUST_DSDT_GPE)
1713 boot_ec->gpe = ec->gpe;
1714
1715 acpi_handle_debug(ec->handle, "duplicated.\n");
1716 acpi_ec_free(ec);
1717 ec = boot_ec;
1718 }
1719 }
1720
1721 ret = acpi_ec_setup(ec, device, true);
1722 if (ret)
1723 goto err;
1724
1725 if (ec == boot_ec)
1726 acpi_handle_info(boot_ec->handle,
1727 "Boot %s EC initialization complete\n",
1728 boot_ec_is_ecdt ? "ECDT" : "DSDT");
1729
1730 acpi_handle_info(ec->handle,
1731 "EC: Used to handle transactions and events\n");
1732
1733 device->driver_data = ec;
1734
1735 ret = !!request_region(ec->data_addr, 1, "EC data");
1736 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1737 ret = !!request_region(ec->command_addr, 1, "EC cmd");
1738 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1739
1740 /* Reprobe devices depending on the EC */
1741 acpi_dev_clear_dependencies(device);
1742
1743 acpi_handle_debug(ec->handle, "enumerated.\n");
1744 return 0;
1745
1746err:
1747 if (ec != boot_ec)
1748 acpi_ec_free(ec);
1749
1750 return ret;
1751}
1752
1753static void acpi_ec_remove(struct acpi_device *device)
1754{
1755 struct acpi_ec *ec;
1756
1757 if (!device)
1758 return;
1759
1760 ec = acpi_driver_data(device);
1761 release_region(ec->data_addr, 1);
1762 release_region(ec->command_addr, 1);
1763 device->driver_data = NULL;
1764 if (ec != boot_ec) {
1765 ec_remove_handlers(ec);
1766 acpi_ec_free(ec);
1767 }
1768}
1769
1770void acpi_ec_register_opregions(struct acpi_device *adev)
1771{
1772 if (first_ec && first_ec->handle != adev->handle)
1773 acpi_execute_reg_methods(adev->handle, 1, ACPI_ADR_SPACE_EC);
1774}
1775
1776static acpi_status
1777ec_parse_io_ports(struct acpi_resource *resource, void *context)
1778{
1779 struct acpi_ec *ec = context;
1780
1781 if (resource->type != ACPI_RESOURCE_TYPE_IO)
1782 return AE_OK;
1783
1784 /*
1785 * The first address region returned is the data port, and
1786 * the second address region returned is the status/command
1787 * port.
1788 */
1789 if (ec->data_addr == 0)
1790 ec->data_addr = resource->data.io.minimum;
1791 else if (ec->command_addr == 0)
1792 ec->command_addr = resource->data.io.minimum;
1793 else
1794 return AE_CTRL_TERMINATE;
1795
1796 return AE_OK;
1797}
1798
1799static const struct acpi_device_id ec_device_ids[] = {
1800 {"PNP0C09", 0},
1801 {ACPI_ECDT_HID, 0},
1802 {"", 0},
1803};
1804
1805/*
1806 * This function is not Windows-compatible as Windows never enumerates the
1807 * namespace EC before the main ACPI device enumeration process. It is
1808 * retained for historical reason and will be deprecated in the future.
1809 */
1810void __init acpi_ec_dsdt_probe(void)
1811{
1812 struct acpi_ec *ec;
1813 acpi_status status;
1814 int ret;
1815
1816 /*
1817 * If a platform has ECDT, there is no need to proceed as the
1818 * following probe is not a part of the ACPI device enumeration,
1819 * executing _STA is not safe, and thus this probe may risk of
1820 * picking up an invalid EC device.
1821 */
1822 if (boot_ec)
1823 return;
1824
1825 ec = acpi_ec_alloc();
1826 if (!ec)
1827 return;
1828
1829 /*
1830 * At this point, the namespace is initialized, so start to find
1831 * the namespace objects.
1832 */
1833 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
1834 if (ACPI_FAILURE(status) || !ec->handle) {
1835 acpi_ec_free(ec);
1836 return;
1837 }
1838
1839 /*
1840 * When the DSDT EC is available, always re-configure boot EC to
1841 * have _REG evaluated. _REG can only be evaluated after the
1842 * namespace initialization.
1843 * At this point, the GPE is not fully initialized, so do not to
1844 * handle the events.
1845 */
1846 ret = acpi_ec_setup(ec, NULL, true);
1847 if (ret) {
1848 acpi_ec_free(ec);
1849 return;
1850 }
1851
1852 boot_ec = ec;
1853
1854 acpi_handle_info(ec->handle,
1855 "Boot DSDT EC used to handle transactions\n");
1856}
1857
1858/*
1859 * acpi_ec_ecdt_start - Finalize the boot ECDT EC initialization.
1860 *
1861 * First, look for an ACPI handle for the boot ECDT EC if acpi_ec_add() has not
1862 * found a matching object in the namespace.
1863 *
1864 * Next, in case the DSDT EC is not functioning, it is still necessary to
1865 * provide a functional ECDT EC to handle events, so add an extra device object
1866 * to represent it (see https://bugzilla.kernel.org/show_bug.cgi?id=115021).
1867 *
1868 * This is useful on platforms with valid ECDT and invalid DSDT EC settings,
1869 * like ASUS X550ZE (see https://bugzilla.kernel.org/show_bug.cgi?id=196847).
1870 */
1871static void __init acpi_ec_ecdt_start(void)
1872{
1873 struct acpi_table_ecdt *ecdt_ptr;
1874 acpi_handle handle;
1875 acpi_status status;
1876
1877 /* Bail out if a matching EC has been found in the namespace. */
1878 if (!boot_ec || boot_ec->handle != ACPI_ROOT_OBJECT)
1879 return;
1880
1881 /* Look up the object pointed to from the ECDT in the namespace. */
1882 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1883 (struct acpi_table_header **)&ecdt_ptr);
1884 if (ACPI_FAILURE(status))
1885 return;
1886
1887 status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1888 if (ACPI_SUCCESS(status)) {
1889 boot_ec->handle = handle;
1890
1891 /* Add a special ACPI device object to represent the boot EC. */
1892 acpi_bus_register_early_device(ACPI_BUS_TYPE_ECDT_EC);
1893 }
1894
1895 acpi_put_table((struct acpi_table_header *)ecdt_ptr);
1896}
1897
1898/*
1899 * On some hardware it is necessary to clear events accumulated by the EC during
1900 * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1901 * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1902 *
1903 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1904 *
1905 * Ideally, the EC should also be instructed NOT to accumulate events during
1906 * sleep (which Windows seems to do somehow), but the interface to control this
1907 * behaviour is not known at this time.
1908 *
1909 * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1910 * however it is very likely that other Samsung models are affected.
1911 *
1912 * On systems which don't accumulate _Q events during sleep, this extra check
1913 * should be harmless.
1914 */
1915static int ec_clear_on_resume(const struct dmi_system_id *id)
1916{
1917 pr_debug("Detected system needing EC poll on resume.\n");
1918 EC_FLAGS_CLEAR_ON_RESUME = 1;
1919 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1920 return 0;
1921}
1922
1923/*
1924 * Some ECDTs contain wrong register addresses.
1925 * MSI MS-171F
1926 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1927 */
1928static int ec_correct_ecdt(const struct dmi_system_id *id)
1929{
1930 pr_debug("Detected system needing ECDT address correction.\n");
1931 EC_FLAGS_CORRECT_ECDT = 1;
1932 return 0;
1933}
1934
1935/*
1936 * Some ECDTs contain wrong GPE setting, but they share the same port addresses
1937 * with DSDT EC, don't duplicate the DSDT EC with ECDT EC in this case.
1938 * https://bugzilla.kernel.org/show_bug.cgi?id=209989
1939 */
1940static int ec_honor_dsdt_gpe(const struct dmi_system_id *id)
1941{
1942 pr_debug("Detected system needing DSDT GPE setting.\n");
1943 EC_FLAGS_TRUST_DSDT_GPE = 1;
1944 return 0;
1945}
1946
1947static const struct dmi_system_id ec_dmi_table[] __initconst = {
1948 {
1949 /*
1950 * MSI MS-171F
1951 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1952 */
1953 .callback = ec_correct_ecdt,
1954 .matches = {
1955 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1956 DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),
1957 },
1958 },
1959 {
1960 /*
1961 * HP Pavilion Gaming Laptop 15-cx0xxx
1962 * https://bugzilla.kernel.org/show_bug.cgi?id=209989
1963 */
1964 .callback = ec_honor_dsdt_gpe,
1965 .matches = {
1966 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1967 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion Gaming Laptop 15-cx0xxx"),
1968 },
1969 },
1970 {
1971 /*
1972 * HP Pavilion Gaming Laptop 15-cx0041ur
1973 */
1974 .callback = ec_honor_dsdt_gpe,
1975 .matches = {
1976 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1977 DMI_MATCH(DMI_PRODUCT_NAME, "HP 15-cx0041ur"),
1978 },
1979 },
1980 {
1981 /*
1982 * HP Pavilion Gaming Laptop 15-dk1xxx
1983 * https://github.com/systemd/systemd/issues/28942
1984 */
1985 .callback = ec_honor_dsdt_gpe,
1986 .matches = {
1987 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1988 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion Gaming Laptop 15-dk1xxx"),
1989 },
1990 },
1991 {
1992 /*
1993 * HP 250 G7 Notebook PC
1994 */
1995 .callback = ec_honor_dsdt_gpe,
1996 .matches = {
1997 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1998 DMI_MATCH(DMI_PRODUCT_NAME, "HP 250 G7 Notebook PC"),
1999 },
2000 },
2001 {
2002 /*
2003 * Samsung hardware
2004 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
2005 */
2006 .callback = ec_clear_on_resume,
2007 .matches = {
2008 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
2009 },
2010 },
2011 {}
2012};
2013
2014void __init acpi_ec_ecdt_probe(void)
2015{
2016 struct acpi_table_ecdt *ecdt_ptr;
2017 struct acpi_ec *ec;
2018 acpi_status status;
2019 int ret;
2020
2021 /* Generate a boot ec context. */
2022 dmi_check_system(ec_dmi_table);
2023 status = acpi_get_table(ACPI_SIG_ECDT, 1,
2024 (struct acpi_table_header **)&ecdt_ptr);
2025 if (ACPI_FAILURE(status))
2026 return;
2027
2028 if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
2029 /*
2030 * Asus X50GL:
2031 * https://bugzilla.kernel.org/show_bug.cgi?id=11880
2032 */
2033 goto out;
2034 }
2035
2036 if (!strstarts(ecdt_ptr->id, "\\")) {
2037 /*
2038 * The ECDT table on some MSI notebooks contains invalid data, together
2039 * with an empty ID string ("").
2040 *
2041 * Section 5.2.15 of the ACPI specification requires the ID string to be
2042 * a "fully qualified reference to the (...) embedded controller device",
2043 * so this string always has to start with a backslash.
2044 *
2045 * By verifying this we can avoid such faulty ECDT tables in a safe way.
2046 */
2047 pr_err(FW_BUG "Ignoring ECDT due to invalid ID string \"%s\"\n", ecdt_ptr->id);
2048 goto out;
2049 }
2050
2051 ec = acpi_ec_alloc();
2052 if (!ec)
2053 goto out;
2054
2055 if (EC_FLAGS_CORRECT_ECDT) {
2056 ec->command_addr = ecdt_ptr->data.address;
2057 ec->data_addr = ecdt_ptr->control.address;
2058 } else {
2059 ec->command_addr = ecdt_ptr->control.address;
2060 ec->data_addr = ecdt_ptr->data.address;
2061 }
2062
2063 /*
2064 * Ignore the GPE value on Reduced Hardware platforms.
2065 * Some products have this set to an erroneous value.
2066 */
2067 if (!acpi_gbl_reduced_hardware)
2068 ec->gpe = ecdt_ptr->gpe;
2069
2070 ec->handle = ACPI_ROOT_OBJECT;
2071
2072 /*
2073 * At this point, the namespace is not initialized, so do not find
2074 * the namespace objects, or handle the events.
2075 */
2076 ret = acpi_ec_setup(ec, NULL, false);
2077 if (ret) {
2078 acpi_ec_free(ec);
2079 goto out;
2080 }
2081
2082 boot_ec = ec;
2083 boot_ec_is_ecdt = true;
2084
2085 pr_info("Boot ECDT EC used to handle transactions\n");
2086
2087out:
2088 acpi_put_table((struct acpi_table_header *)ecdt_ptr);
2089}
2090
2091#ifdef CONFIG_PM_SLEEP
2092static int acpi_ec_suspend(struct device *dev)
2093{
2094 struct acpi_ec *ec =
2095 acpi_driver_data(to_acpi_device(dev));
2096
2097 if (!pm_suspend_no_platform() && ec_freeze_events)
2098 acpi_ec_disable_event(ec);
2099 return 0;
2100}
2101
2102static int acpi_ec_suspend_noirq(struct device *dev)
2103{
2104 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
2105
2106 /*
2107 * The SCI handler doesn't run at this point, so the GPE can be
2108 * masked at the low level without side effects.
2109 */
2110 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
2111 ec->gpe >= 0 && ec->reference_count >= 1)
2112 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
2113
2114 acpi_ec_enter_noirq(ec);
2115
2116 return 0;
2117}
2118
2119static int acpi_ec_resume_noirq(struct device *dev)
2120{
2121 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
2122
2123 acpi_ec_leave_noirq(ec);
2124
2125 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
2126 ec->gpe >= 0 && ec->reference_count >= 1)
2127 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
2128
2129 return 0;
2130}
2131
2132static int acpi_ec_resume(struct device *dev)
2133{
2134 struct acpi_ec *ec =
2135 acpi_driver_data(to_acpi_device(dev));
2136
2137 acpi_ec_enable_event(ec);
2138 return 0;
2139}
2140
2141void acpi_ec_mark_gpe_for_wake(void)
2142{
2143 if (first_ec && !ec_no_wakeup)
2144 acpi_mark_gpe_for_wake(NULL, first_ec->gpe);
2145}
2146EXPORT_SYMBOL_GPL(acpi_ec_mark_gpe_for_wake);
2147
2148void acpi_ec_set_gpe_wake_mask(u8 action)
2149{
2150 if (pm_suspend_no_platform() && first_ec && !ec_no_wakeup)
2151 acpi_set_gpe_wake_mask(NULL, first_ec->gpe, action);
2152}
2153
2154static bool acpi_ec_work_in_progress(struct acpi_ec *ec)
2155{
2156 return ec->events_in_progress + ec->queries_in_progress > 0;
2157}
2158
2159bool acpi_ec_dispatch_gpe(void)
2160{
2161 bool work_in_progress = false;
2162
2163 if (!first_ec)
2164 return acpi_any_gpe_status_set(U32_MAX);
2165
2166 /*
2167 * Report wakeup if the status bit is set for any enabled GPE other
2168 * than the EC one.
2169 */
2170 if (acpi_any_gpe_status_set(first_ec->gpe))
2171 return true;
2172
2173 /*
2174 * Cancel the SCI wakeup and process all pending events in case there
2175 * are any wakeup ones in there.
2176 *
2177 * Note that if any non-EC GPEs are active at this point, the SCI will
2178 * retrigger after the rearming in acpi_s2idle_wake(), so no events
2179 * should be missed by canceling the wakeup here.
2180 */
2181 pm_system_cancel_wakeup();
2182
2183 /*
2184 * Dispatch the EC GPE in-band, but do not report wakeup in any case
2185 * to allow the caller to process events properly after that.
2186 */
2187 spin_lock_irq(&first_ec->lock);
2188
2189 if (acpi_ec_gpe_status_set(first_ec)) {
2190 pm_pr_dbg("ACPI EC GPE status set\n");
2191
2192 clear_gpe_and_advance_transaction(first_ec, false);
2193 work_in_progress = acpi_ec_work_in_progress(first_ec);
2194 }
2195
2196 spin_unlock_irq(&first_ec->lock);
2197
2198 if (!work_in_progress)
2199 return false;
2200
2201 pm_pr_dbg("ACPI EC GPE dispatched\n");
2202
2203 /* Drain EC work. */
2204 do {
2205 acpi_ec_flush_work();
2206
2207 pm_pr_dbg("ACPI EC work flushed\n");
2208
2209 spin_lock_irq(&first_ec->lock);
2210
2211 work_in_progress = acpi_ec_work_in_progress(first_ec);
2212
2213 spin_unlock_irq(&first_ec->lock);
2214 } while (work_in_progress && !pm_wakeup_pending());
2215
2216 return false;
2217}
2218#endif /* CONFIG_PM_SLEEP */
2219
2220static const struct dev_pm_ops acpi_ec_pm = {
2221 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
2222 SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
2223};
2224
2225static int param_set_event_clearing(const char *val,
2226 const struct kernel_param *kp)
2227{
2228 int result = 0;
2229
2230 if (!strncmp(val, "status", sizeof("status") - 1)) {
2231 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
2232 pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
2233 } else if (!strncmp(val, "query", sizeof("query") - 1)) {
2234 ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
2235 pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
2236 } else if (!strncmp(val, "event", sizeof("event") - 1)) {
2237 ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
2238 pr_info("Assuming SCI_EVT clearing on event reads\n");
2239 } else
2240 result = -EINVAL;
2241 return result;
2242}
2243
2244static int param_get_event_clearing(char *buffer,
2245 const struct kernel_param *kp)
2246{
2247 switch (ec_event_clearing) {
2248 case ACPI_EC_EVT_TIMING_STATUS:
2249 return sprintf(buffer, "status\n");
2250 case ACPI_EC_EVT_TIMING_QUERY:
2251 return sprintf(buffer, "query\n");
2252 case ACPI_EC_EVT_TIMING_EVENT:
2253 return sprintf(buffer, "event\n");
2254 default:
2255 return sprintf(buffer, "invalid\n");
2256 }
2257 return 0;
2258}
2259
2260module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
2261 NULL, 0644);
2262MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
2263
2264static struct acpi_driver acpi_ec_driver = {
2265 .name = "ec",
2266 .class = ACPI_EC_CLASS,
2267 .ids = ec_device_ids,
2268 .ops = {
2269 .add = acpi_ec_add,
2270 .remove = acpi_ec_remove,
2271 },
2272 .drv.pm = &acpi_ec_pm,
2273};
2274
2275static void acpi_ec_destroy_workqueues(void)
2276{
2277 if (ec_wq) {
2278 destroy_workqueue(ec_wq);
2279 ec_wq = NULL;
2280 }
2281 if (ec_query_wq) {
2282 destroy_workqueue(ec_query_wq);
2283 ec_query_wq = NULL;
2284 }
2285}
2286
2287static int acpi_ec_init_workqueues(void)
2288{
2289 if (!ec_wq)
2290 ec_wq = alloc_ordered_workqueue("kec", 0);
2291
2292 if (!ec_query_wq)
2293 ec_query_wq = alloc_workqueue("kec_query", 0, ec_max_queries);
2294
2295 if (!ec_wq || !ec_query_wq) {
2296 acpi_ec_destroy_workqueues();
2297 return -ENODEV;
2298 }
2299 return 0;
2300}
2301
2302static const struct dmi_system_id acpi_ec_no_wakeup[] = {
2303 {
2304 .matches = {
2305 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2306 DMI_MATCH(DMI_PRODUCT_FAMILY, "Thinkpad X1 Carbon 6th"),
2307 },
2308 },
2309 {
2310 .matches = {
2311 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2312 DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Yoga 3rd"),
2313 },
2314 },
2315 {
2316 .matches = {
2317 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
2318 DMI_MATCH(DMI_PRODUCT_FAMILY, "103C_5336AN HP ZHAN 66 Pro"),
2319 },
2320 },
2321 /*
2322 * Lenovo Legion Go S; touchscreen blocks HW sleep when woken up from EC
2323 * https://gitlab.freedesktop.org/drm/amd/-/issues/3929
2324 */
2325 {
2326 .matches = {
2327 DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
2328 DMI_MATCH(DMI_PRODUCT_NAME, "83L3"),
2329 }
2330 },
2331 {
2332 .matches = {
2333 DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
2334 DMI_MATCH(DMI_PRODUCT_NAME, "83N6"),
2335 }
2336 },
2337 {
2338 .matches = {
2339 DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
2340 DMI_MATCH(DMI_PRODUCT_NAME, "83Q2"),
2341 }
2342 },
2343 {
2344 .matches = {
2345 DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
2346 DMI_MATCH(DMI_PRODUCT_NAME, "83Q3"),
2347 }
2348 },
2349 {
2350 // TUXEDO InfinityBook Pro AMD Gen9
2351 .matches = {
2352 DMI_MATCH(DMI_BOARD_NAME, "GXxHRXx"),
2353 },
2354 },
2355 { },
2356};
2357
2358void __init acpi_ec_init(void)
2359{
2360 int result;
2361
2362 result = acpi_ec_init_workqueues();
2363 if (result)
2364 return;
2365
2366 /*
2367 * Disable EC wakeup on following systems to prevent periodic
2368 * wakeup from EC GPE.
2369 */
2370 if (dmi_check_system(acpi_ec_no_wakeup)) {
2371 ec_no_wakeup = true;
2372 pr_debug("Disabling EC wakeup on suspend-to-idle\n");
2373 }
2374
2375 /* Driver must be registered after acpi_ec_init_workqueues(). */
2376 acpi_bus_register_driver(&acpi_ec_driver);
2377
2378 acpi_ec_ecdt_start();
2379}
2380
2381/* EC driver currently not unloadable */
2382#if 0
2383static void __exit acpi_ec_exit(void)
2384{
2385
2386 acpi_bus_unregister_driver(&acpi_ec_driver);
2387 acpi_ec_destroy_workqueues();
2388}
2389#endif /* 0 */
Linux 6.x block layer and io_uring tree(s)