blob: 9b42628cf21b328963285e2c04b1e92d912fbb1a [file] [log] [blame]
Thomas Gleixnerc942fdd2019-05-27 08:55:06 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Lv Zhenga8d4fc22015-02-05 16:27:35 +08003 * ec.c - ACPI Embedded Controller Driver (v3)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Lv Zhenga8d4fc22015-02-05 16:27:35 +08005 * Copyright (C) 2001-2015 Intel Corporation
6 * Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
Lv Zheng4a3f6b52014-06-15 08:42:19 +08007 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 */
14
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040015/* Uncomment next line to get verbose printout */
Márton Némethd772b3b2008-01-23 22:34:09 -050016/* #define DEBUG */
Vincent Legollb6aeab42017-05-20 20:38:13 +020017#define pr_fmt(fmt) "ACPI: EC: " fmt
Márton Némethd772b3b2008-01-23 22:34:09 -050018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/types.h>
23#include <linux/delay.h>
Dmitry Torokhov451566f2005-03-19 01:10:05 -050024#include <linux/interrupt.h>
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040025#include <linux/list.h>
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040026#include <linux/spinlock.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Rafael J. Wysocki10a08fd2019-07-30 11:55:59 +020028#include <linux/suspend.h>
Lv Zheng8b484632013-12-03 08:49:16 +080029#include <linux/acpi.h>
Len Browneb27cae2009-07-06 23:40:19 -040030#include <linux/dmi.h>
Lv Zheng8b484632013-12-03 08:49:16 +080031#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Thomas Renninger1195a092010-07-16 13:11:31 +020033#include "internal.h"
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define ACPI_EC_CLASS "embedded_controller"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#define ACPI_EC_DEVICE_NAME "Embedded Controller"
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040037
Denis M. Sadykov703959d2006-09-26 19:50:33 +040038/* EC status register */
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
40#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
Lv Zhengdd43de22014-06-15 08:42:42 +080041#define ACPI_EC_FLAG_CMD 0x08 /* Input buffer contains a command */
Dmitry Torokhov451566f2005-03-19 01:10:05 -050042#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
Alexey Starikovskiy43509332007-05-29 16:42:57 +040044
Lv Zheng1d68d262015-06-11 13:21:38 +080045/*
46 * The SCI_EVT clearing timing is not defined by the ACPI specification.
47 * This leads to lots of practical timing issues for the host EC driver.
48 * The following variations are defined (from the target EC firmware's
49 * perspective):
50 * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
51 * target can clear SCI_EVT at any time so long as the host can see
52 * the indication by reading the status register (EC_SC). So the
53 * host should re-check SCI_EVT after the first time the SCI_EVT
54 * indication is seen, which is the same time the query request
55 * (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
56 * at any later time could indicate another event. Normally such
57 * kind of EC firmware has implemented an event queue and will
58 * return 0x00 to indicate "no outstanding event".
59 * QUERY: After seeing the query request (QR_EC) written to the command
60 * register (EC_CMD) by the host and having prepared the responding
61 * event value in the data register (EC_DATA), the target can safely
62 * clear SCI_EVT because the target can confirm that the current
63 * event is being handled by the host. The host then should check
64 * SCI_EVT right after reading the event response from the data
65 * register (EC_DATA).
66 * EVENT: After seeing the event response read from the data register
67 * (EC_DATA) by the host, the target can clear SCI_EVT. As the
68 * target requires time to notice the change in the data register
69 * (EC_DATA), the host may be required to wait additional guarding
70 * time before checking the SCI_EVT again. Such guarding may not be
71 * necessary if the host is notified via another IRQ.
72 */
73#define ACPI_EC_EVT_TIMING_STATUS 0x00
74#define ACPI_EC_EVT_TIMING_QUERY 0x01
75#define ACPI_EC_EVT_TIMING_EVENT 0x02
76
Denis M. Sadykov703959d2006-09-26 19:50:33 +040077/* EC commands */
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030078enum ec_command {
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +030079 ACPI_EC_COMMAND_READ = 0x80,
80 ACPI_EC_COMMAND_WRITE = 0x81,
81 ACPI_EC_BURST_ENABLE = 0x82,
82 ACPI_EC_BURST_DISABLE = 0x83,
83 ACPI_EC_COMMAND_QUERY = 0x84,
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030084};
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040085
Alexey Starikovskiy5c406412006-12-07 18:42:16 +030086#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
Denis M. Sadykov703959d2006-09-26 19:50:33 +040087#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
Lv Zhengd8d031a2015-05-15 14:16:42 +080088#define ACPI_EC_UDELAY_POLL 550 /* Wait 1ms for EC transaction polling */
Kieran Clancyad332c82014-03-01 00:42:28 +103089#define ACPI_EC_CLEAR_MAX 100 /* Maximum number of events to query
90 * when trying to clear the EC */
Lv Zhenge1191bd2016-08-03 09:00:14 +080091#define ACPI_EC_MAX_QUERIES 16 /* Maximum number of parallel queries */
Denis M. Sadykov703959d2006-09-26 19:50:33 +040092
Alexey Starikovskiy080e4122007-10-22 14:18:30 +040093enum {
Lv Zheng750f628b2016-08-03 16:01:24 +080094 EC_FLAGS_QUERY_ENABLED, /* Query is enabled */
Daniel Drake4446abc2019-10-14 16:56:01 +080095 EC_FLAGS_EVENT_HANDLER_INSTALLED, /* Event handler installed */
Lv Zheng0e1affe2016-03-24 10:42:47 +080096 EC_FLAGS_EC_HANDLER_INSTALLED, /* OpReg handler installed */
Daniel Drake4446abc2019-10-14 16:56:01 +080097 EC_FLAGS_QUERY_METHODS_INSTALLED, /* _Qxx handlers installed */
Lv Zhengad479e72015-02-06 08:57:52 +080098 EC_FLAGS_STARTED, /* Driver is started */
99 EC_FLAGS_STOPPED, /* Driver is stopped */
Daniel Drake4446abc2019-10-14 16:56:01 +0800100 EC_FLAGS_EVENTS_MASKED, /* Events masked */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101};
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400102
Lv Zhengf92fca02014-06-15 08:41:35 +0800103#define ACPI_EC_COMMAND_POLL 0x01 /* Available for command byte */
104#define ACPI_EC_COMMAND_COMPLETE 0x02 /* Completed last byte */
105
Thomas Renninger7a18e962010-10-21 18:24:57 +0200106/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
107static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
108module_param(ec_delay, uint, 0644);
109MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
110
Lv Zhenge1191bd2016-08-03 09:00:14 +0800111static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
112module_param(ec_max_queries, uint, 0644);
113MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
114
Lv Zheng15de603b2015-05-15 14:16:48 +0800115static bool ec_busy_polling __read_mostly;
116module_param(ec_busy_polling, bool, 0644);
117MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
118
119static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
120module_param(ec_polling_guard, uint, 0644);
121MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
122
Lv Zheng3cb02ae2015-06-11 13:21:45 +0800123static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
Lv Zheng1d68d262015-06-11 13:21:38 +0800124
Feng Tanga520d522012-09-28 15:22:00 +0800125/*
126 * If the number of false interrupts per one transaction exceeds
127 * this threshold, will think there is a GPE storm happened and
128 * will disable the GPE for normal transaction.
129 */
130static unsigned int ec_storm_threshold __read_mostly = 8;
131module_param(ec_storm_threshold, uint, 0644);
132MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
133
wangzhitong69cace62021-11-03 13:51:19 +0800134static bool ec_freeze_events __read_mostly;
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800135module_param(ec_freeze_events, bool, 0644);
136MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
137
Rafael J. Wysocki76380632017-07-19 14:41:58 +0200138static bool ec_no_wakeup __read_mostly;
139module_param(ec_no_wakeup, bool, 0644);
140MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
141
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400142struct acpi_ec_query_handler {
143 struct list_head node;
144 acpi_ec_query_func func;
145 acpi_handle handle;
146 void *data;
147 u8 query_bit;
Lv Zheng01305d42015-01-14 19:28:28 +0800148 struct kref kref;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400149};
150
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400151struct transaction {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400152 const u8 *wdata;
153 u8 *rdata;
154 unsigned short irq_count;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400155 u8 command;
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300156 u8 wi;
157 u8 ri;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400158 u8 wlen;
159 u8 rlen;
Lv Zhengf92fca02014-06-15 08:41:35 +0800160 u8 flags;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400161};
162
Lv Zheng02b771b2015-08-12 11:12:02 +0800163struct acpi_ec_query {
164 struct transaction transaction;
165 struct work_struct work;
166 struct acpi_ec_query_handler *handler;
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +0100167 struct acpi_ec *ec;
Lv Zheng02b771b2015-08-12 11:12:02 +0800168};
169
Rafael J. Wysockieafe7502021-11-23 19:42:02 +0100170static int acpi_ec_submit_query(struct acpi_ec *ec);
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +0100171static void advance_transaction(struct acpi_ec *ec, bool interrupt);
Lv Zheng02b771b2015-08-12 11:12:02 +0800172static void acpi_ec_event_handler(struct work_struct *work);
Lv Zheng74443bb2015-01-14 19:28:47 +0800173
Rafael J. Wysockia9c30762019-02-01 10:57:01 +0100174struct acpi_ec *first_ec;
Thomas Renninger1195a092010-07-16 13:11:31 +0200175EXPORT_SYMBOL(first_ec);
Rafael J. Wysockia9c30762019-02-01 10:57:01 +0100176
177static struct acpi_ec *boot_ec;
wangzhitong69cace62021-11-03 13:51:19 +0800178static bool boot_ec_is_ecdt;
Rafael J. Wysockif0ac20c2020-02-11 10:07:43 +0100179static struct workqueue_struct *ec_wq;
Lv Zhenge1191bd2016-08-03 09:00:14 +0800180static struct workqueue_struct *ec_query_wq;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400181
Lv Zheng59f0aa92016-03-24 10:42:53 +0800182static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
Zhang Rui4370cbf2021-06-21 09:37:27 +0800183static int EC_FLAGS_TRUST_DSDT_GPE; /* Needs DSDT GPE as correction setting */
Zhang Ruib6a3e142019-02-01 14:13:41 +0800184static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186/* --------------------------------------------------------------------------
Lv Zheng3535a3c2015-02-27 14:48:15 +0800187 * Logging/Debugging
188 * -------------------------------------------------------------------------- */
189
190/*
191 * Splitters used by the developers to track the boundary of the EC
192 * handling processes.
193 */
194#ifdef DEBUG
195#define EC_DBG_SEP " "
196#define EC_DBG_DRV "+++++"
197#define EC_DBG_STM "====="
198#define EC_DBG_REQ "*****"
199#define EC_DBG_EVT "#####"
200#else
201#define EC_DBG_SEP ""
202#define EC_DBG_DRV
203#define EC_DBG_STM
204#define EC_DBG_REQ
205#define EC_DBG_EVT
206#endif
207
208#define ec_log_raw(fmt, ...) \
209 pr_info(fmt "\n", ##__VA_ARGS__)
210#define ec_dbg_raw(fmt, ...) \
211 pr_debug(fmt "\n", ##__VA_ARGS__)
212#define ec_log(filter, fmt, ...) \
213 ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
214#define ec_dbg(filter, fmt, ...) \
215 ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
216
217#define ec_log_drv(fmt, ...) \
218 ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
219#define ec_dbg_drv(fmt, ...) \
220 ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
221#define ec_dbg_stm(fmt, ...) \
222 ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
223#define ec_dbg_req(fmt, ...) \
224 ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
225#define ec_dbg_evt(fmt, ...) \
226 ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
Lv Zheng770970f2015-02-27 14:48:24 +0800227#define ec_dbg_ref(ec, fmt, ...) \
228 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
Lv Zheng3535a3c2015-02-27 14:48:15 +0800229
230/* --------------------------------------------------------------------------
Lv Zhengad479e72015-02-06 08:57:52 +0800231 * Device Flags
232 * -------------------------------------------------------------------------- */
233
234static bool acpi_ec_started(struct acpi_ec *ec)
235{
236 return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
237 !test_bit(EC_FLAGS_STOPPED, &ec->flags);
238}
239
Lv Zheng750f628b2016-08-03 16:01:24 +0800240static bool acpi_ec_event_enabled(struct acpi_ec *ec)
241{
242 /*
243 * There is an OSPM early stage logic. During the early stages
244 * (boot/resume), OSPMs shouldn't enable the event handling, only
245 * the EC transactions are allowed to be performed.
246 */
247 if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
248 return false;
249 /*
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800250 * However, disabling the event handling is experimental for late
251 * stage (suspend), and is controlled by the boot parameter of
252 * "ec_freeze_events":
253 * 1. true: The EC event handling is disabled before entering
254 * the noirq stage.
255 * 2. false: The EC event handling is automatically disabled as
256 * soon as the EC driver is stopped.
Lv Zheng750f628b2016-08-03 16:01:24 +0800257 */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800258 if (ec_freeze_events)
259 return acpi_ec_started(ec);
260 else
261 return test_bit(EC_FLAGS_STARTED, &ec->flags);
Lv Zheng750f628b2016-08-03 16:01:24 +0800262}
263
Lv Zheng9887d222015-02-06 08:57:59 +0800264static bool acpi_ec_flushed(struct acpi_ec *ec)
265{
266 return ec->reference_count == 1;
267}
268
Lv Zhengad479e72015-02-06 08:57:52 +0800269/* --------------------------------------------------------------------------
Lv Zhengca37bfd2015-02-05 16:27:22 +0800270 * EC Registers
Lv Zheng7a73e602014-10-14 14:24:01 +0800271 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400273static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300275 u8 x = inb(ec->command_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800276
Lv Zheng3535a3c2015-02-27 14:48:15 +0800277 ec_dbg_raw("EC_SC(R) = 0x%2.2x "
278 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
279 x,
280 !!(x & ACPI_EC_FLAG_SCI),
281 !!(x & ACPI_EC_FLAG_BURST),
282 !!(x & ACPI_EC_FLAG_CMD),
283 !!(x & ACPI_EC_FLAG_IBF),
284 !!(x & ACPI_EC_FLAG_OBF));
Márton Németh3ebe08a2007-11-21 03:23:26 +0300285 return x;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286}
287
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400288static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400289{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300290 u8 x = inb(ec->data_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800291
Lv Zhengd8d031a2015-05-15 14:16:42 +0800292 ec->timestamp = jiffies;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800293 ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400294 return x;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400295}
296
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400297static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400298{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800299 ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400300 outb(command, ec->command_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800301 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400302}
303
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400304static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400305{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800306 ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400307 outb(data, ec->data_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800308 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400309}
310
Lv Zheng4625d752017-06-14 13:59:18 +0800311#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
Lv Zhenge34c0e22014-10-14 14:23:49 +0800312static const char *acpi_ec_cmd_string(u8 cmd)
313{
314 switch (cmd) {
315 case 0x80:
316 return "RD_EC";
317 case 0x81:
318 return "WR_EC";
319 case 0x82:
320 return "BE_EC";
321 case 0x83:
322 return "BD_EC";
323 case 0x84:
324 return "QR_EC";
325 }
326 return "UNKNOWN";
327}
328#else
329#define acpi_ec_cmd_string(cmd) "UNDEF"
330#endif
331
Lv Zhengca37bfd2015-02-05 16:27:22 +0800332/* --------------------------------------------------------------------------
333 * GPE Registers
334 * -------------------------------------------------------------------------- */
335
Rafael J. Wysockid2a2e6c2020-11-23 20:00:25 +0100336static inline bool acpi_ec_gpe_status_set(struct acpi_ec *ec)
Lv Zhengca37bfd2015-02-05 16:27:22 +0800337{
338 acpi_event_status gpe_status = 0;
339
340 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
Rafael J. Wysockid2a2e6c2020-11-23 20:00:25 +0100341 return !!(gpe_status & ACPI_EVENT_FLAG_STATUS_SET);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800342}
343
344static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
345{
346 if (open)
347 acpi_enable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800348 else {
349 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800350 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800351 }
Rafael J. Wysockid2a2e6c2020-11-23 20:00:25 +0100352 if (acpi_ec_gpe_status_set(ec)) {
Lv Zhengca37bfd2015-02-05 16:27:22 +0800353 /*
354 * On some platforms, EN=1 writes cannot trigger GPE. So
355 * software need to manually trigger a pseudo GPE event on
356 * EN=1 writes.
357 */
Lv Zheng3535a3c2015-02-27 14:48:15 +0800358 ec_dbg_raw("Polling quirk");
Sebastian Andrzej Siewior2e84ea52020-11-13 19:13:17 +0100359 advance_transaction(ec, false);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800360 }
361}
362
363static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
364{
365 if (close)
366 acpi_disable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800367 else {
368 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800369 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800370 }
Lv Zhengca37bfd2015-02-05 16:27:22 +0800371}
372
Lv Zhengca37bfd2015-02-05 16:27:22 +0800373/* --------------------------------------------------------------------------
374 * Transaction Management
375 * -------------------------------------------------------------------------- */
376
Lv Zheng9887d222015-02-06 08:57:59 +0800377static void acpi_ec_submit_request(struct acpi_ec *ec)
378{
379 ec->reference_count++;
Daniel Drake4446abc2019-10-14 16:56:01 +0800380 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
Daniel Drake406857f2019-10-14 16:56:02 +0800381 ec->gpe >= 0 && ec->reference_count == 1)
Lv Zheng9887d222015-02-06 08:57:59 +0800382 acpi_ec_enable_gpe(ec, true);
383}
384
385static void acpi_ec_complete_request(struct acpi_ec *ec)
386{
387 bool flushed = false;
388
389 ec->reference_count--;
Daniel Drake4446abc2019-10-14 16:56:01 +0800390 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
Daniel Drake406857f2019-10-14 16:56:02 +0800391 ec->gpe >= 0 && ec->reference_count == 0)
Lv Zheng9887d222015-02-06 08:57:59 +0800392 acpi_ec_disable_gpe(ec, true);
393 flushed = acpi_ec_flushed(ec);
394 if (flushed)
395 wake_up(&ec->wait);
396}
397
Daniel Drake4446abc2019-10-14 16:56:01 +0800398static void acpi_ec_mask_events(struct acpi_ec *ec)
Lv Zhenge1d4d902015-02-06 08:58:05 +0800399{
Daniel Drake4446abc2019-10-14 16:56:01 +0800400 if (!test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
Daniel Drake406857f2019-10-14 16:56:02 +0800401 if (ec->gpe >= 0)
402 acpi_ec_disable_gpe(ec, false);
403 else
404 disable_irq_nosync(ec->irq);
405
Lv Zheng3535a3c2015-02-27 14:48:15 +0800406 ec_dbg_drv("Polling enabled");
Daniel Drake4446abc2019-10-14 16:56:01 +0800407 set_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800408 }
409}
410
Daniel Drake4446abc2019-10-14 16:56:01 +0800411static void acpi_ec_unmask_events(struct acpi_ec *ec)
Lv Zhenge1d4d902015-02-06 08:58:05 +0800412{
Daniel Drake4446abc2019-10-14 16:56:01 +0800413 if (test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
414 clear_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
Daniel Drake406857f2019-10-14 16:56:02 +0800415 if (ec->gpe >= 0)
416 acpi_ec_enable_gpe(ec, false);
417 else
418 enable_irq(ec->irq);
419
Lv Zheng3535a3c2015-02-27 14:48:15 +0800420 ec_dbg_drv("Polling disabled");
Lv Zhenge1d4d902015-02-06 08:58:05 +0800421 }
422}
423
Lv Zheng9887d222015-02-06 08:57:59 +0800424/*
425 * acpi_ec_submit_flushable_request() - Increase the reference count unless
426 * the flush operation is not in
427 * progress
428 * @ec: the EC device
429 *
430 * This function must be used before taking a new action that should hold
431 * the reference count. If this function returns false, then the action
432 * must be discarded or it will prevent the flush operation from being
433 * completed.
434 */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100435static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
Lv Zheng9887d222015-02-06 08:57:59 +0800436{
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100437 if (!acpi_ec_started(ec))
438 return false;
Lv Zheng9887d222015-02-06 08:57:59 +0800439 acpi_ec_submit_request(ec);
440 return true;
441}
442
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +0100443static void acpi_ec_submit_event(struct acpi_ec *ec)
Lv Zheng74443bb2015-01-14 19:28:47 +0800444{
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +0100445 /*
446 * It is safe to mask the events here, because acpi_ec_close_event()
447 * will run at least once after this.
448 */
Daniel Drake4446abc2019-10-14 16:56:01 +0800449 acpi_ec_mask_events(ec);
Lv Zheng1ab69f22017-06-14 13:59:09 +0800450 if (!acpi_ec_event_enabled(ec))
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +0100451 return;
Rafael J. Wysockica8283d2021-11-23 19:37:39 +0100452
Rafael J. Wysocki54b86142022-02-04 18:40:55 +0100453 if (ec->event_state != EC_EVENT_READY)
454 return;
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100455
Rafael J. Wysocki54b86142022-02-04 18:40:55 +0100456 ec_dbg_evt("Command(%s) submitted/blocked",
457 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Rafael J. Wysockic7935702021-11-23 19:43:05 +0100458
Rafael J. Wysocki54b86142022-02-04 18:40:55 +0100459 ec->event_state = EC_EVENT_IN_PROGRESS;
460 /*
461 * If events_to_process is greater than 0 at this point, the while ()
462 * loop in acpi_ec_event_handler() is still running and incrementing
463 * events_to_process will cause it to invoke acpi_ec_submit_query() once
464 * more, so it is not necessary to queue up the event work to start the
465 * same loop again.
466 */
467 if (ec->events_to_process++ > 0)
468 return;
469
470 ec->events_in_progress++;
471 queue_work(ec_wq, &ec->work);
Lv Zhengf252cb02015-02-06 08:58:10 +0800472}
473
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100474static void acpi_ec_complete_event(struct acpi_ec *ec)
475{
476 if (ec->event_state == EC_EVENT_IN_PROGRESS)
477 ec->event_state = EC_EVENT_COMPLETE;
478}
479
Rafael J. Wysockieafe7502021-11-23 19:42:02 +0100480static void acpi_ec_close_event(struct acpi_ec *ec)
Lv Zhengf252cb02015-02-06 08:58:10 +0800481{
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100482 if (ec->event_state != EC_EVENT_READY)
Lv Zheng9d8993b2015-06-11 13:21:32 +0800483 ec_dbg_evt("Command(%s) unblocked",
484 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100485
486 ec->event_state = EC_EVENT_READY;
Daniel Drake4446abc2019-10-14 16:56:01 +0800487 acpi_ec_unmask_events(ec);
Lv Zheng74443bb2015-01-14 19:28:47 +0800488}
489
Lv Zheng750f628b2016-08-03 16:01:24 +0800490static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
491{
492 if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
493 ec_log_drv("event unblocked");
Lv Zheng53c5eaa2017-09-26 16:54:03 +0800494 /*
495 * Unconditionally invoke this once after enabling the event
496 * handling mechanism to detect the pending events.
497 */
Sebastian Andrzej Siewior2e84ea52020-11-13 19:13:17 +0100498 advance_transaction(ec, false);
Lv Zheng750f628b2016-08-03 16:01:24 +0800499}
500
501static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
502{
503 if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
504 ec_log_drv("event blocked");
505}
506
Zhang Ruib6a3e142019-02-01 14:13:41 +0800507/*
508 * Process _Q events that might have accumulated in the EC.
509 * Run with locked ec mutex.
510 */
511static void acpi_ec_clear(struct acpi_ec *ec)
512{
Rafael J. Wysocki1f235042021-11-23 19:38:21 +0100513 int i;
Zhang Ruib6a3e142019-02-01 14:13:41 +0800514
515 for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
Rafael J. Wysockieafe7502021-11-23 19:42:02 +0100516 if (acpi_ec_submit_query(ec))
Zhang Ruib6a3e142019-02-01 14:13:41 +0800517 break;
518 }
519 if (unlikely(i == ACPI_EC_CLEAR_MAX))
520 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
521 else
522 pr_info("%d stale EC events cleared\n", i);
523}
524
Lv Zheng750f628b2016-08-03 16:01:24 +0800525static void acpi_ec_enable_event(struct acpi_ec *ec)
526{
527 unsigned long flags;
528
529 spin_lock_irqsave(&ec->lock, flags);
530 if (acpi_ec_started(ec))
531 __acpi_ec_enable_event(ec);
532 spin_unlock_irqrestore(&ec->lock, flags);
Zhang Ruib6a3e142019-02-01 14:13:41 +0800533
534 /* Drain additional events if hardware requires that */
535 if (EC_FLAGS_CLEAR_ON_RESUME)
536 acpi_ec_clear(ec);
Lv Zheng750f628b2016-08-03 16:01:24 +0800537}
538
Eric Biggerseab05ec2016-10-05 10:33:16 -0700539#ifdef CONFIG_PM_SLEEP
Rafael J. Wysocki016b87c2019-11-28 23:47:51 +0100540static void __acpi_ec_flush_work(void)
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800541{
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +0100542 flush_workqueue(ec_wq); /* flush ec->work */
Rafael J. Wysocki016b87c2019-11-28 23:47:51 +0100543 flush_workqueue(ec_query_wq); /* flush queries */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800544}
545
546static void acpi_ec_disable_event(struct acpi_ec *ec)
547{
548 unsigned long flags;
549
550 spin_lock_irqsave(&ec->lock, flags);
551 __acpi_ec_disable_event(ec);
552 spin_unlock_irqrestore(&ec->lock, flags);
Rafael J. Wysocki016b87c2019-11-28 23:47:51 +0100553
554 /*
555 * When ec_freeze_events is true, we need to flush events in
556 * the proper position before entering the noirq stage.
557 */
558 __acpi_ec_flush_work();
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800559}
Rafael J. Wysocki880a6622017-07-20 03:43:12 +0200560
561void acpi_ec_flush_work(void)
562{
Rafael J. Wysockif0ac20c2020-02-11 10:07:43 +0100563 /* Without ec_wq there is nothing to flush. */
564 if (!ec_wq)
Rafael J. Wysocki016b87c2019-11-28 23:47:51 +0100565 return;
Rafael J. Wysocki880a6622017-07-20 03:43:12 +0200566
Rafael J. Wysocki016b87c2019-11-28 23:47:51 +0100567 __acpi_ec_flush_work();
Rafael J. Wysocki880a6622017-07-20 03:43:12 +0200568}
Eric Biggerseab05ec2016-10-05 10:33:16 -0700569#endif /* CONFIG_PM_SLEEP */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800570
Lv Zheng1d68d262015-06-11 13:21:38 +0800571static bool acpi_ec_guard_event(struct acpi_ec *ec)
572{
Lv Zheng61197542015-09-24 14:54:54 +0800573 unsigned long flags;
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100574 bool guarded;
Lv Zheng61197542015-09-24 14:54:54 +0800575
576 spin_lock_irqsave(&ec->lock, flags);
577 /*
578 * If firmware SCI_EVT clearing timing is "event", we actually
579 * don't know when the SCI_EVT will be cleared by firmware after
580 * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
581 * acceptable period.
582 *
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100583 * The guarding period is applicable if the event state is not
584 * EC_EVENT_READY, but otherwise if the current transaction is of the
585 * ACPI_EC_COMMAND_QUERY type, the guarding should have elapsed already
586 * and it should not be applied to let the transaction transition into
587 * the ACPI_EC_COMMAND_POLL state immediately.
Lv Zheng61197542015-09-24 14:54:54 +0800588 */
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100589 guarded = ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
590 ec->event_state != EC_EVENT_READY &&
591 (!ec->curr || ec->curr->command != ACPI_EC_COMMAND_QUERY);
Lv Zheng61197542015-09-24 14:54:54 +0800592 spin_unlock_irqrestore(&ec->lock, flags);
593 return guarded;
Lv Zheng1d68d262015-06-11 13:21:38 +0800594}
595
Lv Zhengd8d031a2015-05-15 14:16:42 +0800596static int ec_transaction_polled(struct acpi_ec *ec)
597{
598 unsigned long flags;
599 int ret = 0;
600
601 spin_lock_irqsave(&ec->lock, flags);
602 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
603 ret = 1;
604 spin_unlock_irqrestore(&ec->lock, flags);
605 return ret;
606}
607
Lv Zhengf92fca02014-06-15 08:41:35 +0800608static int ec_transaction_completed(struct acpi_ec *ec)
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400609{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400610 unsigned long flags;
611 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800612
Feng Tangf351d022012-10-23 01:29:27 +0200613 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengc0d65342014-06-15 08:42:07 +0800614 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400615 ret = 1;
Feng Tangf351d022012-10-23 01:29:27 +0200616 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400617 return ret;
618}
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400619
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800620static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
621{
622 ec->curr->flags |= flag;
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100623
624 if (ec->curr->command != ACPI_EC_COMMAND_QUERY)
625 return;
626
627 switch (ec_event_clearing) {
628 case ACPI_EC_EVT_TIMING_STATUS:
629 if (flag == ACPI_EC_COMMAND_POLL)
Rafael J. Wysockieafe7502021-11-23 19:42:02 +0100630 acpi_ec_close_event(ec);
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100631
632 return;
633
634 case ACPI_EC_EVT_TIMING_QUERY:
635 if (flag == ACPI_EC_COMMAND_COMPLETE)
Rafael J. Wysockieafe7502021-11-23 19:42:02 +0100636 acpi_ec_close_event(ec);
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100637
638 return;
639
640 case ACPI_EC_EVT_TIMING_EVENT:
641 if (flag == ACPI_EC_COMMAND_COMPLETE)
642 acpi_ec_complete_event(ec);
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800643 }
644}
645
Rafael J. Wysocki631734f2020-11-23 20:00:42 +0100646static void acpi_ec_spurious_interrupt(struct acpi_ec *ec, struct transaction *t)
647{
648 if (t->irq_count < ec_storm_threshold)
649 ++t->irq_count;
650
651 /* Trigger if the threshold is 0 too. */
652 if (t->irq_count == ec_storm_threshold)
653 acpi_ec_mask_events(ec);
654}
655
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +0100656static void advance_transaction(struct acpi_ec *ec, bool interrupt)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400657{
Rafael J. Wysocki902675f2020-11-23 20:00:34 +0100658 struct transaction *t = ec->curr;
Lv Zhengc0d65342014-06-15 08:42:07 +0800659 bool wakeup = false;
Rafael J. Wysocki902675f2020-11-23 20:00:34 +0100660 u8 status;
Feng Tangb76b51b2012-10-23 01:29:38 +0200661
Sebastian Andrzej Siewior2e84ea52020-11-13 19:13:17 +0100662 ec_dbg_stm("%s (%d)", interrupt ? "IRQ" : "TASK", smp_processor_id());
Rafael J. Wysockid269fb032020-11-23 20:00:18 +0100663
Lv Zhengca37bfd2015-02-05 16:27:22 +0800664 /*
Rafael J. Wysockid269fb032020-11-23 20:00:18 +0100665 * Clear GPE_STS upfront to allow subsequent hardware GPE_STS 0->1
666 * changes to always trigger a GPE interrupt.
667 *
668 * GPE STS is a W1C register, which means:
669 *
670 * 1. Software can clear it without worrying about clearing the other
671 * GPEs' STS bits when the hardware sets them in parallel.
672 *
673 * 2. As long as software can ensure only clearing it when it is set,
674 * hardware won't set it in parallel.
Lv Zhengca37bfd2015-02-05 16:27:22 +0800675 */
Rafael J. Wysockid2a2e6c2020-11-23 20:00:25 +0100676 if (ec->gpe >= 0 && acpi_ec_gpe_status_set(ec))
Rafael J. Wysockid269fb032020-11-23 20:00:18 +0100677 acpi_clear_gpe(NULL, ec->gpe);
Daniel Drake406857f2019-10-14 16:56:02 +0800678
Lv Zheng66b42b72014-06-15 08:41:17 +0800679 status = acpi_ec_read_status(ec);
Rafael J. Wysocki902675f2020-11-23 20:00:34 +0100680
Lv Zheng1d68d262015-06-11 13:21:38 +0800681 /*
682 * Another IRQ or a guarded polling mode advancement is detected,
683 * the next QR_EC submission is then allowed.
684 */
685 if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
686 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100687 ec->event_state == EC_EVENT_COMPLETE)
Rafael J. Wysockieafe7502021-11-23 19:42:02 +0100688 acpi_ec_close_event(ec);
Rafael J. Wysockic33676a2021-11-23 19:44:46 +0100689
Rafael J. Wysocki902675f2020-11-23 20:00:34 +0100690 if (!t)
691 goto out;
Lv Zheng1d68d262015-06-11 13:21:38 +0800692 }
Rafael J. Wysocki902675f2020-11-23 20:00:34 +0100693
Lv Zhengf92fca02014-06-15 08:41:35 +0800694 if (t->flags & ACPI_EC_COMMAND_POLL) {
695 if (t->wlen > t->wi) {
Rafael J. Wysocki2a39a302020-11-23 20:01:01 +0100696 if (!(status & ACPI_EC_FLAG_IBF))
Lv Zhengf92fca02014-06-15 08:41:35 +0800697 acpi_ec_write_data(ec, t->wdata[t->wi++]);
Rafael J. Wysocki631734f2020-11-23 20:00:42 +0100698 else if (interrupt && !(status & ACPI_EC_FLAG_SCI))
699 acpi_ec_spurious_interrupt(ec, t);
Lv Zhengf92fca02014-06-15 08:41:35 +0800700 } else if (t->rlen > t->ri) {
Rafael J. Wysocki2a39a302020-11-23 20:01:01 +0100701 if (status & ACPI_EC_FLAG_OBF) {
Lv Zhengf92fca02014-06-15 08:41:35 +0800702 t->rdata[t->ri++] = acpi_ec_read_data(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +0800703 if (t->rlen == t->ri) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800704 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Rafael J. Wysocki2a39a302020-11-23 20:01:01 +0100705 wakeup = true;
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800706 if (t->command == ACPI_EC_COMMAND_QUERY)
Lv Zheng9d8993b2015-06-11 13:21:32 +0800707 ec_dbg_evt("Command(%s) completed by hardware",
708 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zhengc0d65342014-06-15 08:42:07 +0800709 }
Rafael J. Wysocki631734f2020-11-23 20:00:42 +0100710 } else if (interrupt && !(status & ACPI_EC_FLAG_SCI)) {
711 acpi_ec_spurious_interrupt(ec, t);
712 }
Rafael J. Wysocki2a39a302020-11-23 20:01:01 +0100713 } else if (t->wlen == t->wi && !(status & ACPI_EC_FLAG_IBF)) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800714 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zhengc0d65342014-06-15 08:42:07 +0800715 wakeup = true;
716 }
Rafael J. Wysockib1e14992020-03-06 00:17:55 +0100717 } else if (!(status & ACPI_EC_FLAG_IBF)) {
718 acpi_ec_write_cmd(ec, t->command);
719 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
Lv Zhengf92fca02014-06-15 08:41:35 +0800720 }
Rafael J. Wysocki902675f2020-11-23 20:00:34 +0100721
Lv Zheng0c788082015-01-14 19:28:22 +0800722out:
Lv Zheng74443bb2015-01-14 19:28:47 +0800723 if (status & ACPI_EC_FLAG_SCI)
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +0100724 acpi_ec_submit_event(ec);
Rafael J. Wysocki2a39a302020-11-23 20:01:01 +0100725
Sebastian Andrzej Siewior2e84ea52020-11-13 19:13:17 +0100726 if (wakeup && interrupt)
Lv Zheng0c788082015-01-14 19:28:22 +0800727 wake_up(&ec->wait);
Lv Zhengf92fca02014-06-15 08:41:35 +0800728}
Feng Tanga3cd8d22012-10-23 01:30:12 +0200729
Lv Zhengf92fca02014-06-15 08:41:35 +0800730static void start_transaction(struct acpi_ec *ec)
731{
732 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
733 ec->curr->flags = 0;
Lv Zhengd8d031a2015-05-15 14:16:42 +0800734}
735
736static int ec_guard(struct acpi_ec *ec)
737{
Lv Zhengc3a696b2017-01-20 16:42:48 +0800738 unsigned long guard = usecs_to_jiffies(ec->polling_guard);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800739 unsigned long timeout = ec->timestamp + guard;
740
Lv Zheng61197542015-09-24 14:54:54 +0800741 /* Ensure guarding period before polling EC status */
Lv Zhengd8d031a2015-05-15 14:16:42 +0800742 do {
Lv Zhengc3a696b2017-01-20 16:42:48 +0800743 if (ec->busy_polling) {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800744 /* Perform busy polling */
745 if (ec_transaction_completed(ec))
746 return 0;
747 udelay(jiffies_to_usecs(guard));
748 } else {
749 /*
750 * Perform wait polling
Lv Zheng61197542015-09-24 14:54:54 +0800751 * 1. Wait the transaction to be completed by the
752 * GPE handler after the transaction enters
753 * ACPI_EC_COMMAND_POLL state.
754 * 2. A special guarding logic is also required
755 * for event clearing mode "event" before the
756 * transaction enters ACPI_EC_COMMAND_POLL
757 * state.
Lv Zhengd8d031a2015-05-15 14:16:42 +0800758 */
Lv Zheng1d68d262015-06-11 13:21:38 +0800759 if (!ec_transaction_polled(ec) &&
760 !acpi_ec_guard_event(ec))
Lv Zhengd8d031a2015-05-15 14:16:42 +0800761 break;
762 if (wait_event_timeout(ec->wait,
763 ec_transaction_completed(ec),
764 guard))
765 return 0;
766 }
Lv Zhengd8d031a2015-05-15 14:16:42 +0800767 } while (time_before(jiffies, timeout));
768 return -ETIME;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400769}
770
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400771static int ec_poll(struct acpi_ec *ec)
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300772{
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400773 unsigned long flags;
Lan Tianyu28fe5c82013-05-06 03:23:40 +0000774 int repeat = 5; /* number of command restarts */
Lv Zheng7a73e602014-10-14 14:24:01 +0800775
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400776 while (repeat--) {
777 unsigned long delay = jiffies +
Thomas Renninger7a18e962010-10-21 18:24:57 +0200778 msecs_to_jiffies(ec_delay);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400779 do {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800780 if (!ec_guard(ec))
781 return 0;
Lv Zhengf92fca02014-06-15 08:41:35 +0800782 spin_lock_irqsave(&ec->lock, flags);
Sebastian Andrzej Siewior2e84ea52020-11-13 19:13:17 +0100783 advance_transaction(ec, false);
Lv Zhengf92fca02014-06-15 08:41:35 +0800784 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400785 } while (time_before(jiffies, delay));
Lan Tianyu16a26e82013-09-12 03:32:04 -0400786 pr_debug("controller reset, restart transaction\n");
Feng Tangf351d022012-10-23 01:29:27 +0200787 spin_lock_irqsave(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400788 start_transaction(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200789 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiyaf3fd142006-12-07 18:42:16 +0300790 }
Alexey Starikovskiyb77d81b2008-03-21 17:07:15 +0300791 return -ETIME;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500792}
793
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400794static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400795 struct transaction *t)
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400796{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400797 unsigned long tmp;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400798 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800799
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400800 /* start transaction */
Feng Tangf351d022012-10-23 01:29:27 +0200801 spin_lock_irqsave(&ec->lock, tmp);
Lv Zheng9887d222015-02-06 08:57:59 +0800802 /* Enable GPE for command processing (IBF=0/OBF=1) */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100803 if (!acpi_ec_submit_flushable_request(ec)) {
Lv Zhengad479e72015-02-06 08:57:52 +0800804 ret = -EINVAL;
805 goto unlock;
806 }
Lv Zheng770970f2015-02-27 14:48:24 +0800807 ec_dbg_ref(ec, "Increase command");
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400808 /* following two actions should be kept atomic */
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400809 ec->curr = t;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800810 ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300811 start_transaction(ec);
Lv Zhengdf9ff912014-10-29 11:33:43 +0800812 spin_unlock_irqrestore(&ec->lock, tmp);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800813
Lv Zhengdf9ff912014-10-29 11:33:43 +0800814 ret = ec_poll(ec);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800815
Lv Zhengdf9ff912014-10-29 11:33:43 +0800816 spin_lock_irqsave(&ec->lock, tmp);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800817 if (t->irq_count == ec_storm_threshold)
Daniel Drake4446abc2019-10-14 16:56:01 +0800818 acpi_ec_unmask_events(ec);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800819 ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400820 ec->curr = NULL;
Lv Zheng9887d222015-02-06 08:57:59 +0800821 /* Disable GPE for command processing (IBF=0/OBF=1) */
822 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800823 ec_dbg_ref(ec, "Decrease command");
Lv Zhengad479e72015-02-06 08:57:52 +0800824unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200825 spin_unlock_irqrestore(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400826 return ret;
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400827}
828
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400829static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
Luming Yu45bea152005-07-23 04:08:00 -0400830{
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400831 int status;
Len Brown50526df2005-08-11 17:32:05 -0400832 u32 glk;
Lv Zheng7a73e602014-10-14 14:24:01 +0800833
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400834 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
Patrick Mocheld550d982006-06-27 00:41:40 -0400835 return -EINVAL;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400836 if (t->rdata)
837 memset(t->rdata, 0, t->rlen);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800838
Feng Tangf351d022012-10-23 01:29:27 +0200839 mutex_lock(&ec->mutex);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400840 if (ec->global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300842 if (ACPI_FAILURE(status)) {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400843 status = -ENODEV;
844 goto unlock;
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 }
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300847
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400848 status = acpi_ec_transaction_unlocked(ec, t);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300849
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400850 if (ec->global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 acpi_release_global_lock(glk);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400852unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200853 mutex_unlock(&ec->mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400854 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855}
856
Roel Kluin8a383ef2008-12-09 20:45:30 +0100857static int acpi_ec_burst_enable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300858{
859 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400860 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
861 .wdata = NULL, .rdata = &d,
862 .wlen = 0, .rlen = 1};
863
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400864 return acpi_ec_transaction(ec, &t);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300865}
866
Roel Kluin8a383ef2008-12-09 20:45:30 +0100867static int acpi_ec_burst_disable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300868{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400869 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
870 .wdata = NULL, .rdata = NULL,
871 .wlen = 0, .rlen = 0};
872
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400873 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400874 acpi_ec_transaction(ec, &t) : 0;
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300875}
876
Lv Zheng7a73e602014-10-14 14:24:01 +0800877static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400878{
879 int result;
880 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400881 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
882 .wdata = &address, .rdata = &d,
883 .wlen = 1, .rlen = 1};
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400884
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400885 result = acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400886 *data = d;
887 return result;
888}
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400889
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400890static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
891{
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300892 u8 wdata[2] = { address, data };
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400893 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
894 .wdata = wdata, .rdata = NULL,
895 .wlen = 2, .rlen = 0};
896
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400897 return acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400898}
899
Feng Tangb76b51b2012-10-23 01:29:38 +0200900int ec_read(u8 addr, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 int err;
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400903 u8 temp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905 if (!first_ec)
906 return -ENODEV;
907
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300908 err = acpi_ec_read(first_ec, addr, &temp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
910 if (!err) {
911 *val = temp_data;
912 return 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800913 }
914 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915}
916EXPORT_SYMBOL(ec_read);
917
Len Brown50526df2005-08-11 17:32:05 -0400918int ec_write(u8 addr, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 if (!first_ec)
921 return -ENODEV;
922
ye xingchenb3c0e382022-08-25 07:27:44 +0000923 return acpi_ec_write(first_ec, addr, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924}
925EXPORT_SYMBOL(ec_write);
926
Randy Dunlap616362d2006-10-27 01:47:34 -0400927int ec_transaction(u8 command,
Lv Zheng7a73e602014-10-14 14:24:01 +0800928 const u8 *wdata, unsigned wdata_len,
929 u8 *rdata, unsigned rdata_len)
Luming Yu45bea152005-07-23 04:08:00 -0400930{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400931 struct transaction t = {.command = command,
932 .wdata = wdata, .rdata = rdata,
933 .wlen = wdata_len, .rlen = rdata_len};
Lv Zheng7a73e602014-10-14 14:24:01 +0800934
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400935 if (!first_ec)
936 return -ENODEV;
937
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400938 return acpi_ec_transaction(first_ec, &t);
Luming Yu45bea152005-07-23 04:08:00 -0400939}
Lennart Poetteringab9e43c2006-10-03 22:49:00 -0400940EXPORT_SYMBOL(ec_transaction);
941
Seth Forshee3e2abc52012-01-18 13:44:08 -0600942/* Get the handle to the EC device */
943acpi_handle ec_get_handle(void)
944{
945 if (!first_ec)
946 return NULL;
947 return first_ec->handle;
948}
Seth Forshee3e2abc52012-01-18 13:44:08 -0600949EXPORT_SYMBOL(ec_get_handle);
950
Lv Zhengad479e72015-02-06 08:57:52 +0800951static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
952{
953 unsigned long flags;
954
955 spin_lock_irqsave(&ec->lock, flags);
956 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800957 ec_dbg_drv("Starting EC");
Lv Zheng9887d222015-02-06 08:57:59 +0800958 /* Enable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800959 if (!resuming) {
Lv Zheng9887d222015-02-06 08:57:59 +0800960 acpi_ec_submit_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800961 ec_dbg_ref(ec, "Increase driver");
Lv Zhengc2b46d62016-08-03 16:01:36 +0800962 }
Lv Zheng3535a3c2015-02-27 14:48:15 +0800963 ec_log_drv("EC started");
Lv Zhengad479e72015-02-06 08:57:52 +0800964 }
965 spin_unlock_irqrestore(&ec->lock, flags);
966}
967
Lv Zheng9887d222015-02-06 08:57:59 +0800968static bool acpi_ec_stopped(struct acpi_ec *ec)
969{
970 unsigned long flags;
971 bool flushed;
972
973 spin_lock_irqsave(&ec->lock, flags);
974 flushed = acpi_ec_flushed(ec);
975 spin_unlock_irqrestore(&ec->lock, flags);
976 return flushed;
977}
978
Lv Zhengad479e72015-02-06 08:57:52 +0800979static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
980{
981 unsigned long flags;
982
983 spin_lock_irqsave(&ec->lock, flags);
984 if (acpi_ec_started(ec)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800985 ec_dbg_drv("Stopping EC");
Lv Zhengad479e72015-02-06 08:57:52 +0800986 set_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng9887d222015-02-06 08:57:59 +0800987 spin_unlock_irqrestore(&ec->lock, flags);
988 wait_event(ec->wait, acpi_ec_stopped(ec));
989 spin_lock_irqsave(&ec->lock, flags);
990 /* Disable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800991 if (!suspending) {
Lv Zheng9887d222015-02-06 08:57:59 +0800992 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800993 ec_dbg_ref(ec, "Decrease driver");
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800994 } else if (!ec_freeze_events)
Lv Zheng750f628b2016-08-03 16:01:24 +0800995 __acpi_ec_disable_event(ec);
Lv Zhengad479e72015-02-06 08:57:52 +0800996 clear_bit(EC_FLAGS_STARTED, &ec->flags);
997 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800998 ec_log_drv("EC stopped");
Lv Zhengad479e72015-02-06 08:57:52 +0800999 }
1000 spin_unlock_irqrestore(&ec->lock, flags);
1001}
1002
Lv Zhengc3a696b2017-01-20 16:42:48 +08001003static void acpi_ec_enter_noirq(struct acpi_ec *ec)
1004{
1005 unsigned long flags;
1006
1007 spin_lock_irqsave(&ec->lock, flags);
1008 ec->busy_polling = true;
1009 ec->polling_guard = 0;
1010 ec_log_drv("interrupt blocked");
1011 spin_unlock_irqrestore(&ec->lock, flags);
1012}
1013
1014static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1015{
1016 unsigned long flags;
1017
1018 spin_lock_irqsave(&ec->lock, flags);
1019 ec->busy_polling = ec_busy_polling;
1020 ec->polling_guard = ec_polling_guard;
1021 ec_log_drv("interrupt unblocked");
1022 spin_unlock_irqrestore(&ec->lock, flags);
1023}
1024
Rafael J. Wysockife955682010-04-09 01:40:38 +02001025void acpi_ec_block_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001026{
1027 struct acpi_ec *ec = first_ec;
1028
1029 if (!ec)
1030 return;
1031
Feng Tangf351d022012-10-23 01:29:27 +02001032 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001033 /* Prevent transactions from being carried out */
Lv Zhengad479e72015-02-06 08:57:52 +08001034 acpi_ec_stop(ec, true);
Feng Tangf351d022012-10-23 01:29:27 +02001035 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001036}
1037
Rafael J. Wysockife955682010-04-09 01:40:38 +02001038void acpi_ec_unblock_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001039{
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001040 /*
1041 * Allow transactions to happen again (this function is called from
1042 * atomic context during wakeup, so we don't need to acquire the mutex).
1043 */
1044 if (first_ec)
Lv Zhengad479e72015-02-06 08:57:52 +08001045 acpi_ec_start(first_ec, true);
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001046}
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048/* --------------------------------------------------------------------------
1049 Event Management
1050 -------------------------------------------------------------------------- */
Lv Zheng01305d42015-01-14 19:28:28 +08001051static struct acpi_ec_query_handler *
Lv Zheng0700c042015-09-24 14:54:48 +08001052acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1053{
1054 struct acpi_ec_query_handler *handler;
Lv Zheng0700c042015-09-24 14:54:48 +08001055
1056 mutex_lock(&ec->mutex);
1057 list_for_each_entry(handler, &ec->list, node) {
1058 if (value == handler->query_bit) {
Rafael J. Wysocki3df663a2019-12-27 11:04:21 +01001059 kref_get(&handler->kref);
1060 mutex_unlock(&ec->mutex);
1061 return handler;
Lv Zheng0700c042015-09-24 14:54:48 +08001062 }
1063 }
1064 mutex_unlock(&ec->mutex);
Rafael J. Wysocki3df663a2019-12-27 11:04:21 +01001065 return NULL;
Lv Zheng0700c042015-09-24 14:54:48 +08001066}
1067
Lv Zheng01305d42015-01-14 19:28:28 +08001068static void acpi_ec_query_handler_release(struct kref *kref)
1069{
1070 struct acpi_ec_query_handler *handler =
1071 container_of(kref, struct acpi_ec_query_handler, kref);
1072
1073 kfree(handler);
1074}
1075
1076static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1077{
1078 kref_put(&handler->kref, acpi_ec_query_handler_release);
1079}
1080
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001081int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1082 acpi_handle handle, acpi_ec_query_func func,
1083 void *data)
1084{
1085 struct acpi_ec_query_handler *handler =
1086 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001087
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001088 if (!handler)
1089 return -ENOMEM;
1090
1091 handler->query_bit = query_bit;
1092 handler->handle = handle;
1093 handler->func = func;
1094 handler->data = data;
Feng Tangf351d022012-10-23 01:29:27 +02001095 mutex_lock(&ec->mutex);
Lv Zheng01305d42015-01-14 19:28:28 +08001096 kref_init(&handler->kref);
Alexey Starikovskiy30c08572007-09-26 19:43:22 +04001097 list_add(&handler->node, &ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001098 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001099 return 0;
1100}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001101EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1102
Lv Zheng0700c042015-09-24 14:54:48 +08001103static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1104 bool remove_all, u8 query_bit)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001105{
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001106 struct acpi_ec_query_handler *handler, *tmp;
Lv Zheng01305d42015-01-14 19:28:28 +08001107 LIST_HEAD(free_list);
Lv Zheng7a73e602014-10-14 14:24:01 +08001108
Feng Tangf351d022012-10-23 01:29:27 +02001109 mutex_lock(&ec->mutex);
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001110 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
Lv Zheng0700c042015-09-24 14:54:48 +08001111 if (remove_all || query_bit == handler->query_bit) {
Lv Zheng01305d42015-01-14 19:28:28 +08001112 list_del_init(&handler->node);
1113 list_add(&handler->node, &free_list);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001114 }
1115 }
Feng Tangf351d022012-10-23 01:29:27 +02001116 mutex_unlock(&ec->mutex);
Chris Bainbridge6b5eab52015-04-22 00:25:36 +01001117 list_for_each_entry_safe(handler, tmp, &free_list, node)
Lv Zheng01305d42015-01-14 19:28:28 +08001118 acpi_ec_put_query_handler(handler);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001119}
Lv Zheng0700c042015-09-24 14:54:48 +08001120
1121void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1122{
1123 acpi_ec_remove_query_handlers(ec, false, query_bit);
1124}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001125EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Lv Zheng02b771b2015-08-12 11:12:02 +08001127static void acpi_ec_event_processor(struct work_struct *work)
1128{
1129 struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1130 struct acpi_ec_query_handler *handler = q->handler;
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001131 struct acpi_ec *ec = q->ec;
Lv Zheng02b771b2015-08-12 11:12:02 +08001132
Lv Zheng3535a3c2015-02-27 14:48:15 +08001133 ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001134
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001135 if (handler->func)
1136 handler->func(handler->data);
1137 else if (handler->handle)
1138 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001139
Lv Zheng3535a3c2015-02-27 14:48:15 +08001140 ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001141
1142 spin_lock_irq(&ec->lock);
1143 ec->queries_in_progress--;
1144 spin_unlock_irq(&ec->lock);
1145
Rafael J. Wysockibefd9b52021-11-23 19:46:09 +01001146 acpi_ec_put_query_handler(handler);
1147 kfree(q);
1148}
1149
1150static struct acpi_ec_query *acpi_ec_create_query(struct acpi_ec *ec, u8 *pval)
1151{
1152 struct acpi_ec_query *q;
1153 struct transaction *t;
1154
1155 q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1156 if (!q)
1157 return NULL;
1158
1159 INIT_WORK(&q->work, acpi_ec_event_processor);
1160 t = &q->transaction;
1161 t->command = ACPI_EC_COMMAND_QUERY;
1162 t->rdata = pval;
1163 t->rlen = 1;
1164 q->ec = ec;
1165 return q;
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001166}
1167
Rafael J. Wysockieafe7502021-11-23 19:42:02 +01001168static int acpi_ec_submit_query(struct acpi_ec *ec)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001169{
Rafael J. Wysocki1f235042021-11-23 19:38:21 +01001170 struct acpi_ec_query *q;
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001171 u8 value = 0;
Lv Zhengc2cf5762015-01-14 19:28:33 +08001172 int result;
Lv Zheng02b771b2015-08-12 11:12:02 +08001173
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001174 q = acpi_ec_create_query(ec, &value);
Lv Zheng02b771b2015-08-12 11:12:02 +08001175 if (!q)
1176 return -ENOMEM;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301177
Lv Zheng550b3aac2015-01-14 19:28:53 +08001178 /*
1179 * Query the EC to find out which _Qxx method we need to evaluate.
1180 * Note that successful completion of the query causes the ACPI_EC_SCI
1181 * bit to be cleared (and thus clearing the interrupt source).
1182 */
Lv Zheng02b771b2015-08-12 11:12:02 +08001183 result = acpi_ec_transaction(ec, &q->transaction);
Lv Zheng02b771b2015-08-12 11:12:02 +08001184 if (result)
1185 goto err_exit;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301186
Rafael J. Wysocki1f235042021-11-23 19:38:21 +01001187 if (!value) {
1188 result = -ENODATA;
1189 goto err_exit;
1190 }
1191
Lv Zheng0700c042015-09-24 14:54:48 +08001192 q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1193 if (!q->handler) {
1194 result = -ENODATA;
1195 goto err_exit;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001196 }
Lv Zheng0700c042015-09-24 14:54:48 +08001197
1198 /*
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001199 * It is reported that _Qxx are evaluated in a parallel way on Windows:
Lv Zheng0700c042015-09-24 14:54:48 +08001200 * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1201 *
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001202 * Put this log entry before queue_work() to make it appear in the log
1203 * before any other messages emitted during workqueue handling.
Lv Zheng0700c042015-09-24 14:54:48 +08001204 */
1205 ec_dbg_evt("Query(0x%02x) scheduled", value);
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001206
1207 spin_lock_irq(&ec->lock);
1208
1209 ec->queries_in_progress++;
1210 queue_work(ec_query_wq, &q->work);
1211
1212 spin_unlock_irq(&ec->lock);
Lv Zheng02b771b2015-08-12 11:12:02 +08001213
Rafael J. Wysockibefd9b52021-11-23 19:46:09 +01001214 return 0;
1215
Lv Zheng02b771b2015-08-12 11:12:02 +08001216err_exit:
Rafael J. Wysockibefd9b52021-11-23 19:46:09 +01001217 kfree(q);
Rafael J. Wysocki1f235042021-11-23 19:38:21 +01001218
Lv Zhengc2cf5762015-01-14 19:28:33 +08001219 return result;
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001220}
1221
Lv Zheng9d8993b2015-06-11 13:21:32 +08001222static void acpi_ec_event_handler(struct work_struct *work)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001223{
Lv Zheng74443bb2015-01-14 19:28:47 +08001224 struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
Lv Zheng7a73e602014-10-14 14:24:01 +08001225
Lv Zheng9d8993b2015-06-11 13:21:32 +08001226 ec_dbg_evt("Event started");
1227
Rafael J. Wysockia105acd2021-11-23 19:40:50 +01001228 spin_lock_irq(&ec->lock);
1229
Rafael J. Wysockic7935702021-11-23 19:43:05 +01001230 while (ec->events_to_process) {
Rafael J. Wysockia105acd2021-11-23 19:40:50 +01001231 spin_unlock_irq(&ec->lock);
Rafael J. Wysocki1f235042021-11-23 19:38:21 +01001232
Rafael J. Wysockieafe7502021-11-23 19:42:02 +01001233 acpi_ec_submit_query(ec);
Rafael J. Wysocki1f235042021-11-23 19:38:21 +01001234
Rafael J. Wysockia105acd2021-11-23 19:40:50 +01001235 spin_lock_irq(&ec->lock);
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001236
Rafael J. Wysockic7935702021-11-23 19:43:05 +01001237 ec->events_to_process--;
Lv Zheng9d8993b2015-06-11 13:21:32 +08001238 }
Rafael J. Wysocki388fb772021-11-23 19:40:04 +01001239
1240 /*
1241 * Before exit, make sure that the it will be possible to queue up the
1242 * event handling work again regardless of whether or not the query
1243 * queued up above is processed successfully.
1244 */
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001245 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1246 bool guard_timeout;
1247
Rafael J. Wysockic33676a2021-11-23 19:44:46 +01001248 acpi_ec_complete_event(ec);
Rafael J. Wysocki388fb772021-11-23 19:40:04 +01001249
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001250 ec_dbg_evt("Event stopped");
Lv Zheng9d8993b2015-06-11 13:21:32 +08001251
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001252 spin_unlock_irq(&ec->lock);
Lv Zheng1d68d262015-06-11 13:21:38 +08001253
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001254 guard_timeout = !!ec_guard(ec);
1255
Rafael J. Wysockia105acd2021-11-23 19:40:50 +01001256 spin_lock_irq(&ec->lock);
Rafael J. Wysocki98d36452021-11-23 19:39:05 +01001257
1258 /* Take care of SCI_EVT unless someone else is doing that. */
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001259 if (guard_timeout && !ec->curr)
Rafael J. Wysocki98d36452021-11-23 19:39:05 +01001260 advance_transaction(ec, false);
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001261 } else {
1262 acpi_ec_close_event(ec);
Rafael J. Wysocki98d36452021-11-23 19:39:05 +01001263
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001264 ec_dbg_evt("Event stopped");
Rafael J. Wysocki98d36452021-11-23 19:39:05 +01001265 }
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001266
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01001267 ec->events_in_progress--;
Rafael J. Wysocki13a62d02022-02-04 18:43:14 +01001268
Rafael J. Wysockia105acd2021-11-23 19:40:50 +01001269 spin_unlock_irq(&ec->lock);
Luming Yu45bea152005-07-23 04:08:00 -04001270}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Daniel Drake406857f2019-10-14 16:56:02 +08001272static void acpi_ec_handle_interrupt(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273{
Lv Zhengf92fca02014-06-15 08:41:35 +08001274 unsigned long flags;
Lennart Poettering00eb43a2007-05-04 14:16:19 +02001275
Lv Zhengf92fca02014-06-15 08:41:35 +08001276 spin_lock_irqsave(&ec->lock, flags);
Sebastian Andrzej Siewior2e84ea52020-11-13 19:13:17 +01001277 advance_transaction(ec, true);
Lv Zhengc0d65342014-06-15 08:42:07 +08001278 spin_unlock_irqrestore(&ec->lock, flags);
Daniel Drake406857f2019-10-14 16:56:02 +08001279}
1280
1281static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1282 u32 gpe_number, void *data)
1283{
1284 acpi_ec_handle_interrupt(data);
Lv Zhengca37bfd2015-02-05 16:27:22 +08001285 return ACPI_INTERRUPT_HANDLED;
Alexey Starikovskiy845625c2008-03-21 17:07:03 +03001286}
1287
Daniel Drake406857f2019-10-14 16:56:02 +08001288static irqreturn_t acpi_ec_irq_handler(int irq, void *data)
1289{
1290 acpi_ec_handle_interrupt(data);
1291 return IRQ_HANDLED;
1292}
1293
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001295 * Address Space Management
1296 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
1298static acpi_status
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001299acpi_ec_space_handler(u32 function, acpi_physical_address address,
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001300 u32 bits, u64 *value64,
Len Brown50526df2005-08-11 17:32:05 -04001301 void *handler_context, void *region_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302{
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +03001303 struct acpi_ec *ec = handler_context;
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001304 int result = 0, i, bytes = bits / 8;
1305 u8 *value = (u8 *)value64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 if ((address > 0xFF) || !value || !handler_context)
Patrick Mocheld550d982006-06-27 00:41:40 -04001308 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001310 if (function != ACPI_READ && function != ACPI_WRITE)
Patrick Mocheld550d982006-06-27 00:41:40 -04001311 return AE_BAD_PARAMETER;
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001312
Lv Zhengc3a696b2017-01-20 16:42:48 +08001313 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001314 acpi_ec_burst_enable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001315
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001316 for (i = 0; i < bytes; ++i, ++address, ++value)
1317 result = (function == ACPI_READ) ?
1318 acpi_ec_read(ec, address, value) :
1319 acpi_ec_write(ec, address, *value);
Alexey Starikovskiy3e71a872008-01-11 02:42:51 +03001320
Lv Zhengc3a696b2017-01-20 16:42:48 +08001321 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001322 acpi_ec_burst_disable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 switch (result) {
1325 case -EINVAL:
Patrick Mocheld550d982006-06-27 00:41:40 -04001326 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 case -ENODEV:
Patrick Mocheld550d982006-06-27 00:41:40 -04001328 return AE_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 case -ETIME:
Patrick Mocheld550d982006-06-27 00:41:40 -04001330 return AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 default:
Patrick Mocheld550d982006-06-27 00:41:40 -04001332 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334}
1335
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001337 * Driver Interface
1338 * -------------------------------------------------------------------------- */
1339
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001340static acpi_status
1341ec_parse_io_ports(struct acpi_resource *resource, void *context);
1342
Lv Zheng72c77b72016-09-07 16:50:08 +08001343static void acpi_ec_free(struct acpi_ec *ec)
1344{
1345 if (first_ec == ec)
1346 first_ec = NULL;
1347 if (boot_ec == ec)
1348 boot_ec = NULL;
1349 kfree(ec);
1350}
1351
1352static struct acpi_ec *acpi_ec_alloc(void)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001353{
1354 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001355
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001356 if (!ec)
1357 return NULL;
Feng Tangf351d022012-10-23 01:29:27 +02001358 mutex_init(&ec->mutex);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001359 init_waitqueue_head(&ec->wait);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001360 INIT_LIST_HEAD(&ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001361 spin_lock_init(&ec->lock);
Lv Zheng9d8993b2015-06-11 13:21:32 +08001362 INIT_WORK(&ec->work, acpi_ec_event_handler);
Lv Zhengd8d031a2015-05-15 14:16:42 +08001363 ec->timestamp = jiffies;
Lv Zhengc3a696b2017-01-20 16:42:48 +08001364 ec->busy_polling = true;
1365 ec->polling_guard = 0;
Daniel Drake406857f2019-10-14 16:56:02 +08001366 ec->gpe = -1;
1367 ec->irq = -1;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001368 return ec;
1369}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001371static acpi_status
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001372acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1373 void *context, void **return_value)
1374{
Lin Ming0175d562008-12-16 16:46:12 +08001375 char node_name[5];
1376 struct acpi_buffer buffer = { sizeof(node_name), node_name };
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001377 struct acpi_ec *ec = context;
1378 int value = 0;
Lin Ming0175d562008-12-16 16:46:12 +08001379 acpi_status status;
1380
1381 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1382
Lv Zheng7a73e602014-10-14 14:24:01 +08001383 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001384 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001385 return AE_OK;
1386}
1387
1388static acpi_status
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001389ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001390{
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001391 acpi_status status;
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001392 unsigned long long tmp = 0;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001393 struct acpi_ec *ec = context;
Alexey Starikovskiya5032bf2009-04-01 01:33:15 -04001394
1395 /* clear addr values, ec_parse_io_ports depend on it */
1396 ec->command_addr = ec->data_addr = 0;
1397
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001398 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1399 ec_parse_io_ports, ec);
1400 if (ACPI_FAILURE(status))
1401 return status;
Lv Zhengae56c9f2017-06-15 09:41:35 +08001402 if (ec->data_addr == 0 || ec->command_addr == 0)
1403 return AE_OK;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001404
Hans de Goedef7090e02022-06-20 11:25:44 +02001405 /* Get GPE bit assignment (EC events). */
1406 /* TODO: Add support for _GPE returning a package */
1407 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1408 if (ACPI_SUCCESS(status))
1409 ec->gpe = tmp;
1410 /*
1411 * Errors are non-fatal, allowing for ACPI Reduced Hardware
1412 * platforms which use GpioInt instead of GPE.
1413 */
Daniel Drake406857f2019-10-14 16:56:02 +08001414
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001415 /* Use the global lock for all EC transactions? */
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001416 tmp = 0;
Matthew Wilcox27663c52008-10-10 02:22:59 -04001417 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1418 ec->global_lock = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001419 ec->handle = handle;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001420 return AE_CTRL_TERMINATE;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001421}
1422
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001423static bool install_gpe_event_handler(struct acpi_ec *ec)
Daniel Drake406857f2019-10-14 16:56:02 +08001424{
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001425 acpi_status status;
1426
1427 status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1428 ACPI_GPE_EDGE_TRIGGERED,
1429 &acpi_ec_gpe_handler, ec);
1430 if (ACPI_FAILURE(status))
1431 return false;
1432
1433 if (test_bit(EC_FLAGS_STARTED, &ec->flags) && ec->reference_count >= 1)
1434 acpi_ec_enable_gpe(ec, true);
1435
1436 return true;
Daniel Drake406857f2019-10-14 16:56:02 +08001437}
1438
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001439static bool install_gpio_irq_event_handler(struct acpi_ec *ec)
Daniel Drake406857f2019-10-14 16:56:02 +08001440{
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001441 return request_irq(ec->irq, acpi_ec_irq_handler, IRQF_SHARED,
1442 "ACPI EC", ec) >= 0;
Daniel Drake406857f2019-10-14 16:56:02 +08001443}
1444
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001445/**
1446 * ec_install_handlers - Install service callbacks and register query methods.
1447 * @ec: Target EC.
1448 * @device: ACPI device object corresponding to @ec.
1449 *
1450 * Install a handler for the EC address space type unless it has been installed
1451 * already. If @device is not NULL, also look for EC query methods in the
1452 * namespace and register them, and install an event (either GPE or GPIO IRQ)
1453 * handler for the EC, if possible.
1454 *
1455 * Return:
1456 * -ENODEV if the address space handler cannot be installed, which means
1457 * "unable to handle transactions",
1458 * -EPROBE_DEFER if GPIO IRQ acquisition needs to be deferred,
1459 * or 0 (success) otherwise.
Lv Zheng72c77b72016-09-07 16:50:08 +08001460 */
Rafael J. Wysockia2b69172020-02-27 22:55:22 +01001461static int ec_install_handlers(struct acpi_ec *ec, struct acpi_device *device)
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001462{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001463 acpi_status status;
Lv Zheng7a73e602014-10-14 14:24:01 +08001464
Lv Zhengad479e72015-02-06 08:57:52 +08001465 acpi_ec_start(ec, false);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001466
1467 if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
Lv Zhengc3a696b2017-01-20 16:42:48 +08001468 acpi_ec_enter_noirq(ec);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001469 status = acpi_install_address_space_handler(ec->handle,
1470 ACPI_ADR_SPACE_EC,
1471 &acpi_ec_space_handler,
1472 NULL, ec);
1473 if (ACPI_FAILURE(status)) {
Rafael J. Wysocki7247f0c2020-02-27 22:56:28 +01001474 acpi_ec_stop(ec, false);
1475 return -ENODEV;
Lv Zheng0e1affe2016-03-24 10:42:47 +08001476 }
1477 set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1478 }
1479
Rafael J. Wysockia2b69172020-02-27 22:55:22 +01001480 if (!device)
Lv Zheng2a570842016-09-07 16:50:21 +08001481 return 0;
1482
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001483 if (ec->gpe < 0) {
1484 /* ACPI reduced hardware platforms use a GpioInt from _CRS. */
1485 int irq = acpi_dev_gpio_irq_get(device, 0);
1486 /*
1487 * Bail out right away for deferred probing or complete the
1488 * initialization regardless of any other errors.
1489 */
1490 if (irq == -EPROBE_DEFER)
1491 return -EPROBE_DEFER;
1492 else if (irq >= 0)
1493 ec->irq = irq;
1494 }
1495
Daniel Drake4446abc2019-10-14 16:56:01 +08001496 if (!test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
Lv Zheng2a570842016-09-07 16:50:21 +08001497 /* Find and register all query methods */
1498 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1499 acpi_ec_register_query_methods,
1500 NULL, ec, NULL);
Daniel Drake4446abc2019-10-14 16:56:01 +08001501 set_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
Lv Zheng2a570842016-09-07 16:50:21 +08001502 }
Daniel Drake4446abc2019-10-14 16:56:01 +08001503 if (!test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001504 bool ready = false;
Daniel Drake406857f2019-10-14 16:56:02 +08001505
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001506 if (ec->gpe >= 0)
1507 ready = install_gpe_event_handler(ec);
1508 else if (ec->irq >= 0)
1509 ready = install_gpio_irq_event_handler(ec);
1510
1511 if (ready) {
1512 set_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1513 acpi_ec_leave_noirq(ec);
Zhao Yakui20edd742008-10-17 02:02:44 -04001514 }
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001515 /*
1516 * Failures to install an event handler are not fatal, because
1517 * the EC can be polled for events.
1518 */
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001519 }
Lv Zheng53c5eaa2017-09-26 16:54:03 +08001520 /* EC is fully operational, allow queries */
1521 acpi_ec_enable_event(ec);
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001522
1523 return 0;
1524}
1525
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526static void ec_remove_handlers(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527{
Lv Zheng0e1affe2016-03-24 10:42:47 +08001528 if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1529 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1530 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1531 pr_err("failed to remove space handler\n");
1532 clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1533 }
1534
Lv Zhengfa5b4a502016-07-08 09:25:05 +08001535 /*
1536 * Stops handling the EC transactions after removing the operation
1537 * region handler. This is required because _REG(DISCONNECT)
1538 * invoked during the removal can result in new EC transactions.
1539 *
1540 * Flushes the EC requests and thus disables the GPE before
1541 * removing the GPE handler. This is required by the current ACPICA
1542 * GPE core. ACPICA GPE core will automatically disable a GPE when
1543 * it is indicated but there is no way to handle it. So the drivers
1544 * must disable the GPEs prior to removing the GPE handlers.
1545 */
1546 acpi_ec_stop(ec, false);
1547
Daniel Drake4446abc2019-10-14 16:56:01 +08001548 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
Daniel Drake406857f2019-10-14 16:56:02 +08001549 if (ec->gpe >= 0 &&
1550 ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1551 &acpi_ec_gpe_handler)))
Lv Zheng0e1affe2016-03-24 10:42:47 +08001552 pr_err("failed to remove gpe handler\n");
Daniel Drake406857f2019-10-14 16:56:02 +08001553
1554 if (ec->irq >= 0)
1555 free_irq(ec->irq, ec);
1556
Daniel Drake4446abc2019-10-14 16:56:01 +08001557 clear_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001558 }
Daniel Drake4446abc2019-10-14 16:56:01 +08001559 if (test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
Lv Zheng2a570842016-09-07 16:50:21 +08001560 acpi_ec_remove_query_handlers(ec, true, 0);
Daniel Drake4446abc2019-10-14 16:56:01 +08001561 clear_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
Lv Zheng2a570842016-09-07 16:50:21 +08001562 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
Rafael J. Wysockia2b69172020-02-27 22:55:22 +01001565static int acpi_ec_setup(struct acpi_ec *ec, struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566{
Lv Zheng72c77b72016-09-07 16:50:08 +08001567 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
Rafael J. Wysockia2b69172020-02-27 22:55:22 +01001569 ret = ec_install_handlers(ec, device);
Lv Zheng72c77b72016-09-07 16:50:08 +08001570 if (ret)
1571 return ret;
1572
1573 /* First EC capable of handling transactions */
Rafael J. Wysockic823c172020-02-27 22:51:36 +01001574 if (!first_ec)
Lv Zheng72c77b72016-09-07 16:50:08 +08001575 first_ec = ec;
Rafael J. Wysockic823c172020-02-27 22:51:36 +01001576
1577 pr_info("EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", ec->command_addr,
1578 ec->data_addr);
1579
1580 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1581 if (ec->gpe >= 0)
1582 pr_info("GPE=0x%x\n", ec->gpe);
1583 else
1584 pr_info("IRQ=%d\n", ec->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 }
Lv Zheng72c77b72016-09-07 16:50:08 +08001586
Lv Zheng72c77b72016-09-07 16:50:08 +08001587 return ret;
1588}
1589
Lv Zhengfd6231e2016-06-21 17:42:05 +08001590static int acpi_ec_add(struct acpi_device *device)
1591{
Rafael J. Wysockie3cfabc2020-03-02 11:25:13 +01001592 struct acpi_ec *ec;
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001593 int ret;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001594
1595 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1596 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1597
Rafael J. Wysockid7e04812020-04-06 17:40:27 +02001598 if (boot_ec && (boot_ec->handle == device->handle ||
1599 !strcmp(acpi_device_hid(device), ACPI_ECDT_HID))) {
Rafael J. Wysockie3cfabc2020-03-02 11:25:13 +01001600 /* Fast path: this device corresponds to the boot EC. */
Lv Zhenga64a62c2017-09-26 16:54:09 +08001601 ec = boot_ec;
1602 } else {
Rafael J. Wysockie3cfabc2020-03-02 11:25:13 +01001603 acpi_status status;
1604
Lv Zhenga64a62c2017-09-26 16:54:09 +08001605 ec = acpi_ec_alloc();
1606 if (!ec)
1607 return -ENOMEM;
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001608
Lv Zhenga64a62c2017-09-26 16:54:09 +08001609 status = ec_parse_device(device->handle, 0, ec, NULL);
1610 if (status != AE_CTRL_TERMINATE) {
Lv Zheng46922d22016-09-07 16:50:14 +08001611 ret = -EINVAL;
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001612 goto err;
Lv Zhenga64a62c2017-09-26 16:54:09 +08001613 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001615 if (boot_ec && ec->command_addr == boot_ec->command_addr &&
Hans de Goede81df5f92022-06-20 11:25:45 +02001616 ec->data_addr == boot_ec->data_addr) {
Lv Zhenga64a62c2017-09-26 16:54:09 +08001617 /*
Hans de Goede81df5f92022-06-20 11:25:45 +02001618 * Trust PNP0C09 namespace location rather than ECDT ID.
1619 * But trust ECDT GPE rather than _GPE because of ASUS
1620 * quirks. So do not change boot_ec->gpe to ec->gpe,
1621 * except when the TRUST_DSDT_GPE quirk is set.
Lv Zhenga64a62c2017-09-26 16:54:09 +08001622 */
1623 boot_ec->handle = ec->handle;
Hans de Goede81df5f92022-06-20 11:25:45 +02001624
1625 if (EC_FLAGS_TRUST_DSDT_GPE)
1626 boot_ec->gpe = ec->gpe;
1627
Lv Zhenga64a62c2017-09-26 16:54:09 +08001628 acpi_handle_debug(ec->handle, "duplicated.\n");
1629 acpi_ec_free(ec);
1630 ec = boot_ec;
1631 }
Rafael J. Wysockid2c62ae2019-02-01 12:55:31 +01001632 }
1633
Rafael J. Wysockia2b69172020-02-27 22:55:22 +01001634 ret = acpi_ec_setup(ec, device);
Lv Zheng46922d22016-09-07 16:50:14 +08001635 if (ret)
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001636 goto err;
Lv Zheng46922d22016-09-07 16:50:14 +08001637
Rafael J. Wysockid2c62ae2019-02-01 12:55:31 +01001638 if (ec == boot_ec)
1639 acpi_handle_info(boot_ec->handle,
Rafael J. Wysocki65a691f2020-03-06 00:15:24 +01001640 "Boot %s EC initialization complete\n",
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001641 boot_ec_is_ecdt ? "ECDT" : "DSDT");
Rafael J. Wysockid2c62ae2019-02-01 12:55:31 +01001642
Rafael J. Wysocki65a691f2020-03-06 00:15:24 +01001643 acpi_handle_info(ec->handle,
1644 "EC: Used to handle transactions and events\n");
1645
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 device->driver_data = ec;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001647
Andi Kleend6795fe32012-02-06 08:17:08 -08001648 ret = !!request_region(ec->data_addr, 1, "EC data");
1649 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1650 ret = !!request_region(ec->command_addr, 1, "EC cmd");
1651 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001652
Rafael J. Wysockie3cfabc2020-03-02 11:25:13 +01001653 /* Reprobe devices depending on the EC */
Daniel Scallya9e10e52021-06-03 23:40:02 +01001654 acpi_dev_clear_dependencies(device);
Rafael J. Wysockie3cfabc2020-03-02 11:25:13 +01001655
Lv Zheng97cb1592016-09-07 16:50:27 +08001656 acpi_handle_debug(ec->handle, "enumerated.\n");
Lv Zheng46922d22016-09-07 16:50:14 +08001657 return 0;
1658
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001659err:
Lv Zheng97cb1592016-09-07 16:50:27 +08001660 if (ec != boot_ec)
1661 acpi_ec_free(ec);
Rafael J. Wysocki03e9a0e2020-03-03 20:15:04 +01001662
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001663 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664}
1665
Rafael J. Wysocki51fac832013-01-24 00:24:48 +01001666static int acpi_ec_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001668 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001671 return -EINVAL;
Alexey Starikovskiyf9319f92007-08-24 08:10:11 +04001672
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 ec = acpi_driver_data(device);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001674 release_region(ec->data_addr, 1);
1675 release_region(ec->command_addr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 device->driver_data = NULL;
Lv Zheng97cb1592016-09-07 16:50:27 +08001677 if (ec != boot_ec) {
1678 ec_remove_handlers(ec);
1679 acpi_ec_free(ec);
1680 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001681 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682}
1683
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684static acpi_status
1685ec_parse_io_ports(struct acpi_resource *resource, void *context)
1686{
1687 struct acpi_ec *ec = context;
1688
1689 if (resource->type != ACPI_RESOURCE_TYPE_IO)
1690 return AE_OK;
1691
1692 /*
1693 * The first address region returned is the data port, and
1694 * the second address region returned is the status/command
1695 * port.
1696 */
Thomas Renningerde4f1042010-07-29 22:08:44 +02001697 if (ec->data_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 ec->data_addr = resource->data.io.minimum;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001699 else if (ec->command_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 ec->command_addr = resource->data.io.minimum;
1701 else
1702 return AE_CTRL_TERMINATE;
1703
1704 return AE_OK;
1705}
1706
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001707static const struct acpi_device_id ec_device_ids[] = {
1708 {"PNP0C09", 0},
Lv Zhenga64a62c2017-09-26 16:54:09 +08001709 {ACPI_ECDT_HID, 0},
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001710 {"", 0},
1711};
1712
Lv Zhengc712bb52017-06-15 09:41:41 +08001713/*
1714 * This function is not Windows-compatible as Windows never enumerates the
1715 * namespace EC before the main ACPI device enumeration process. It is
1716 * retained for historical reason and will be deprecated in the future.
1717 */
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001718void __init acpi_ec_dsdt_probe(void)
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001719{
Lv Zhengfd6231e2016-06-21 17:42:05 +08001720 struct acpi_ec *ec;
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001721 acpi_status status;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001722 int ret;
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001723
Lv Zhengc712bb52017-06-15 09:41:41 +08001724 /*
1725 * If a platform has ECDT, there is no need to proceed as the
1726 * following probe is not a part of the ACPI device enumeration,
1727 * executing _STA is not safe, and thus this probe may risk of
1728 * picking up an invalid EC device.
1729 */
1730 if (boot_ec)
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001731 return;
Lv Zhengc712bb52017-06-15 09:41:41 +08001732
Lv Zhengfd6231e2016-06-21 17:42:05 +08001733 ec = acpi_ec_alloc();
1734 if (!ec)
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001735 return;
1736
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001737 /*
Lv Zheng2a570842016-09-07 16:50:21 +08001738 * At this point, the namespace is initialized, so start to find
1739 * the namespace objects.
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001740 */
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001741 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
Lv Zhengfd6231e2016-06-21 17:42:05 +08001742 if (ACPI_FAILURE(status) || !ec->handle) {
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001743 acpi_ec_free(ec);
1744 return;
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001745 }
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001746
Lv Zheng2a570842016-09-07 16:50:21 +08001747 /*
1748 * When the DSDT EC is available, always re-configure boot EC to
1749 * have _REG evaluated. _REG can only be evaluated after the
1750 * namespace initialization.
1751 * At this point, the GPE is not fully initialized, so do not to
1752 * handle the events.
1753 */
Rafael J. Wysockia2b69172020-02-27 22:55:22 +01001754 ret = acpi_ec_setup(ec, NULL);
Rafael J. Wysockic746b6b2019-02-01 10:59:42 +01001755 if (ret) {
Lv Zheng72c77b72016-09-07 16:50:08 +08001756 acpi_ec_free(ec);
Rafael J. Wysockic746b6b2019-02-01 10:59:42 +01001757 return;
1758 }
1759
1760 boot_ec = ec;
1761
1762 acpi_handle_info(ec->handle,
1763 "Boot DSDT EC used to handle transactions\n");
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001764}
1765
Lv Zheng2a570842016-09-07 16:50:21 +08001766/*
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001767 * acpi_ec_ecdt_start - Finalize the boot ECDT EC initialization.
1768 *
1769 * First, look for an ACPI handle for the boot ECDT EC if acpi_ec_add() has not
1770 * found a matching object in the namespace.
1771 *
1772 * Next, in case the DSDT EC is not functioning, it is still necessary to
1773 * provide a functional ECDT EC to handle events, so add an extra device object
1774 * to represent it (see https://bugzilla.kernel.org/show_bug.cgi?id=115021).
1775 *
1776 * This is useful on platforms with valid ECDT and invalid DSDT EC settings,
1777 * like ASUS X550ZE (see https://bugzilla.kernel.org/show_bug.cgi?id=196847).
Lv Zheng2a570842016-09-07 16:50:21 +08001778 */
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001779static void __init acpi_ec_ecdt_start(void)
Lv Zheng2a570842016-09-07 16:50:21 +08001780{
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001781 struct acpi_table_ecdt *ecdt_ptr;
Lv Zheng2a570842016-09-07 16:50:21 +08001782 acpi_handle handle;
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001783 acpi_status status;
Lv Zheng2a570842016-09-07 16:50:21 +08001784
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001785 /* Bail out if a matching EC has been found in the namespace. */
1786 if (!boot_ec || boot_ec->handle != ACPI_ROOT_OBJECT)
1787 return;
Lv Zheng2a570842016-09-07 16:50:21 +08001788
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001789 /* Look up the object pointed to from the ECDT in the namespace. */
1790 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1791 (struct acpi_table_header **)&ecdt_ptr);
1792 if (ACPI_FAILURE(status))
1793 return;
Lv Zhenga64a62c2017-09-26 16:54:09 +08001794
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001795 status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
Hanjun Guof900bf42020-05-07 17:09:19 +08001796 if (ACPI_SUCCESS(status)) {
1797 boot_ec->handle = handle;
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001798
Hanjun Guof900bf42020-05-07 17:09:19 +08001799 /* Add a special ACPI device object to represent the boot EC. */
1800 acpi_bus_register_early_device(ACPI_BUS_TYPE_ECDT_EC);
1801 }
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01001802
Hanjun Guof900bf42020-05-07 17:09:19 +08001803 acpi_put_table((struct acpi_table_header *)ecdt_ptr);
Lv Zheng2a570842016-09-07 16:50:21 +08001804}
1805
Lv Zheng791490012014-10-29 11:33:49 +08001806/*
Zhang Ruib6a3e142019-02-01 14:13:41 +08001807 * On some hardware it is necessary to clear events accumulated by the EC during
1808 * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1809 * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1810 *
1811 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1812 *
1813 * Ideally, the EC should also be instructed NOT to accumulate events during
1814 * sleep (which Windows seems to do somehow), but the interface to control this
1815 * behaviour is not known at this time.
1816 *
1817 * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1818 * however it is very likely that other Samsung models are affected.
1819 *
1820 * On systems which don't accumulate _Q events during sleep, this extra check
1821 * should be harmless.
1822 */
1823static int ec_clear_on_resume(const struct dmi_system_id *id)
1824{
1825 pr_debug("Detected system needing EC poll on resume.\n");
1826 EC_FLAGS_CLEAR_ON_RESUME = 1;
1827 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1828 return 0;
1829}
1830
1831/*
Lv Zhengbc539562016-06-21 17:42:12 +08001832 * Some ECDTs contain wrong register addresses.
1833 * MSI MS-171F
1834 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1835 */
Lv Zheng59f0aa92016-03-24 10:42:53 +08001836static int ec_correct_ecdt(const struct dmi_system_id *id)
1837{
1838 pr_debug("Detected system needing ECDT address correction.\n");
1839 EC_FLAGS_CORRECT_ECDT = 1;
1840 return 0;
1841}
1842
Chris Chiu440f53d2017-06-15 09:41:47 +08001843/*
Zhang Rui4370cbf2021-06-21 09:37:27 +08001844 * Some ECDTs contain wrong GPE setting, but they share the same port addresses
1845 * with DSDT EC, don't duplicate the DSDT EC with ECDT EC in this case.
1846 * https://bugzilla.kernel.org/show_bug.cgi?id=209989
1847 */
1848static int ec_honor_dsdt_gpe(const struct dmi_system_id *id)
1849{
1850 pr_debug("Detected system needing DSDT GPE setting.\n");
1851 EC_FLAGS_TRUST_DSDT_GPE = 1;
1852 return 0;
1853}
1854
Christoph Hellwig6faadbb2017-09-14 11:59:30 +02001855static const struct dmi_system_id ec_dmi_table[] __initconst = {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001856 {
Hans de Goede3e6573c2022-06-20 11:25:46 +02001857 /*
1858 * MSI MS-171F
1859 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1860 */
1861 .callback = ec_correct_ecdt,
1862 .matches = {
1863 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1864 DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),
1865 },
1866 },
Chris Chiu440f53d2017-06-15 09:41:47 +08001867 {
Hans de Goede3e6573c2022-06-20 11:25:46 +02001868 /*
1869 * HP Pavilion Gaming Laptop 15-cx0xxx
1870 * https://bugzilla.kernel.org/show_bug.cgi?id=209989
1871 */
1872 .callback = ec_honor_dsdt_gpe,
1873 .matches = {
1874 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1875 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion Gaming Laptop 15-cx0xxx"),
1876 },
1877 },
Zhang Rui4370cbf2021-06-21 09:37:27 +08001878 {
Hans de Goede3e6573c2022-06-20 11:25:46 +02001879 /*
1880 * Samsung hardware
1881 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1882 */
1883 .callback = ec_clear_on_resume,
1884 .matches = {
1885 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1886 },
1887 },
1888 {}
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001889};
1890
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001891void __init acpi_ec_ecdt_probe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001893 struct acpi_table_ecdt *ecdt_ptr;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001894 struct acpi_ec *ec;
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001895 acpi_status status;
1896 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001898 /* Generate a boot ec context. */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001899 dmi_check_system(ec_dmi_table);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001900 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1901 (struct acpi_table_header **)&ecdt_ptr);
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001902 if (ACPI_FAILURE(status))
1903 return;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001904
1905 if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1906 /*
1907 * Asus X50GL:
1908 * https://bugzilla.kernel.org/show_bug.cgi?id=11880
1909 */
Hanjun Guof900bf42020-05-07 17:09:19 +08001910 goto out;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001911 }
1912
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001913 ec = acpi_ec_alloc();
1914 if (!ec)
Hanjun Guof900bf42020-05-07 17:09:19 +08001915 goto out;
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001916
Lv Zheng59f0aa92016-03-24 10:42:53 +08001917 if (EC_FLAGS_CORRECT_ECDT) {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001918 ec->command_addr = ecdt_ptr->data.address;
1919 ec->data_addr = ecdt_ptr->control.address;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001920 } else {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001921 ec->command_addr = ecdt_ptr->control.address;
1922 ec->data_addr = ecdt_ptr->data.address;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001923 }
Daniel Drake406857f2019-10-14 16:56:02 +08001924
1925 /*
1926 * Ignore the GPE value on Reduced Hardware platforms.
1927 * Some products have this set to an erroneous value.
1928 */
1929 if (!acpi_gbl_reduced_hardware)
1930 ec->gpe = ecdt_ptr->gpe;
1931
Rafael J. Wysocki15684262019-02-01 10:58:20 +01001932 ec->handle = ACPI_ROOT_OBJECT;
Lv Zheng2a570842016-09-07 16:50:21 +08001933
1934 /*
1935 * At this point, the namespace is not initialized, so do not find
1936 * the namespace objects, or handle the events.
1937 */
Rafael J. Wysockia2b69172020-02-27 22:55:22 +01001938 ret = acpi_ec_setup(ec, NULL);
Rafael J. Wysocki15684262019-02-01 10:58:20 +01001939 if (ret) {
Lv Zheng72c77b72016-09-07 16:50:08 +08001940 acpi_ec_free(ec);
Hanjun Guof900bf42020-05-07 17:09:19 +08001941 goto out;
Rafael J. Wysocki15684262019-02-01 10:58:20 +01001942 }
1943
1944 boot_ec = ec;
1945 boot_ec_is_ecdt = true;
1946
1947 pr_info("Boot ECDT EC used to handle transactions\n");
Hanjun Guof900bf42020-05-07 17:09:19 +08001948
1949out:
1950 acpi_put_table((struct acpi_table_header *)ecdt_ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951}
1952
Lv Zhengdf45db62016-08-03 09:07:58 +08001953#ifdef CONFIG_PM_SLEEP
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001954static int acpi_ec_suspend(struct device *dev)
1955{
1956 struct acpi_ec *ec =
1957 acpi_driver_data(to_acpi_device(dev));
1958
Rafael J. Wysocki6e866332019-07-31 11:05:42 +02001959 if (!pm_suspend_no_platform() && ec_freeze_events)
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001960 acpi_ec_disable_event(ec);
1961 return 0;
1962}
1963
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001964static int acpi_ec_suspend_noirq(struct device *dev)
1965{
1966 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1967
1968 /*
1969 * The SCI handler doesn't run at this point, so the GPE can be
1970 * masked at the low level without side effects.
1971 */
1972 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
Daniel Drake406857f2019-10-14 16:56:02 +08001973 ec->gpe >= 0 && ec->reference_count >= 1)
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001974 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1975
Rafael J. Wysockifcd0a042019-07-31 11:05:33 +02001976 acpi_ec_enter_noirq(ec);
Rafael J. Wysocki3cd091a2018-02-09 22:55:28 +01001977
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001978 return 0;
1979}
1980
1981static int acpi_ec_resume_noirq(struct device *dev)
1982{
1983 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1984
Rafael J. Wysockifcd0a042019-07-31 11:05:33 +02001985 acpi_ec_leave_noirq(ec);
Rafael J. Wysocki3cd091a2018-02-09 22:55:28 +01001986
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001987 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
Daniel Drake406857f2019-10-14 16:56:02 +08001988 ec->gpe >= 0 && ec->reference_count >= 1)
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001989 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
1990
1991 return 0;
1992}
1993
Lv Zhengc2b46d62016-08-03 16:01:36 +08001994static int acpi_ec_resume(struct device *dev)
1995{
1996 struct acpi_ec *ec =
1997 acpi_driver_data(to_acpi_device(dev));
1998
1999 acpi_ec_enable_event(ec);
2000 return 0;
2001}
Rafael J. Wysockid7589402019-07-31 11:05:52 +02002002
2003void acpi_ec_mark_gpe_for_wake(void)
2004{
2005 if (first_ec && !ec_no_wakeup)
2006 acpi_mark_gpe_for_wake(NULL, first_ec->gpe);
2007}
2008EXPORT_SYMBOL_GPL(acpi_ec_mark_gpe_for_wake);
2009
2010void acpi_ec_set_gpe_wake_mask(u8 action)
2011{
2012 if (pm_suspend_no_platform() && first_ec && !ec_no_wakeup)
2013 acpi_set_gpe_wake_mask(NULL, first_ec->gpe, action);
2014}
Rafael J. Wysockid7589402019-07-31 11:05:52 +02002015
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +01002016static bool acpi_ec_work_in_progress(struct acpi_ec *ec)
2017{
2018 return ec->events_in_progress + ec->queries_in_progress > 0;
2019}
2020
Rafael J. Wysockid7589402019-07-31 11:05:52 +02002021bool acpi_ec_dispatch_gpe(void)
2022{
Rafael J. Wysockica8283d2021-11-23 19:37:39 +01002023 bool work_in_progress = false;
Rafael J. Wysockid7589402019-07-31 11:05:52 +02002024
2025 if (!first_ec)
Rafael J. Wysocki7b301752020-05-09 10:44:41 +02002026 return acpi_any_gpe_status_set(U32_MAX);
2027
2028 /*
2029 * Report wakeup if the status bit is set for any enabled GPE other
2030 * than the EC one.
2031 */
2032 if (acpi_any_gpe_status_set(first_ec->gpe))
2033 return true;
2034
Rafael J. Wysocki7b301752020-05-09 10:44:41 +02002035 /*
Rafael J. Wysockidc0075b2022-02-04 18:31:02 +01002036 * Cancel the SCI wakeup and process all pending events in case there
2037 * are any wakeup ones in there.
2038 *
2039 * Note that if any non-EC GPEs are active at this point, the SCI will
2040 * retrigger after the rearming in acpi_s2idle_wake(), so no events
2041 * should be missed by canceling the wakeup here.
2042 */
2043 pm_system_cancel_wakeup();
2044
2045 /*
Rafael J. Wysocki7b301752020-05-09 10:44:41 +02002046 * Dispatch the EC GPE in-band, but do not report wakeup in any case
2047 * to allow the caller to process events properly after that.
2048 */
Rafael J. Wysockica8283d2021-11-23 19:37:39 +01002049 spin_lock_irq(&first_ec->lock);
2050
Rafael J. Wysocki977dc302022-02-01 20:18:56 +01002051 if (acpi_ec_gpe_status_set(first_ec)) {
2052 pm_pr_dbg("ACPI EC GPE status set\n");
2053
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +01002054 advance_transaction(first_ec, false);
2055 work_in_progress = acpi_ec_work_in_progress(first_ec);
Rafael J. Wysocki977dc302022-02-01 20:18:56 +01002056 }
Rafael J. Wysockica8283d2021-11-23 19:37:39 +01002057
2058 spin_unlock_irq(&first_ec->lock);
2059
2060 if (!work_in_progress)
2061 return false;
2062
2063 pm_pr_dbg("ACPI EC GPE dispatched\n");
Rafael J. Wysocki7b301752020-05-09 10:44:41 +02002064
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01002065 /* Drain EC work. */
2066 do {
2067 acpi_ec_flush_work();
2068
2069 pm_pr_dbg("ACPI EC work flushed\n");
2070
2071 spin_lock_irq(&first_ec->lock);
2072
Rafael J. Wysocki9aa60f32022-02-04 18:40:20 +01002073 work_in_progress = acpi_ec_work_in_progress(first_ec);
Rafael J. Wysocki4a9af6c2021-11-23 19:36:51 +01002074
2075 spin_unlock_irq(&first_ec->lock);
2076 } while (work_in_progress && !pm_wakeup_pending());
Rafael J. Wysocki607b9df2020-05-15 12:58:19 +02002077
Rafael J. Wysocki29113f22019-07-31 11:06:00 +02002078 return false;
Rafael J. Wysockid7589402019-07-31 11:05:52 +02002079}
2080#endif /* CONFIG_PM_SLEEP */
Lv Zhengdf45db62016-08-03 09:07:58 +08002081
2082static const struct dev_pm_ops acpi_ec_pm = {
Rafael J. Wysocki76380632017-07-19 14:41:58 +02002083 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
Lv Zheng39a2a2a2016-08-03 16:01:43 +08002084 SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
Lv Zhengdf45db62016-08-03 09:07:58 +08002085};
2086
Kees Cooke4dca7b2017-10-17 19:04:42 -07002087static int param_set_event_clearing(const char *val,
2088 const struct kernel_param *kp)
Lv Zheng1d68d262015-06-11 13:21:38 +08002089{
2090 int result = 0;
2091
2092 if (!strncmp(val, "status", sizeof("status") - 1)) {
2093 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
2094 pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
2095 } else if (!strncmp(val, "query", sizeof("query") - 1)) {
2096 ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
2097 pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
2098 } else if (!strncmp(val, "event", sizeof("event") - 1)) {
2099 ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
2100 pr_info("Assuming SCI_EVT clearing on event reads\n");
2101 } else
2102 result = -EINVAL;
2103 return result;
2104}
2105
Kees Cooke4dca7b2017-10-17 19:04:42 -07002106static int param_get_event_clearing(char *buffer,
2107 const struct kernel_param *kp)
Lv Zheng1d68d262015-06-11 13:21:38 +08002108{
2109 switch (ec_event_clearing) {
2110 case ACPI_EC_EVT_TIMING_STATUS:
Xiongfeng Wangfc293b72020-06-16 17:14:08 +08002111 return sprintf(buffer, "status\n");
Lv Zheng1d68d262015-06-11 13:21:38 +08002112 case ACPI_EC_EVT_TIMING_QUERY:
Xiongfeng Wangfc293b72020-06-16 17:14:08 +08002113 return sprintf(buffer, "query\n");
Lv Zheng1d68d262015-06-11 13:21:38 +08002114 case ACPI_EC_EVT_TIMING_EVENT:
Xiongfeng Wangfc293b72020-06-16 17:14:08 +08002115 return sprintf(buffer, "event\n");
Lv Zheng1d68d262015-06-11 13:21:38 +08002116 default:
Xiongfeng Wangfc293b72020-06-16 17:14:08 +08002117 return sprintf(buffer, "invalid\n");
Lv Zheng1d68d262015-06-11 13:21:38 +08002118 }
2119 return 0;
2120}
2121
2122module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
2123 NULL, 0644);
2124MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
2125
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03002126static struct acpi_driver acpi_ec_driver = {
2127 .name = "ec",
2128 .class = ACPI_EC_CLASS,
2129 .ids = ec_device_ids,
2130 .ops = {
2131 .add = acpi_ec_add,
2132 .remove = acpi_ec_remove,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03002133 },
Lv Zhengdf45db62016-08-03 09:07:58 +08002134 .drv.pm = &acpi_ec_pm,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03002135};
2136
Rafael J. Wysockif0ac20c2020-02-11 10:07:43 +01002137static void acpi_ec_destroy_workqueues(void)
Lv Zhenge1191bd2016-08-03 09:00:14 +08002138{
Rafael J. Wysockif0ac20c2020-02-11 10:07:43 +01002139 if (ec_wq) {
2140 destroy_workqueue(ec_wq);
2141 ec_wq = NULL;
Lv Zhenge1191bd2016-08-03 09:00:14 +08002142 }
Lv Zhenge1191bd2016-08-03 09:00:14 +08002143 if (ec_query_wq) {
2144 destroy_workqueue(ec_query_wq);
2145 ec_query_wq = NULL;
2146 }
2147}
2148
Rafael J. Wysockif0ac20c2020-02-11 10:07:43 +01002149static int acpi_ec_init_workqueues(void)
2150{
2151 if (!ec_wq)
2152 ec_wq = alloc_ordered_workqueue("kec", 0);
2153
2154 if (!ec_query_wq)
2155 ec_query_wq = alloc_workqueue("kec_query", 0, ec_max_queries);
2156
2157 if (!ec_wq || !ec_query_wq) {
2158 acpi_ec_destroy_workqueues();
2159 return -ENODEV;
2160 }
2161 return 0;
2162}
2163
Mika Westerberg8195a652018-06-18 14:17:16 +03002164static const struct dmi_system_id acpi_ec_no_wakeup[] = {
2165 {
Mika Westerberg8195a652018-06-18 14:17:16 +03002166 .matches = {
2167 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
Robin H. Johnson2c4d6ba2018-07-13 20:50:47 +00002168 DMI_MATCH(DMI_PRODUCT_FAMILY, "Thinkpad X1 Carbon 6th"),
Mika Westerberg8195a652018-06-18 14:17:16 +03002169 },
2170 },
Aaron Mab047c622018-07-31 18:52:39 +08002171 {
Aaron Mab047c622018-07-31 18:52:39 +08002172 .matches = {
2173 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2174 DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Yoga 3rd"),
2175 },
2176 },
Binbin Zhoueb794e32021-10-28 21:44:32 +08002177 {
Binbin Zhoueb794e32021-10-28 21:44:32 +08002178 .matches = {
2179 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
2180 DMI_MATCH(DMI_PRODUCT_FAMILY, "103C_5336AN HP ZHAN 66 Pro"),
2181 },
2182 },
Mika Westerberg8195a652018-06-18 14:17:16 +03002183 { },
2184};
2185
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01002186void __init acpi_ec_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187{
Lv Zhenge1191bd2016-08-03 09:00:14 +08002188 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189
Rafael J. Wysockif0ac20c2020-02-11 10:07:43 +01002190 result = acpi_ec_init_workqueues();
Lv Zhenge1191bd2016-08-03 09:00:14 +08002191 if (result)
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01002192 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193
Mika Westerberg8195a652018-06-18 14:17:16 +03002194 /*
2195 * Disable EC wakeup on following systems to prevent periodic
2196 * wakeup from EC GPE.
2197 */
2198 if (dmi_check_system(acpi_ec_no_wakeup)) {
2199 ec_no_wakeup = true;
2200 pr_debug("Disabling EC wakeup on suspend-to-idle\n");
2201 }
2202
Rafael J. Wysocki98ada3c2020-03-06 00:14:35 +01002203 /* Driver must be registered after acpi_ec_init_workqueues(). */
2204 acpi_bus_register_driver(&acpi_ec_driver);
2205
2206 acpi_ec_ecdt_start();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207}
2208
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209/* EC driver currently not unloadable */
2210#if 0
Len Brown50526df2005-08-11 17:32:05 -04002211static void __exit acpi_ec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213
2214 acpi_bus_unregister_driver(&acpi_ec_driver);
Rafael J. Wysockif0ac20c2020-02-11 10:07:43 +01002215 acpi_ec_destroy_workqueues();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216}
Alexey Starikovskiy78439322007-10-22 14:18:43 +04002217#endif /* 0 */