blob: c33756ed33049cd9e9eced123177c556f76874ee [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>
Lv Zheng8b484632013-12-03 08:49:16 +080028#include <linux/acpi.h>
Len Browneb27cae2009-07-06 23:40:19 -040029#include <linux/dmi.h>
Lv Zheng8b484632013-12-03 08:49:16 +080030#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Thomas Renninger1195a092010-07-16 13:11:31 +020032#include "internal.h"
33
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#define ACPI_EC_CLASS "embedded_controller"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define ACPI_EC_DEVICE_NAME "Embedded Controller"
36#define ACPI_EC_FILE_INFO "info"
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 */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +010095 EC_FLAGS_QUERY_PENDING, /* Query is pending */
Lv Zheng1d68d262015-06-11 13:21:38 +080096 EC_FLAGS_QUERY_GUARDING, /* Guard for SCI_EVT check */
Lv Zheng0e1affe2016-03-24 10:42:47 +080097 EC_FLAGS_GPE_HANDLER_INSTALLED, /* GPE handler installed */
98 EC_FLAGS_EC_HANDLER_INSTALLED, /* OpReg handler installed */
Lv Zheng2a570842016-09-07 16:50:21 +080099 EC_FLAGS_EVT_HANDLER_INSTALLED, /* _Qxx handlers installed */
Lv Zhengad479e72015-02-06 08:57:52 +0800100 EC_FLAGS_STARTED, /* Driver is started */
101 EC_FLAGS_STOPPED, /* Driver is stopped */
Lv Zheng56f77ee2017-08-11 14:36:28 +0800102 EC_FLAGS_GPE_MASKED, /* GPE masked */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103};
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400104
Lv Zhengf92fca02014-06-15 08:41:35 +0800105#define ACPI_EC_COMMAND_POLL 0x01 /* Available for command byte */
106#define ACPI_EC_COMMAND_COMPLETE 0x02 /* Completed last byte */
107
Thomas Renninger7a18e962010-10-21 18:24:57 +0200108/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
109static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
110module_param(ec_delay, uint, 0644);
111MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
112
Lv Zhenge1191bd2016-08-03 09:00:14 +0800113static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
114module_param(ec_max_queries, uint, 0644);
115MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
116
Lv Zheng15de6032015-05-15 14:16:48 +0800117static bool ec_busy_polling __read_mostly;
118module_param(ec_busy_polling, bool, 0644);
119MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
120
121static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
122module_param(ec_polling_guard, uint, 0644);
123MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
124
Lv Zheng3cb02ae2015-06-11 13:21:45 +0800125static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
Lv Zheng1d68d262015-06-11 13:21:38 +0800126
Feng Tanga520d522012-09-28 15:22:00 +0800127/*
128 * If the number of false interrupts per one transaction exceeds
129 * this threshold, will think there is a GPE storm happened and
130 * will disable the GPE for normal transaction.
131 */
132static unsigned int ec_storm_threshold __read_mostly = 8;
133module_param(ec_storm_threshold, uint, 0644);
134MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
135
Lv Zheng9c40f952017-07-12 11:09:17 +0800136static bool ec_freeze_events __read_mostly = false;
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800137module_param(ec_freeze_events, bool, 0644);
138MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
139
Rafael J. Wysocki76380632017-07-19 14:41:58 +0200140static bool ec_no_wakeup __read_mostly;
141module_param(ec_no_wakeup, bool, 0644);
142MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
143
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400144struct acpi_ec_query_handler {
145 struct list_head node;
146 acpi_ec_query_func func;
147 acpi_handle handle;
148 void *data;
149 u8 query_bit;
Lv Zheng01305d42015-01-14 19:28:28 +0800150 struct kref kref;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400151};
152
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400153struct transaction {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400154 const u8 *wdata;
155 u8 *rdata;
156 unsigned short irq_count;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400157 u8 command;
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300158 u8 wi;
159 u8 ri;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400160 u8 wlen;
161 u8 rlen;
Lv Zhengf92fca02014-06-15 08:41:35 +0800162 u8 flags;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400163};
164
Lv Zheng02b771b2015-08-12 11:12:02 +0800165struct acpi_ec_query {
166 struct transaction transaction;
167 struct work_struct work;
168 struct acpi_ec_query_handler *handler;
169};
170
Lv Zheng550b3aac2015-01-14 19:28:53 +0800171static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800172static void advance_transaction(struct acpi_ec *ec);
Lv Zheng02b771b2015-08-12 11:12:02 +0800173static void acpi_ec_event_handler(struct work_struct *work);
174static void acpi_ec_event_processor(struct work_struct *work);
Lv Zheng74443bb2015-01-14 19:28:47 +0800175
Rafael J. Wysockia9c30762019-02-01 10:57:01 +0100176struct acpi_ec *first_ec;
Thomas Renninger1195a092010-07-16 13:11:31 +0200177EXPORT_SYMBOL(first_ec);
Rafael J. Wysockia9c30762019-02-01 10:57:01 +0100178
179static struct acpi_ec *boot_ec;
Lv Zheng72c77b72016-09-07 16:50:08 +0800180static bool boot_ec_is_ecdt = false;
Lv Zhenge1191bd2016-08-03 09:00:14 +0800181static struct workqueue_struct *ec_query_wq;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400182
Lv Zheng79149002014-10-29 11:33:49 +0800183static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
Lv Zheng59f0aa92016-03-24 10:42:53 +0800184static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
Chris Chiu440f53d2017-06-15 09:41:47 +0800185static int EC_FLAGS_IGNORE_DSDT_GPE; /* Needs ECDT GPE as correction setting */
Zhang Ruib6a3e142019-02-01 14:13:41 +0800186static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188/* --------------------------------------------------------------------------
Lv Zheng3535a3c2015-02-27 14:48:15 +0800189 * Logging/Debugging
190 * -------------------------------------------------------------------------- */
191
192/*
193 * Splitters used by the developers to track the boundary of the EC
194 * handling processes.
195 */
196#ifdef DEBUG
197#define EC_DBG_SEP " "
198#define EC_DBG_DRV "+++++"
199#define EC_DBG_STM "====="
200#define EC_DBG_REQ "*****"
201#define EC_DBG_EVT "#####"
202#else
203#define EC_DBG_SEP ""
204#define EC_DBG_DRV
205#define EC_DBG_STM
206#define EC_DBG_REQ
207#define EC_DBG_EVT
208#endif
209
210#define ec_log_raw(fmt, ...) \
211 pr_info(fmt "\n", ##__VA_ARGS__)
212#define ec_dbg_raw(fmt, ...) \
213 pr_debug(fmt "\n", ##__VA_ARGS__)
214#define ec_log(filter, fmt, ...) \
215 ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
216#define ec_dbg(filter, fmt, ...) \
217 ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
218
219#define ec_log_drv(fmt, ...) \
220 ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
221#define ec_dbg_drv(fmt, ...) \
222 ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
223#define ec_dbg_stm(fmt, ...) \
224 ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
225#define ec_dbg_req(fmt, ...) \
226 ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
227#define ec_dbg_evt(fmt, ...) \
228 ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
Lv Zheng770970f2015-02-27 14:48:24 +0800229#define ec_dbg_ref(ec, fmt, ...) \
230 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
Lv Zheng3535a3c2015-02-27 14:48:15 +0800231
232/* --------------------------------------------------------------------------
Lv Zhengad479e72015-02-06 08:57:52 +0800233 * Device Flags
234 * -------------------------------------------------------------------------- */
235
236static bool acpi_ec_started(struct acpi_ec *ec)
237{
238 return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
239 !test_bit(EC_FLAGS_STOPPED, &ec->flags);
240}
241
Lv Zheng750f628b2016-08-03 16:01:24 +0800242static bool acpi_ec_event_enabled(struct acpi_ec *ec)
243{
244 /*
245 * There is an OSPM early stage logic. During the early stages
246 * (boot/resume), OSPMs shouldn't enable the event handling, only
247 * the EC transactions are allowed to be performed.
248 */
249 if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
250 return false;
251 /*
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800252 * However, disabling the event handling is experimental for late
253 * stage (suspend), and is controlled by the boot parameter of
254 * "ec_freeze_events":
255 * 1. true: The EC event handling is disabled before entering
256 * the noirq stage.
257 * 2. false: The EC event handling is automatically disabled as
258 * soon as the EC driver is stopped.
Lv Zheng750f628b2016-08-03 16:01:24 +0800259 */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800260 if (ec_freeze_events)
261 return acpi_ec_started(ec);
262 else
263 return test_bit(EC_FLAGS_STARTED, &ec->flags);
Lv Zheng750f628b2016-08-03 16:01:24 +0800264}
265
Lv Zheng9887d222015-02-06 08:57:59 +0800266static bool acpi_ec_flushed(struct acpi_ec *ec)
267{
268 return ec->reference_count == 1;
269}
270
Lv Zhengad479e72015-02-06 08:57:52 +0800271/* --------------------------------------------------------------------------
Lv Zhengca37bfd2015-02-05 16:27:22 +0800272 * EC Registers
Lv Zheng7a73e602014-10-14 14:24:01 +0800273 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400275static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300277 u8 x = inb(ec->command_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800278
Lv Zheng3535a3c2015-02-27 14:48:15 +0800279 ec_dbg_raw("EC_SC(R) = 0x%2.2x "
280 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
281 x,
282 !!(x & ACPI_EC_FLAG_SCI),
283 !!(x & ACPI_EC_FLAG_BURST),
284 !!(x & ACPI_EC_FLAG_CMD),
285 !!(x & ACPI_EC_FLAG_IBF),
286 !!(x & ACPI_EC_FLAG_OBF));
Márton Németh3ebe08a2007-11-21 03:23:26 +0300287 return x;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288}
289
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400290static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400291{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300292 u8 x = inb(ec->data_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800293
Lv Zhengd8d031a2015-05-15 14:16:42 +0800294 ec->timestamp = jiffies;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800295 ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400296 return x;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400297}
298
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400299static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400300{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800301 ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400302 outb(command, ec->command_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800303 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400304}
305
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400306static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400307{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800308 ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400309 outb(data, ec->data_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800310 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400311}
312
Lv Zheng4625d752017-06-14 13:59:18 +0800313#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
Lv Zhenge34c0e22014-10-14 14:23:49 +0800314static const char *acpi_ec_cmd_string(u8 cmd)
315{
316 switch (cmd) {
317 case 0x80:
318 return "RD_EC";
319 case 0x81:
320 return "WR_EC";
321 case 0x82:
322 return "BE_EC";
323 case 0x83:
324 return "BD_EC";
325 case 0x84:
326 return "QR_EC";
327 }
328 return "UNKNOWN";
329}
330#else
331#define acpi_ec_cmd_string(cmd) "UNDEF"
332#endif
333
Lv Zhengca37bfd2015-02-05 16:27:22 +0800334/* --------------------------------------------------------------------------
335 * GPE Registers
336 * -------------------------------------------------------------------------- */
337
338static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
339{
340 acpi_event_status gpe_status = 0;
341
342 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
Lv Zheng7c0b2592015-05-15 14:16:17 +0800343 return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
Lv Zhengca37bfd2015-02-05 16:27:22 +0800344}
345
346static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
347{
348 if (open)
349 acpi_enable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800350 else {
351 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800352 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800353 }
Lv Zhengca37bfd2015-02-05 16:27:22 +0800354 if (acpi_ec_is_gpe_raised(ec)) {
355 /*
356 * On some platforms, EN=1 writes cannot trigger GPE. So
357 * software need to manually trigger a pseudo GPE event on
358 * EN=1 writes.
359 */
Lv Zheng3535a3c2015-02-27 14:48:15 +0800360 ec_dbg_raw("Polling quirk");
Lv Zhengca37bfd2015-02-05 16:27:22 +0800361 advance_transaction(ec);
362 }
363}
364
365static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
366{
367 if (close)
368 acpi_disable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800369 else {
370 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800371 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800372 }
Lv Zhengca37bfd2015-02-05 16:27:22 +0800373}
374
375static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
376{
377 /*
378 * GPE STS is a W1C register, which means:
379 * 1. Software can clear it without worrying about clearing other
380 * GPEs' STS bits when the hardware sets them in parallel.
381 * 2. As long as software can ensure only clearing it when it is
382 * set, hardware won't set it in parallel.
383 * So software can clear GPE in any contexts.
384 * Warning: do not move the check into advance_transaction() as the
385 * EC commands will be sent without GPE raised.
386 */
387 if (!acpi_ec_is_gpe_raised(ec))
388 return;
389 acpi_clear_gpe(NULL, ec->gpe);
390}
391
392/* --------------------------------------------------------------------------
393 * Transaction Management
394 * -------------------------------------------------------------------------- */
395
Lv Zheng9887d222015-02-06 08:57:59 +0800396static void acpi_ec_submit_request(struct acpi_ec *ec)
397{
398 ec->reference_count++;
Lv Zheng0e1affe2016-03-24 10:42:47 +0800399 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
400 ec->reference_count == 1)
Lv Zheng9887d222015-02-06 08:57:59 +0800401 acpi_ec_enable_gpe(ec, true);
402}
403
404static void acpi_ec_complete_request(struct acpi_ec *ec)
405{
406 bool flushed = false;
407
408 ec->reference_count--;
Lv Zheng0e1affe2016-03-24 10:42:47 +0800409 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
410 ec->reference_count == 0)
Lv Zheng9887d222015-02-06 08:57:59 +0800411 acpi_ec_disable_gpe(ec, true);
412 flushed = acpi_ec_flushed(ec);
413 if (flushed)
414 wake_up(&ec->wait);
415}
416
Lv Zheng56f77ee2017-08-11 14:36:28 +0800417static void acpi_ec_mask_gpe(struct acpi_ec *ec)
Lv Zhenge1d4d902015-02-06 08:58:05 +0800418{
Lv Zheng56f77ee2017-08-11 14:36:28 +0800419 if (!test_bit(EC_FLAGS_GPE_MASKED, &ec->flags)) {
Lv Zhenge1d4d902015-02-06 08:58:05 +0800420 acpi_ec_disable_gpe(ec, false);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800421 ec_dbg_drv("Polling enabled");
Lv Zheng56f77ee2017-08-11 14:36:28 +0800422 set_bit(EC_FLAGS_GPE_MASKED, &ec->flags);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800423 }
424}
425
Lv Zheng56f77ee2017-08-11 14:36:28 +0800426static void acpi_ec_unmask_gpe(struct acpi_ec *ec)
Lv Zhenge1d4d902015-02-06 08:58:05 +0800427{
Lv Zheng56f77ee2017-08-11 14:36:28 +0800428 if (test_bit(EC_FLAGS_GPE_MASKED, &ec->flags)) {
429 clear_bit(EC_FLAGS_GPE_MASKED, &ec->flags);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800430 acpi_ec_enable_gpe(ec, false);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800431 ec_dbg_drv("Polling disabled");
Lv Zhenge1d4d902015-02-06 08:58:05 +0800432 }
433}
434
Lv Zheng9887d222015-02-06 08:57:59 +0800435/*
436 * acpi_ec_submit_flushable_request() - Increase the reference count unless
437 * the flush operation is not in
438 * progress
439 * @ec: the EC device
440 *
441 * This function must be used before taking a new action that should hold
442 * the reference count. If this function returns false, then the action
443 * must be discarded or it will prevent the flush operation from being
444 * completed.
445 */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100446static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
Lv Zheng9887d222015-02-06 08:57:59 +0800447{
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100448 if (!acpi_ec_started(ec))
449 return false;
Lv Zheng9887d222015-02-06 08:57:59 +0800450 acpi_ec_submit_request(ec);
451 return true;
452}
453
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100454static void acpi_ec_submit_query(struct acpi_ec *ec)
Lv Zheng74443bb2015-01-14 19:28:47 +0800455{
Lv Zheng56f77ee2017-08-11 14:36:28 +0800456 acpi_ec_mask_gpe(ec);
Lv Zheng1ab69f22017-06-14 13:59:09 +0800457 if (!acpi_ec_event_enabled(ec))
458 return;
459 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
Lv Zheng9d8993b2015-06-11 13:21:32 +0800460 ec_dbg_evt("Command(%s) submitted/blocked",
461 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
462 ec->nr_pending_queries++;
Lv Zheng74443bb2015-01-14 19:28:47 +0800463 schedule_work(&ec->work);
Lv Zhengf252cb02015-02-06 08:58:10 +0800464 }
Lv Zhengf252cb02015-02-06 08:58:10 +0800465}
466
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100467static void acpi_ec_complete_query(struct acpi_ec *ec)
Lv Zhengf252cb02015-02-06 08:58:10 +0800468{
Lv Zheng1ab69f22017-06-14 13:59:09 +0800469 if (test_and_clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
Lv Zheng9d8993b2015-06-11 13:21:32 +0800470 ec_dbg_evt("Command(%s) unblocked",
471 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zheng56f77ee2017-08-11 14:36:28 +0800472 acpi_ec_unmask_gpe(ec);
Lv Zheng74443bb2015-01-14 19:28:47 +0800473}
474
Lv Zheng750f628b2016-08-03 16:01:24 +0800475static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
476{
477 if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
478 ec_log_drv("event unblocked");
Lv Zheng53c5eaa2017-09-26 16:54:03 +0800479 /*
480 * Unconditionally invoke this once after enabling the event
481 * handling mechanism to detect the pending events.
482 */
483 advance_transaction(ec);
Lv Zheng750f628b2016-08-03 16:01:24 +0800484}
485
486static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
487{
488 if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
489 ec_log_drv("event blocked");
490}
491
Zhang Ruib6a3e142019-02-01 14:13:41 +0800492/*
493 * Process _Q events that might have accumulated in the EC.
494 * Run with locked ec mutex.
495 */
496static void acpi_ec_clear(struct acpi_ec *ec)
497{
498 int i, status;
499 u8 value = 0;
500
501 for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
502 status = acpi_ec_query(ec, &value);
503 if (status || !value)
504 break;
505 }
506 if (unlikely(i == ACPI_EC_CLEAR_MAX))
507 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
508 else
509 pr_info("%d stale EC events cleared\n", i);
510}
511
Lv Zheng750f628b2016-08-03 16:01:24 +0800512static void acpi_ec_enable_event(struct acpi_ec *ec)
513{
514 unsigned long flags;
515
516 spin_lock_irqsave(&ec->lock, flags);
517 if (acpi_ec_started(ec))
518 __acpi_ec_enable_event(ec);
519 spin_unlock_irqrestore(&ec->lock, flags);
Zhang Ruib6a3e142019-02-01 14:13:41 +0800520
521 /* Drain additional events if hardware requires that */
522 if (EC_FLAGS_CLEAR_ON_RESUME)
523 acpi_ec_clear(ec);
Lv Zheng750f628b2016-08-03 16:01:24 +0800524}
525
Eric Biggerseab05ec2016-10-05 10:33:16 -0700526#ifdef CONFIG_PM_SLEEP
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800527static bool acpi_ec_query_flushed(struct acpi_ec *ec)
528{
529 bool flushed;
530 unsigned long flags;
531
532 spin_lock_irqsave(&ec->lock, flags);
533 flushed = !ec->nr_pending_queries;
534 spin_unlock_irqrestore(&ec->lock, flags);
535 return flushed;
536}
537
538static void __acpi_ec_flush_event(struct acpi_ec *ec)
539{
540 /*
541 * When ec_freeze_events is true, we need to flush events in
542 * the proper position before entering the noirq stage.
543 */
544 wait_event(ec->wait, acpi_ec_query_flushed(ec));
545 if (ec_query_wq)
546 flush_workqueue(ec_query_wq);
547}
548
549static void acpi_ec_disable_event(struct acpi_ec *ec)
550{
551 unsigned long flags;
552
553 spin_lock_irqsave(&ec->lock, flags);
554 __acpi_ec_disable_event(ec);
555 spin_unlock_irqrestore(&ec->lock, flags);
556 __acpi_ec_flush_event(ec);
557}
Rafael J. Wysocki880a6622017-07-20 03:43:12 +0200558
559void acpi_ec_flush_work(void)
560{
561 if (first_ec)
562 __acpi_ec_flush_event(first_ec);
563
564 flush_scheduled_work();
565}
Eric Biggerseab05ec2016-10-05 10:33:16 -0700566#endif /* CONFIG_PM_SLEEP */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800567
Lv Zheng1d68d262015-06-11 13:21:38 +0800568static bool acpi_ec_guard_event(struct acpi_ec *ec)
569{
Lv Zheng61197542015-09-24 14:54:54 +0800570 bool guarded = true;
571 unsigned long flags;
572
573 spin_lock_irqsave(&ec->lock, flags);
574 /*
575 * If firmware SCI_EVT clearing timing is "event", we actually
576 * don't know when the SCI_EVT will be cleared by firmware after
577 * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
578 * acceptable period.
579 *
580 * The guarding period begins when EC_FLAGS_QUERY_PENDING is
581 * flagged, which means SCI_EVT check has just been performed.
582 * But if the current transaction is ACPI_EC_COMMAND_QUERY, the
583 * guarding should have already been performed (via
584 * EC_FLAGS_QUERY_GUARDING) and should not be applied so that the
585 * ACPI_EC_COMMAND_QUERY transaction can be transitioned into
586 * ACPI_EC_COMMAND_POLL state immediately.
587 */
Lv Zheng1d68d262015-06-11 13:21:38 +0800588 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
589 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY ||
590 !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
591 (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
Lv Zheng61197542015-09-24 14:54:54 +0800592 guarded = false;
593 spin_unlock_irqrestore(&ec->lock, flags);
594 return guarded;
Lv Zheng1d68d262015-06-11 13:21:38 +0800595}
596
Lv Zhengd8d031a2015-05-15 14:16:42 +0800597static int ec_transaction_polled(struct acpi_ec *ec)
598{
599 unsigned long flags;
600 int ret = 0;
601
602 spin_lock_irqsave(&ec->lock, flags);
603 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
604 ret = 1;
605 spin_unlock_irqrestore(&ec->lock, flags);
606 return ret;
607}
608
Lv Zhengf92fca02014-06-15 08:41:35 +0800609static int ec_transaction_completed(struct acpi_ec *ec)
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400610{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400611 unsigned long flags;
612 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800613
Feng Tangf351d022012-10-23 01:29:27 +0200614 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengc0d65342014-06-15 08:42:07 +0800615 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400616 ret = 1;
Feng Tangf351d022012-10-23 01:29:27 +0200617 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400618 return ret;
619}
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400620
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800621static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
622{
623 ec->curr->flags |= flag;
624 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
Lv Zheng1d68d262015-06-11 13:21:38 +0800625 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS &&
626 flag == ACPI_EC_COMMAND_POLL)
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800627 acpi_ec_complete_query(ec);
Lv Zheng1d68d262015-06-11 13:21:38 +0800628 if (ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY &&
629 flag == ACPI_EC_COMMAND_COMPLETE)
630 acpi_ec_complete_query(ec);
631 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
632 flag == ACPI_EC_COMMAND_COMPLETE)
633 set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800634 }
635}
636
Lv Zheng0c788082015-01-14 19:28:22 +0800637static void advance_transaction(struct acpi_ec *ec)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400638{
Puneet Kumar36b15872013-11-15 11:41:29 -0800639 struct transaction *t;
Lv Zheng66b42b72014-06-15 08:41:17 +0800640 u8 status;
Lv Zhengc0d65342014-06-15 08:42:07 +0800641 bool wakeup = false;
Feng Tangb76b51b2012-10-23 01:29:38 +0200642
Lv Zheng3535a3c2015-02-27 14:48:15 +0800643 ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
644 smp_processor_id());
Lv Zhengca37bfd2015-02-05 16:27:22 +0800645 /*
646 * By always clearing STS before handling all indications, we can
647 * ensure a hardware STS 0->1 change after this clearing can always
648 * trigger a GPE interrupt.
649 */
650 acpi_ec_clear_gpe(ec);
Lv Zheng66b42b72014-06-15 08:41:17 +0800651 status = acpi_ec_read_status(ec);
Puneet Kumar36b15872013-11-15 11:41:29 -0800652 t = ec->curr;
Lv Zheng1d68d262015-06-11 13:21:38 +0800653 /*
654 * Another IRQ or a guarded polling mode advancement is detected,
655 * the next QR_EC submission is then allowed.
656 */
657 if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
658 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
Lv Zheng66db3832015-06-11 13:21:51 +0800659 (!ec->nr_pending_queries ||
660 test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
Lv Zheng1d68d262015-06-11 13:21:38 +0800661 clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
662 acpi_ec_complete_query(ec);
663 }
664 }
Feng Tangb76b51b2012-10-23 01:29:38 +0200665 if (!t)
Lv Zhengf92fca02014-06-15 08:41:35 +0800666 goto err;
667 if (t->flags & ACPI_EC_COMMAND_POLL) {
668 if (t->wlen > t->wi) {
669 if ((status & ACPI_EC_FLAG_IBF) == 0)
670 acpi_ec_write_data(ec, t->wdata[t->wi++]);
671 else
672 goto err;
673 } else if (t->rlen > t->ri) {
674 if ((status & ACPI_EC_FLAG_OBF) == 1) {
675 t->rdata[t->ri++] = acpi_ec_read_data(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +0800676 if (t->rlen == t->ri) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800677 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800678 if (t->command == ACPI_EC_COMMAND_QUERY)
Lv Zheng9d8993b2015-06-11 13:21:32 +0800679 ec_dbg_evt("Command(%s) completed by hardware",
680 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zhengc0d65342014-06-15 08:42:07 +0800681 wakeup = true;
682 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800683 } else
684 goto err;
685 } else if (t->wlen == t->wi &&
Lv Zhengc0d65342014-06-15 08:42:07 +0800686 (status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800687 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zhengc0d65342014-06-15 08:42:07 +0800688 wakeup = true;
689 }
Lv Zheng0c788082015-01-14 19:28:22 +0800690 goto out;
Lv Zhengf92fca02014-06-15 08:41:35 +0800691 } else {
Lv Zheng79149002014-10-29 11:33:49 +0800692 if (EC_FLAGS_QUERY_HANDSHAKE &&
693 !(status & ACPI_EC_FLAG_SCI) &&
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800694 (t->command == ACPI_EC_COMMAND_QUERY)) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800695 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800696 t->rdata[t->ri++] = 0x00;
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800697 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zheng9d8993b2015-06-11 13:21:32 +0800698 ec_dbg_evt("Command(%s) completed by software",
699 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800700 wakeup = true;
701 } else if ((status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf92fca02014-06-15 08:41:35 +0800702 acpi_ec_write_cmd(ec, t->command);
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800703 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400704 } else
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300705 goto err;
Lv Zheng0c788082015-01-14 19:28:22 +0800706 goto out;
Lv Zhengf92fca02014-06-15 08:41:35 +0800707 }
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300708err:
Feng Tanga3cd8d22012-10-23 01:30:12 +0200709 /*
710 * If SCI bit is set, then don't think it's a false IRQ
711 * otherwise will take a not handled IRQ as a false one.
712 */
Lv Zhengf92fca02014-06-15 08:41:35 +0800713 if (!(status & ACPI_EC_FLAG_SCI)) {
Lv Zhenge1d4d902015-02-06 08:58:05 +0800714 if (in_interrupt() && t) {
715 if (t->irq_count < ec_storm_threshold)
716 ++t->irq_count;
717 /* Allow triggering on 0 threshold */
718 if (t->irq_count == ec_storm_threshold)
Lv Zheng56f77ee2017-08-11 14:36:28 +0800719 acpi_ec_mask_gpe(ec);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800720 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800721 }
Lv Zheng0c788082015-01-14 19:28:22 +0800722out:
Lv Zheng74443bb2015-01-14 19:28:47 +0800723 if (status & ACPI_EC_FLAG_SCI)
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100724 acpi_ec_submit_query(ec);
Lv Zheng0c788082015-01-14 19:28:22 +0800725 if (wakeup && in_interrupt())
726 wake_up(&ec->wait);
Lv Zhengf92fca02014-06-15 08:41:35 +0800727}
Feng Tanga3cd8d22012-10-23 01:30:12 +0200728
Lv Zhengf92fca02014-06-15 08:41:35 +0800729static void start_transaction(struct acpi_ec *ec)
730{
731 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
732 ec->curr->flags = 0;
Lv Zhengd8d031a2015-05-15 14:16:42 +0800733}
734
735static int ec_guard(struct acpi_ec *ec)
736{
Lv Zhengc3a696b2017-01-20 16:42:48 +0800737 unsigned long guard = usecs_to_jiffies(ec->polling_guard);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800738 unsigned long timeout = ec->timestamp + guard;
739
Lv Zheng61197542015-09-24 14:54:54 +0800740 /* Ensure guarding period before polling EC status */
Lv Zhengd8d031a2015-05-15 14:16:42 +0800741 do {
Lv Zhengc3a696b2017-01-20 16:42:48 +0800742 if (ec->busy_polling) {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800743 /* Perform busy polling */
744 if (ec_transaction_completed(ec))
745 return 0;
746 udelay(jiffies_to_usecs(guard));
747 } else {
748 /*
749 * Perform wait polling
Lv Zheng61197542015-09-24 14:54:54 +0800750 * 1. Wait the transaction to be completed by the
751 * GPE handler after the transaction enters
752 * ACPI_EC_COMMAND_POLL state.
753 * 2. A special guarding logic is also required
754 * for event clearing mode "event" before the
755 * transaction enters ACPI_EC_COMMAND_POLL
756 * state.
Lv Zhengd8d031a2015-05-15 14:16:42 +0800757 */
Lv Zheng1d68d262015-06-11 13:21:38 +0800758 if (!ec_transaction_polled(ec) &&
759 !acpi_ec_guard_event(ec))
Lv Zhengd8d031a2015-05-15 14:16:42 +0800760 break;
761 if (wait_event_timeout(ec->wait,
762 ec_transaction_completed(ec),
763 guard))
764 return 0;
765 }
Lv Zhengd8d031a2015-05-15 14:16:42 +0800766 } while (time_before(jiffies, timeout));
767 return -ETIME;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400768}
769
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400770static int ec_poll(struct acpi_ec *ec)
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300771{
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400772 unsigned long flags;
Lan Tianyu28fe5c82013-05-06 03:23:40 +0000773 int repeat = 5; /* number of command restarts */
Lv Zheng7a73e602014-10-14 14:24:01 +0800774
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400775 while (repeat--) {
776 unsigned long delay = jiffies +
Thomas Renninger7a18e962010-10-21 18:24:57 +0200777 msecs_to_jiffies(ec_delay);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400778 do {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800779 if (!ec_guard(ec))
780 return 0;
Lv Zhengf92fca02014-06-15 08:41:35 +0800781 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800782 advance_transaction(ec);
Lv Zhengf92fca02014-06-15 08:41:35 +0800783 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400784 } while (time_before(jiffies, delay));
Lan Tianyu16a26e82013-09-12 03:32:04 -0400785 pr_debug("controller reset, restart transaction\n");
Feng Tangf351d022012-10-23 01:29:27 +0200786 spin_lock_irqsave(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400787 start_transaction(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200788 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiyaf3fd142006-12-07 18:42:16 +0300789 }
Alexey Starikovskiyb77d81b2008-03-21 17:07:15 +0300790 return -ETIME;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500791}
792
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400793static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400794 struct transaction *t)
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400795{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400796 unsigned long tmp;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400797 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800798
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400799 /* start transaction */
Feng Tangf351d022012-10-23 01:29:27 +0200800 spin_lock_irqsave(&ec->lock, tmp);
Lv Zheng9887d222015-02-06 08:57:59 +0800801 /* Enable GPE for command processing (IBF=0/OBF=1) */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100802 if (!acpi_ec_submit_flushable_request(ec)) {
Lv Zhengad479e72015-02-06 08:57:52 +0800803 ret = -EINVAL;
804 goto unlock;
805 }
Lv Zheng770970f2015-02-27 14:48:24 +0800806 ec_dbg_ref(ec, "Increase command");
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400807 /* following two actions should be kept atomic */
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400808 ec->curr = t;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800809 ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300810 start_transaction(ec);
Lv Zhengdf9ff912014-10-29 11:33:43 +0800811 spin_unlock_irqrestore(&ec->lock, tmp);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800812
Lv Zhengdf9ff912014-10-29 11:33:43 +0800813 ret = ec_poll(ec);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800814
Lv Zhengdf9ff912014-10-29 11:33:43 +0800815 spin_lock_irqsave(&ec->lock, tmp);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800816 if (t->irq_count == ec_storm_threshold)
Lv Zheng56f77ee2017-08-11 14:36:28 +0800817 acpi_ec_unmask_gpe(ec);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800818 ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400819 ec->curr = NULL;
Lv Zheng9887d222015-02-06 08:57:59 +0800820 /* Disable GPE for command processing (IBF=0/OBF=1) */
821 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800822 ec_dbg_ref(ec, "Decrease command");
Lv Zhengad479e72015-02-06 08:57:52 +0800823unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200824 spin_unlock_irqrestore(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400825 return ret;
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400826}
827
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400828static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
Luming Yu45bea152005-07-23 04:08:00 -0400829{
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400830 int status;
Len Brown50526df2005-08-11 17:32:05 -0400831 u32 glk;
Lv Zheng7a73e602014-10-14 14:24:01 +0800832
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400833 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
Patrick Mocheld550d982006-06-27 00:41:40 -0400834 return -EINVAL;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400835 if (t->rdata)
836 memset(t->rdata, 0, t->rlen);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800837
Feng Tangf351d022012-10-23 01:29:27 +0200838 mutex_lock(&ec->mutex);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400839 if (ec->global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300841 if (ACPI_FAILURE(status)) {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400842 status = -ENODEV;
843 goto unlock;
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300844 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 }
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300846
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400847 status = acpi_ec_transaction_unlocked(ec, t);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300848
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400849 if (ec->global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 acpi_release_global_lock(glk);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400851unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200852 mutex_unlock(&ec->mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400853 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854}
855
Roel Kluin8a383ef2008-12-09 20:45:30 +0100856static int acpi_ec_burst_enable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300857{
858 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400859 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
860 .wdata = NULL, .rdata = &d,
861 .wlen = 0, .rlen = 1};
862
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400863 return acpi_ec_transaction(ec, &t);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300864}
865
Roel Kluin8a383ef2008-12-09 20:45:30 +0100866static int acpi_ec_burst_disable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300867{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400868 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
869 .wdata = NULL, .rdata = NULL,
870 .wlen = 0, .rlen = 0};
871
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400872 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400873 acpi_ec_transaction(ec, &t) : 0;
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300874}
875
Lv Zheng7a73e602014-10-14 14:24:01 +0800876static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400877{
878 int result;
879 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400880 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
881 .wdata = &address, .rdata = &d,
882 .wlen = 1, .rlen = 1};
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400883
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400884 result = acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400885 *data = d;
886 return result;
887}
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400888
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400889static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
890{
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300891 u8 wdata[2] = { address, data };
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400892 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
893 .wdata = wdata, .rdata = NULL,
894 .wlen = 2, .rlen = 0};
895
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400896 return acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400897}
898
Feng Tangb76b51b2012-10-23 01:29:38 +0200899int ec_read(u8 addr, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 int err;
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400902 u8 temp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
904 if (!first_ec)
905 return -ENODEV;
906
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300907 err = acpi_ec_read(first_ec, addr, &temp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908
909 if (!err) {
910 *val = temp_data;
911 return 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800912 }
913 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914}
915EXPORT_SYMBOL(ec_read);
916
Len Brown50526df2005-08-11 17:32:05 -0400917int ec_write(u8 addr, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 int err;
920
921 if (!first_ec)
922 return -ENODEV;
923
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300924 err = acpi_ec_write(first_ec, addr, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926 return err;
927}
928EXPORT_SYMBOL(ec_write);
929
Randy Dunlap616362d2006-10-27 01:47:34 -0400930int ec_transaction(u8 command,
Lv Zheng7a73e602014-10-14 14:24:01 +0800931 const u8 *wdata, unsigned wdata_len,
932 u8 *rdata, unsigned rdata_len)
Luming Yu45bea152005-07-23 04:08:00 -0400933{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400934 struct transaction t = {.command = command,
935 .wdata = wdata, .rdata = rdata,
936 .wlen = wdata_len, .rlen = rdata_len};
Lv Zheng7a73e602014-10-14 14:24:01 +0800937
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400938 if (!first_ec)
939 return -ENODEV;
940
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400941 return acpi_ec_transaction(first_ec, &t);
Luming Yu45bea152005-07-23 04:08:00 -0400942}
Lennart Poetteringab9e43c2006-10-03 22:49:00 -0400943EXPORT_SYMBOL(ec_transaction);
944
Seth Forshee3e2abc52012-01-18 13:44:08 -0600945/* Get the handle to the EC device */
946acpi_handle ec_get_handle(void)
947{
948 if (!first_ec)
949 return NULL;
950 return first_ec->handle;
951}
Seth Forshee3e2abc52012-01-18 13:44:08 -0600952EXPORT_SYMBOL(ec_get_handle);
953
Lv Zhengad479e72015-02-06 08:57:52 +0800954static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
955{
956 unsigned long flags;
957
958 spin_lock_irqsave(&ec->lock, flags);
959 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800960 ec_dbg_drv("Starting EC");
Lv Zheng9887d222015-02-06 08:57:59 +0800961 /* Enable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800962 if (!resuming) {
Lv Zheng9887d222015-02-06 08:57:59 +0800963 acpi_ec_submit_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800964 ec_dbg_ref(ec, "Increase driver");
Lv Zhengc2b46d62016-08-03 16:01:36 +0800965 }
Lv Zheng3535a3c2015-02-27 14:48:15 +0800966 ec_log_drv("EC started");
Lv Zhengad479e72015-02-06 08:57:52 +0800967 }
968 spin_unlock_irqrestore(&ec->lock, flags);
969}
970
Lv Zheng9887d222015-02-06 08:57:59 +0800971static bool acpi_ec_stopped(struct acpi_ec *ec)
972{
973 unsigned long flags;
974 bool flushed;
975
976 spin_lock_irqsave(&ec->lock, flags);
977 flushed = acpi_ec_flushed(ec);
978 spin_unlock_irqrestore(&ec->lock, flags);
979 return flushed;
980}
981
Lv Zhengad479e72015-02-06 08:57:52 +0800982static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
983{
984 unsigned long flags;
985
986 spin_lock_irqsave(&ec->lock, flags);
987 if (acpi_ec_started(ec)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800988 ec_dbg_drv("Stopping EC");
Lv Zhengad479e72015-02-06 08:57:52 +0800989 set_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng9887d222015-02-06 08:57:59 +0800990 spin_unlock_irqrestore(&ec->lock, flags);
991 wait_event(ec->wait, acpi_ec_stopped(ec));
992 spin_lock_irqsave(&ec->lock, flags);
993 /* Disable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800994 if (!suspending) {
Lv Zheng9887d222015-02-06 08:57:59 +0800995 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800996 ec_dbg_ref(ec, "Decrease driver");
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800997 } else if (!ec_freeze_events)
Lv Zheng750f628b2016-08-03 16:01:24 +0800998 __acpi_ec_disable_event(ec);
Lv Zhengad479e72015-02-06 08:57:52 +0800999 clear_bit(EC_FLAGS_STARTED, &ec->flags);
1000 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng3535a3c2015-02-27 14:48:15 +08001001 ec_log_drv("EC stopped");
Lv Zhengad479e72015-02-06 08:57:52 +08001002 }
1003 spin_unlock_irqrestore(&ec->lock, flags);
1004}
1005
Lv Zhengc3a696b2017-01-20 16:42:48 +08001006static void acpi_ec_enter_noirq(struct acpi_ec *ec)
1007{
1008 unsigned long flags;
1009
1010 spin_lock_irqsave(&ec->lock, flags);
1011 ec->busy_polling = true;
1012 ec->polling_guard = 0;
1013 ec_log_drv("interrupt blocked");
1014 spin_unlock_irqrestore(&ec->lock, flags);
1015}
1016
1017static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1018{
1019 unsigned long flags;
1020
1021 spin_lock_irqsave(&ec->lock, flags);
1022 ec->busy_polling = ec_busy_polling;
1023 ec->polling_guard = ec_polling_guard;
1024 ec_log_drv("interrupt unblocked");
1025 spin_unlock_irqrestore(&ec->lock, flags);
1026}
1027
Rafael J. Wysockife955682010-04-09 01:40:38 +02001028void acpi_ec_block_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001029{
1030 struct acpi_ec *ec = first_ec;
1031
1032 if (!ec)
1033 return;
1034
Feng Tangf351d022012-10-23 01:29:27 +02001035 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001036 /* Prevent transactions from being carried out */
Lv Zhengad479e72015-02-06 08:57:52 +08001037 acpi_ec_stop(ec, true);
Feng Tangf351d022012-10-23 01:29:27 +02001038 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001039}
1040
Rafael J. Wysockife955682010-04-09 01:40:38 +02001041void acpi_ec_unblock_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001042{
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001043 /*
1044 * Allow transactions to happen again (this function is called from
1045 * atomic context during wakeup, so we don't need to acquire the mutex).
1046 */
1047 if (first_ec)
Lv Zhengad479e72015-02-06 08:57:52 +08001048 acpi_ec_start(first_ec, true);
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001049}
1050
Rafael J. Wysockif941d3e2018-12-17 12:21:55 +01001051void acpi_ec_mark_gpe_for_wake(void)
1052{
1053 if (first_ec && !ec_no_wakeup)
1054 acpi_mark_gpe_for_wake(NULL, first_ec->gpe);
1055}
1056
1057void acpi_ec_set_gpe_wake_mask(u8 action)
1058{
1059 if (first_ec && !ec_no_wakeup)
1060 acpi_set_gpe_wake_mask(NULL, first_ec->gpe, action);
1061}
1062
Rafael J. Wysocki68e22012018-05-16 14:13:21 +02001063void acpi_ec_dispatch_gpe(void)
1064{
1065 if (first_ec)
1066 acpi_dispatch_gpe(NULL, first_ec->gpe);
1067}
1068
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069/* --------------------------------------------------------------------------
1070 Event Management
1071 -------------------------------------------------------------------------- */
Lv Zheng01305d42015-01-14 19:28:28 +08001072static struct acpi_ec_query_handler *
1073acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler)
1074{
1075 if (handler)
1076 kref_get(&handler->kref);
1077 return handler;
1078}
1079
Lv Zheng0700c042015-09-24 14:54:48 +08001080static struct acpi_ec_query_handler *
1081acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1082{
1083 struct acpi_ec_query_handler *handler;
1084 bool found = false;
1085
1086 mutex_lock(&ec->mutex);
1087 list_for_each_entry(handler, &ec->list, node) {
1088 if (value == handler->query_bit) {
1089 found = true;
1090 break;
1091 }
1092 }
1093 mutex_unlock(&ec->mutex);
1094 return found ? acpi_ec_get_query_handler(handler) : NULL;
1095}
1096
Lv Zheng01305d42015-01-14 19:28:28 +08001097static void acpi_ec_query_handler_release(struct kref *kref)
1098{
1099 struct acpi_ec_query_handler *handler =
1100 container_of(kref, struct acpi_ec_query_handler, kref);
1101
1102 kfree(handler);
1103}
1104
1105static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1106{
1107 kref_put(&handler->kref, acpi_ec_query_handler_release);
1108}
1109
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001110int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1111 acpi_handle handle, acpi_ec_query_func func,
1112 void *data)
1113{
1114 struct acpi_ec_query_handler *handler =
1115 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001116
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001117 if (!handler)
1118 return -ENOMEM;
1119
1120 handler->query_bit = query_bit;
1121 handler->handle = handle;
1122 handler->func = func;
1123 handler->data = data;
Feng Tangf351d022012-10-23 01:29:27 +02001124 mutex_lock(&ec->mutex);
Lv Zheng01305d42015-01-14 19:28:28 +08001125 kref_init(&handler->kref);
Alexey Starikovskiy30c08572007-09-26 19:43:22 +04001126 list_add(&handler->node, &ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001127 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001128 return 0;
1129}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001130EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1131
Lv Zheng0700c042015-09-24 14:54:48 +08001132static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1133 bool remove_all, u8 query_bit)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001134{
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001135 struct acpi_ec_query_handler *handler, *tmp;
Lv Zheng01305d42015-01-14 19:28:28 +08001136 LIST_HEAD(free_list);
Lv Zheng7a73e602014-10-14 14:24:01 +08001137
Feng Tangf351d022012-10-23 01:29:27 +02001138 mutex_lock(&ec->mutex);
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001139 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
Lv Zheng0700c042015-09-24 14:54:48 +08001140 if (remove_all || query_bit == handler->query_bit) {
Lv Zheng01305d42015-01-14 19:28:28 +08001141 list_del_init(&handler->node);
1142 list_add(&handler->node, &free_list);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001143 }
1144 }
Feng Tangf351d022012-10-23 01:29:27 +02001145 mutex_unlock(&ec->mutex);
Chris Bainbridge6b5eab52015-04-22 00:25:36 +01001146 list_for_each_entry_safe(handler, tmp, &free_list, node)
Lv Zheng01305d42015-01-14 19:28:28 +08001147 acpi_ec_put_query_handler(handler);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001148}
Lv Zheng0700c042015-09-24 14:54:48 +08001149
1150void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1151{
1152 acpi_ec_remove_query_handlers(ec, false, query_bit);
1153}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001154EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
Lv Zheng02b771b2015-08-12 11:12:02 +08001156static struct acpi_ec_query *acpi_ec_create_query(u8 *pval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157{
Lv Zheng02b771b2015-08-12 11:12:02 +08001158 struct acpi_ec_query *q;
1159 struct transaction *t;
Lv Zheng7a73e602014-10-14 14:24:01 +08001160
Lv Zheng02b771b2015-08-12 11:12:02 +08001161 q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1162 if (!q)
1163 return NULL;
1164 INIT_WORK(&q->work, acpi_ec_event_processor);
1165 t = &q->transaction;
1166 t->command = ACPI_EC_COMMAND_QUERY;
1167 t->rdata = pval;
1168 t->rlen = 1;
1169 return q;
1170}
1171
1172static void acpi_ec_delete_query(struct acpi_ec_query *q)
1173{
1174 if (q) {
1175 if (q->handler)
1176 acpi_ec_put_query_handler(q->handler);
1177 kfree(q);
1178 }
1179}
1180
1181static void acpi_ec_event_processor(struct work_struct *work)
1182{
1183 struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1184 struct acpi_ec_query_handler *handler = q->handler;
1185
Lv Zheng3535a3c2015-02-27 14:48:15 +08001186 ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001187 if (handler->func)
1188 handler->func(handler->data);
1189 else if (handler->handle)
1190 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
Lv Zheng3535a3c2015-02-27 14:48:15 +08001191 ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
Lv Zheng02b771b2015-08-12 11:12:02 +08001192 acpi_ec_delete_query(q);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001193}
1194
Lv Zheng550b3aac2015-01-14 19:28:53 +08001195static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001196{
1197 u8 value = 0;
Lv Zhengc2cf5762015-01-14 19:28:33 +08001198 int result;
Lv Zheng02b771b2015-08-12 11:12:02 +08001199 struct acpi_ec_query *q;
1200
1201 q = acpi_ec_create_query(&value);
1202 if (!q)
1203 return -ENOMEM;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301204
Lv Zheng550b3aac2015-01-14 19:28:53 +08001205 /*
1206 * Query the EC to find out which _Qxx method we need to evaluate.
1207 * Note that successful completion of the query causes the ACPI_EC_SCI
1208 * bit to be cleared (and thus clearing the interrupt source).
1209 */
Lv Zheng02b771b2015-08-12 11:12:02 +08001210 result = acpi_ec_transaction(ec, &q->transaction);
Lv Zheng550b3aac2015-01-14 19:28:53 +08001211 if (!value)
Lv Zheng02b771b2015-08-12 11:12:02 +08001212 result = -ENODATA;
1213 if (result)
1214 goto err_exit;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301215
Lv Zheng0700c042015-09-24 14:54:48 +08001216 q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1217 if (!q->handler) {
1218 result = -ENODATA;
1219 goto err_exit;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001220 }
Lv Zheng0700c042015-09-24 14:54:48 +08001221
1222 /*
1223 * It is reported that _Qxx are evaluated in a parallel way on
1224 * Windows:
1225 * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1226 *
1227 * Put this log entry before schedule_work() in order to make
1228 * it appearing before any other log entries occurred during the
1229 * work queue execution.
1230 */
1231 ec_dbg_evt("Query(0x%02x) scheduled", value);
Lv Zhenge1191bd2016-08-03 09:00:14 +08001232 if (!queue_work(ec_query_wq, &q->work)) {
Lv Zheng0700c042015-09-24 14:54:48 +08001233 ec_dbg_evt("Query(0x%02x) overlapped", value);
1234 result = -EBUSY;
1235 }
Lv Zheng02b771b2015-08-12 11:12:02 +08001236
1237err_exit:
Markus Elfring4981c2b2015-11-15 22:42:27 +01001238 if (result)
Lv Zheng02b771b2015-08-12 11:12:02 +08001239 acpi_ec_delete_query(q);
1240 if (data)
1241 *data = value;
Lv Zhengc2cf5762015-01-14 19:28:33 +08001242 return result;
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001243}
1244
Lv Zheng1d68d262015-06-11 13:21:38 +08001245static void acpi_ec_check_event(struct acpi_ec *ec)
1246{
1247 unsigned long flags;
1248
1249 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1250 if (ec_guard(ec)) {
1251 spin_lock_irqsave(&ec->lock, flags);
1252 /*
1253 * Take care of the SCI_EVT unless no one else is
1254 * taking care of it.
1255 */
1256 if (!ec->curr)
1257 advance_transaction(ec);
1258 spin_unlock_irqrestore(&ec->lock, flags);
1259 }
1260 }
1261}
1262
Lv Zheng9d8993b2015-06-11 13:21:32 +08001263static void acpi_ec_event_handler(struct work_struct *work)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001264{
Lv Zheng9d8993b2015-06-11 13:21:32 +08001265 unsigned long flags;
Lv Zheng74443bb2015-01-14 19:28:47 +08001266 struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
Lv Zheng7a73e602014-10-14 14:24:01 +08001267
Lv Zheng9d8993b2015-06-11 13:21:32 +08001268 ec_dbg_evt("Event started");
1269
1270 spin_lock_irqsave(&ec->lock, flags);
1271 while (ec->nr_pending_queries) {
1272 spin_unlock_irqrestore(&ec->lock, flags);
1273 (void)acpi_ec_query(ec, NULL);
1274 spin_lock_irqsave(&ec->lock, flags);
1275 ec->nr_pending_queries--;
Lv Zheng66db3832015-06-11 13:21:51 +08001276 /*
1277 * Before exit, make sure that this work item can be
1278 * scheduled again. There might be QR_EC failures, leaving
1279 * EC_FLAGS_QUERY_PENDING uncleared and preventing this work
1280 * item from being scheduled again.
1281 */
1282 if (!ec->nr_pending_queries) {
1283 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
1284 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY)
1285 acpi_ec_complete_query(ec);
1286 }
Lv Zheng9d8993b2015-06-11 13:21:32 +08001287 }
1288 spin_unlock_irqrestore(&ec->lock, flags);
1289
1290 ec_dbg_evt("Event stopped");
Lv Zheng1d68d262015-06-11 13:21:38 +08001291
1292 acpi_ec_check_event(ec);
Luming Yu45bea152005-07-23 04:08:00 -04001293}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294
Lin Ming8b6cd8a2010-12-13 13:38:46 +08001295static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1296 u32 gpe_number, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297{
Lv Zhengf92fca02014-06-15 08:41:35 +08001298 unsigned long flags;
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +03001299 struct acpi_ec *ec = data;
Lennart Poettering00eb43a2007-05-04 14:16:19 +02001300
Lv Zhengf92fca02014-06-15 08:41:35 +08001301 spin_lock_irqsave(&ec->lock, flags);
Lv Zheng0c788082015-01-14 19:28:22 +08001302 advance_transaction(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +08001303 spin_unlock_irqrestore(&ec->lock, flags);
Lv Zhengca37bfd2015-02-05 16:27:22 +08001304 return ACPI_INTERRUPT_HANDLED;
Alexey Starikovskiy845625c2008-03-21 17:07:03 +03001305}
1306
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001308 * Address Space Management
1309 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
1311static acpi_status
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001312acpi_ec_space_handler(u32 function, acpi_physical_address address,
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001313 u32 bits, u64 *value64,
Len Brown50526df2005-08-11 17:32:05 -04001314 void *handler_context, void *region_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315{
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +03001316 struct acpi_ec *ec = handler_context;
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001317 int result = 0, i, bytes = bits / 8;
1318 u8 *value = (u8 *)value64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 if ((address > 0xFF) || !value || !handler_context)
Patrick Mocheld550d982006-06-27 00:41:40 -04001321 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001323 if (function != ACPI_READ && function != ACPI_WRITE)
Patrick Mocheld550d982006-06-27 00:41:40 -04001324 return AE_BAD_PARAMETER;
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001325
Lv Zhengc3a696b2017-01-20 16:42:48 +08001326 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001327 acpi_ec_burst_enable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001328
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001329 for (i = 0; i < bytes; ++i, ++address, ++value)
1330 result = (function == ACPI_READ) ?
1331 acpi_ec_read(ec, address, value) :
1332 acpi_ec_write(ec, address, *value);
Alexey Starikovskiy3e71a872008-01-11 02:42:51 +03001333
Lv Zhengc3a696b2017-01-20 16:42:48 +08001334 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001335 acpi_ec_burst_disable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001336
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 switch (result) {
1338 case -EINVAL:
Patrick Mocheld550d982006-06-27 00:41:40 -04001339 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 case -ENODEV:
Patrick Mocheld550d982006-06-27 00:41:40 -04001341 return AE_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 case -ETIME:
Patrick Mocheld550d982006-06-27 00:41:40 -04001343 return AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 default:
Patrick Mocheld550d982006-06-27 00:41:40 -04001345 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347}
1348
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001350 * Driver Interface
1351 * -------------------------------------------------------------------------- */
1352
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001353static acpi_status
1354ec_parse_io_ports(struct acpi_resource *resource, void *context);
1355
Lv Zheng72c77b72016-09-07 16:50:08 +08001356static void acpi_ec_free(struct acpi_ec *ec)
1357{
1358 if (first_ec == ec)
1359 first_ec = NULL;
1360 if (boot_ec == ec)
1361 boot_ec = NULL;
1362 kfree(ec);
1363}
1364
1365static struct acpi_ec *acpi_ec_alloc(void)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001366{
1367 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001368
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001369 if (!ec)
1370 return NULL;
Feng Tangf351d022012-10-23 01:29:27 +02001371 mutex_init(&ec->mutex);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001372 init_waitqueue_head(&ec->wait);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001373 INIT_LIST_HEAD(&ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001374 spin_lock_init(&ec->lock);
Lv Zheng9d8993b2015-06-11 13:21:32 +08001375 INIT_WORK(&ec->work, acpi_ec_event_handler);
Lv Zhengd8d031a2015-05-15 14:16:42 +08001376 ec->timestamp = jiffies;
Lv Zhengc3a696b2017-01-20 16:42:48 +08001377 ec->busy_polling = true;
1378 ec->polling_guard = 0;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001379 return ec;
1380}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001382static acpi_status
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001383acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1384 void *context, void **return_value)
1385{
Lin Ming0175d562008-12-16 16:46:12 +08001386 char node_name[5];
1387 struct acpi_buffer buffer = { sizeof(node_name), node_name };
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001388 struct acpi_ec *ec = context;
1389 int value = 0;
Lin Ming0175d562008-12-16 16:46:12 +08001390 acpi_status status;
1391
1392 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1393
Lv Zheng7a73e602014-10-14 14:24:01 +08001394 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001395 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001396 return AE_OK;
1397}
1398
1399static acpi_status
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001400ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001401{
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001402 acpi_status status;
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001403 unsigned long long tmp = 0;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001404 struct acpi_ec *ec = context;
Alexey Starikovskiya5032bf2009-04-01 01:33:15 -04001405
1406 /* clear addr values, ec_parse_io_ports depend on it */
1407 ec->command_addr = ec->data_addr = 0;
1408
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001409 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1410 ec_parse_io_ports, ec);
1411 if (ACPI_FAILURE(status))
1412 return status;
Lv Zhengae56c9f2017-06-15 09:41:35 +08001413 if (ec->data_addr == 0 || ec->command_addr == 0)
1414 return AE_OK;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001415
Chris Chiu440f53d2017-06-15 09:41:47 +08001416 if (boot_ec && boot_ec_is_ecdt && EC_FLAGS_IGNORE_DSDT_GPE) {
1417 /*
1418 * Always inherit the GPE number setting from the ECDT
1419 * EC.
1420 */
1421 ec->gpe = boot_ec->gpe;
1422 } else {
1423 /* Get GPE bit assignment (EC events). */
1424 /* TODO: Add support for _GPE returning a package */
1425 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1426 if (ACPI_FAILURE(status))
1427 return status;
1428 ec->gpe = tmp;
1429 }
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001430 /* Use the global lock for all EC transactions? */
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001431 tmp = 0;
Matthew Wilcox27663c52008-10-10 02:22:59 -04001432 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1433 ec->global_lock = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001434 ec->handle = handle;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001435 return AE_CTRL_TERMINATE;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001436}
1437
Lv Zheng72c77b72016-09-07 16:50:08 +08001438/*
1439 * Note: This function returns an error code only when the address space
1440 * handler is not installed, which means "not able to handle
1441 * transactions".
1442 */
Lv Zheng2a570842016-09-07 16:50:21 +08001443static int ec_install_handlers(struct acpi_ec *ec, bool handle_events)
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001444{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001445 acpi_status status;
Lv Zheng7a73e602014-10-14 14:24:01 +08001446
Lv Zhengad479e72015-02-06 08:57:52 +08001447 acpi_ec_start(ec, false);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001448
1449 if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
Lv Zhengc3a696b2017-01-20 16:42:48 +08001450 acpi_ec_enter_noirq(ec);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001451 status = acpi_install_address_space_handler(ec->handle,
1452 ACPI_ADR_SPACE_EC,
1453 &acpi_ec_space_handler,
1454 NULL, ec);
1455 if (ACPI_FAILURE(status)) {
1456 if (status == AE_NOT_FOUND) {
1457 /*
1458 * Maybe OS fails in evaluating the _REG
1459 * object. The AE_NOT_FOUND error will be
1460 * ignored and OS * continue to initialize
1461 * EC.
1462 */
1463 pr_err("Fail in evaluating the _REG object"
1464 " of EC device. Broken bios is suspected.\n");
1465 } else {
1466 acpi_ec_stop(ec, false);
1467 return -ENODEV;
1468 }
1469 }
1470 set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1471 }
1472
Lv Zheng2a570842016-09-07 16:50:21 +08001473 if (!handle_events)
1474 return 0;
1475
1476 if (!test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
1477 /* Find and register all query methods */
1478 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1479 acpi_ec_register_query_methods,
1480 NULL, ec, NULL);
1481 set_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1482 }
Lv Zheng0e1affe2016-03-24 10:42:47 +08001483 if (!test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1484 status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1485 ACPI_GPE_EDGE_TRIGGERED,
1486 &acpi_ec_gpe_handler, ec);
1487 /* This is not fatal as we can poll EC events */
1488 if (ACPI_SUCCESS(status)) {
1489 set_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
Lv Zhengc3a696b2017-01-20 16:42:48 +08001490 acpi_ec_leave_noirq(ec);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001491 if (test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1492 ec->reference_count >= 1)
1493 acpi_ec_enable_gpe(ec, true);
Zhao Yakui20edd742008-10-17 02:02:44 -04001494 }
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001495 }
Lv Zheng53c5eaa2017-09-26 16:54:03 +08001496 /* EC is fully operational, allow queries */
1497 acpi_ec_enable_event(ec);
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001498
1499 return 0;
1500}
1501
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502static void ec_remove_handlers(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503{
Lv Zheng0e1affe2016-03-24 10:42:47 +08001504 if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1505 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1506 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1507 pr_err("failed to remove space handler\n");
1508 clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1509 }
1510
Lv Zhengfa5b4a52016-07-08 09:25:05 +08001511 /*
1512 * Stops handling the EC transactions after removing the operation
1513 * region handler. This is required because _REG(DISCONNECT)
1514 * invoked during the removal can result in new EC transactions.
1515 *
1516 * Flushes the EC requests and thus disables the GPE before
1517 * removing the GPE handler. This is required by the current ACPICA
1518 * GPE core. ACPICA GPE core will automatically disable a GPE when
1519 * it is indicated but there is no way to handle it. So the drivers
1520 * must disable the GPEs prior to removing the GPE handlers.
1521 */
1522 acpi_ec_stop(ec, false);
1523
Lv Zheng0e1affe2016-03-24 10:42:47 +08001524 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1525 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1526 &acpi_ec_gpe_handler)))
1527 pr_err("failed to remove gpe handler\n");
1528 clear_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
1529 }
Lv Zheng2a570842016-09-07 16:50:21 +08001530 if (test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
1531 acpi_ec_remove_query_handlers(ec, true, 0);
1532 clear_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1533 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535
Lv Zheng2a570842016-09-07 16:50:21 +08001536static int acpi_ec_setup(struct acpi_ec *ec, bool handle_events)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537{
Lv Zheng72c77b72016-09-07 16:50:08 +08001538 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539
Lv Zheng2a570842016-09-07 16:50:21 +08001540 ret = ec_install_handlers(ec, handle_events);
Lv Zheng72c77b72016-09-07 16:50:08 +08001541 if (ret)
1542 return ret;
1543
1544 /* First EC capable of handling transactions */
1545 if (!first_ec) {
1546 first_ec = ec;
1547 acpi_handle_info(first_ec->handle, "Used as first EC\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 }
Lv Zheng72c77b72016-09-07 16:50:08 +08001549
1550 acpi_handle_info(ec->handle,
Geert Uytterhoeven3522f862018-01-02 16:26:31 +01001551 "GPE=0x%x, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n",
Lv Zheng72c77b72016-09-07 16:50:08 +08001552 ec->gpe, ec->command_addr, ec->data_addr);
1553 return ret;
1554}
1555
Lv Zheng97cb1592016-09-07 16:50:27 +08001556static bool acpi_ec_ecdt_get_handle(acpi_handle *phandle)
1557{
1558 struct acpi_table_ecdt *ecdt_ptr;
1559 acpi_status status;
1560 acpi_handle handle;
1561
1562 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1563 (struct acpi_table_header **)&ecdt_ptr);
1564 if (ACPI_FAILURE(status))
1565 return false;
1566
1567 status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1568 if (ACPI_FAILURE(status))
1569 return false;
1570
1571 *phandle = handle;
1572 return true;
1573}
1574
Lv Zhengfd6231e2016-06-21 17:42:05 +08001575static int acpi_ec_add(struct acpi_device *device)
1576{
1577 struct acpi_ec *ec = NULL;
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001578 bool dep_update = true;
Lv Zhenga64a62c2017-09-26 16:54:09 +08001579 acpi_status status;
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001580 int ret;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001581
1582 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1583 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1584
Lv Zhenga64a62c2017-09-26 16:54:09 +08001585 if (!strcmp(acpi_device_hid(device), ACPI_ECDT_HID)) {
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001586 boot_ec_is_ecdt = true;
Lv Zhenga64a62c2017-09-26 16:54:09 +08001587 ec = boot_ec;
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001588 dep_update = false;
Lv Zhenga64a62c2017-09-26 16:54:09 +08001589 } else {
1590 ec = acpi_ec_alloc();
1591 if (!ec)
1592 return -ENOMEM;
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001593
Lv Zhenga64a62c2017-09-26 16:54:09 +08001594 status = ec_parse_device(device->handle, 0, ec, NULL);
1595 if (status != AE_CTRL_TERMINATE) {
Lv Zheng46922d22016-09-07 16:50:14 +08001596 ret = -EINVAL;
1597 goto err_alloc;
Lv Zhenga64a62c2017-09-26 16:54:09 +08001598 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001600 if (boot_ec && ec->command_addr == boot_ec->command_addr &&
1601 ec->data_addr == boot_ec->data_addr) {
1602 boot_ec_is_ecdt = false;
Lv Zhenga64a62c2017-09-26 16:54:09 +08001603 /*
1604 * Trust PNP0C09 namespace location rather than
1605 * ECDT ID. But trust ECDT GPE rather than _GPE
1606 * because of ASUS quirks, so do not change
1607 * boot_ec->gpe to ec->gpe.
1608 */
1609 boot_ec->handle = ec->handle;
1610 acpi_handle_debug(ec->handle, "duplicated.\n");
1611 acpi_ec_free(ec);
1612 ec = boot_ec;
1613 }
Rafael J. Wysockid2c62ae2019-02-01 12:55:31 +01001614 }
1615
1616 ret = acpi_ec_setup(ec, true);
Lv Zheng46922d22016-09-07 16:50:14 +08001617 if (ret)
1618 goto err_query;
1619
Rafael J. Wysockid2c62ae2019-02-01 12:55:31 +01001620 if (ec == boot_ec)
1621 acpi_handle_info(boot_ec->handle,
1622 "Boot %s EC used to handle transactions and events\n",
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001623 boot_ec_is_ecdt ? "ECDT" : "DSDT");
Rafael J. Wysockid2c62ae2019-02-01 12:55:31 +01001624
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 device->driver_data = ec;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001626
Andi Kleend6795fe32012-02-06 08:17:08 -08001627 ret = !!request_region(ec->data_addr, 1, "EC data");
1628 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1629 ret = !!request_region(ec->command_addr, 1, "EC cmd");
1630 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001631
Rafael J. Wysocki116f2b32019-02-01 12:56:03 +01001632 if (dep_update) {
Lv Zhenga64a62c2017-09-26 16:54:09 +08001633 /* Reprobe devices depending on the EC */
1634 acpi_walk_dep_device_list(ec->handle);
1635 }
Lv Zheng97cb1592016-09-07 16:50:27 +08001636 acpi_handle_debug(ec->handle, "enumerated.\n");
Lv Zheng46922d22016-09-07 16:50:14 +08001637 return 0;
1638
1639err_query:
Lv Zheng97cb1592016-09-07 16:50:27 +08001640 if (ec != boot_ec)
1641 acpi_ec_remove_query_handlers(ec, true, 0);
Lv Zheng46922d22016-09-07 16:50:14 +08001642err_alloc:
Lv Zheng97cb1592016-09-07 16:50:27 +08001643 if (ec != boot_ec)
1644 acpi_ec_free(ec);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001645 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646}
1647
Rafael J. Wysocki51fac832013-01-24 00:24:48 +01001648static int acpi_ec_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001650 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001653 return -EINVAL;
Alexey Starikovskiyf9319f92007-08-24 08:10:11 +04001654
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 ec = acpi_driver_data(device);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001656 release_region(ec->data_addr, 1);
1657 release_region(ec->command_addr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 device->driver_data = NULL;
Lv Zheng97cb1592016-09-07 16:50:27 +08001659 if (ec != boot_ec) {
1660 ec_remove_handlers(ec);
1661 acpi_ec_free(ec);
1662 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001663 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664}
1665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666static acpi_status
1667ec_parse_io_ports(struct acpi_resource *resource, void *context)
1668{
1669 struct acpi_ec *ec = context;
1670
1671 if (resource->type != ACPI_RESOURCE_TYPE_IO)
1672 return AE_OK;
1673
1674 /*
1675 * The first address region returned is the data port, and
1676 * the second address region returned is the status/command
1677 * port.
1678 */
Thomas Renningerde4f1042010-07-29 22:08:44 +02001679 if (ec->data_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 ec->data_addr = resource->data.io.minimum;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001681 else if (ec->command_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 ec->command_addr = resource->data.io.minimum;
1683 else
1684 return AE_CTRL_TERMINATE;
1685
1686 return AE_OK;
1687}
1688
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001689static const struct acpi_device_id ec_device_ids[] = {
1690 {"PNP0C09", 0},
Lv Zhenga64a62c2017-09-26 16:54:09 +08001691 {ACPI_ECDT_HID, 0},
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001692 {"", 0},
1693};
1694
Lv Zhengc712bb52017-06-15 09:41:41 +08001695/*
1696 * This function is not Windows-compatible as Windows never enumerates the
1697 * namespace EC before the main ACPI device enumeration process. It is
1698 * retained for historical reason and will be deprecated in the future.
1699 */
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001700void __init acpi_ec_dsdt_probe(void)
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001701{
Lv Zhengfd6231e2016-06-21 17:42:05 +08001702 struct acpi_ec *ec;
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001703 acpi_status status;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001704 int ret;
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001705
Lv Zhengc712bb52017-06-15 09:41:41 +08001706 /*
1707 * If a platform has ECDT, there is no need to proceed as the
1708 * following probe is not a part of the ACPI device enumeration,
1709 * executing _STA is not safe, and thus this probe may risk of
1710 * picking up an invalid EC device.
1711 */
1712 if (boot_ec)
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001713 return;
Lv Zhengc712bb52017-06-15 09:41:41 +08001714
Lv Zhengfd6231e2016-06-21 17:42:05 +08001715 ec = acpi_ec_alloc();
1716 if (!ec)
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001717 return;
1718
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001719 /*
Lv Zheng2a570842016-09-07 16:50:21 +08001720 * At this point, the namespace is initialized, so start to find
1721 * the namespace objects.
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001722 */
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001723 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
Lv Zhengfd6231e2016-06-21 17:42:05 +08001724 if (ACPI_FAILURE(status) || !ec->handle) {
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001725 acpi_ec_free(ec);
1726 return;
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001727 }
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001728
Lv Zheng2a570842016-09-07 16:50:21 +08001729 /*
1730 * When the DSDT EC is available, always re-configure boot EC to
1731 * have _REG evaluated. _REG can only be evaluated after the
1732 * namespace initialization.
1733 * At this point, the GPE is not fully initialized, so do not to
1734 * handle the events.
1735 */
Rafael J. Wysockic746b6b2019-02-01 10:59:42 +01001736 ret = acpi_ec_setup(ec, false);
1737 if (ret) {
Lv Zheng72c77b72016-09-07 16:50:08 +08001738 acpi_ec_free(ec);
Rafael J. Wysockic746b6b2019-02-01 10:59:42 +01001739 return;
1740 }
1741
1742 boot_ec = ec;
1743
1744 acpi_handle_info(ec->handle,
1745 "Boot DSDT EC used to handle transactions\n");
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001746}
1747
Lv Zheng2a570842016-09-07 16:50:21 +08001748/*
1749 * If the DSDT EC is not functioning, we still need to prepare a fully
1750 * functioning ECDT EC first in order to handle the events.
1751 * https://bugzilla.kernel.org/show_bug.cgi?id=115021
1752 */
Lv Zheng98529b92017-08-16 15:29:49 +08001753static int __init acpi_ec_ecdt_start(void)
Lv Zheng2a570842016-09-07 16:50:21 +08001754{
Lv Zheng2a570842016-09-07 16:50:21 +08001755 acpi_handle handle;
1756
1757 if (!boot_ec)
1758 return -ENODEV;
Lv Zheng69b957c2017-08-17 10:21:12 +08001759 /* In case acpi_ec_ecdt_start() is called after acpi_ec_add() */
Lv Zheng2a570842016-09-07 16:50:21 +08001760 if (!boot_ec_is_ecdt)
1761 return -ENODEV;
1762
Lv Zheng2a570842016-09-07 16:50:21 +08001763 /*
1764 * At this point, the namespace and the GPE is initialized, so
1765 * start to find the namespace objects and handle the events.
Lv Zheng69b957c2017-08-17 10:21:12 +08001766 *
1767 * Note: ec->handle can be valid if this function is called after
1768 * acpi_ec_add(), hence the fast path.
Lv Zheng2a570842016-09-07 16:50:21 +08001769 */
Lv Zhenga64a62c2017-09-26 16:54:09 +08001770 if (boot_ec->handle == ACPI_ROOT_OBJECT) {
1771 if (!acpi_ec_ecdt_get_handle(&handle))
1772 return -ENODEV;
1773 boot_ec->handle = handle;
1774 }
1775
1776 /* Register to ACPI bus with PM ops attached */
1777 return acpi_bus_register_early_device(ACPI_BUS_TYPE_ECDT_EC);
Lv Zheng2a570842016-09-07 16:50:21 +08001778}
1779
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001780#if 0
Feng Tang67bfa9b2012-09-28 15:22:01 +08001781/*
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001782 * Some EC firmware variations refuses to respond QR_EC when SCI_EVT is not
1783 * set, for which case, we complete the QR_EC without issuing it to the
1784 * firmware.
1785 * https://bugzilla.kernel.org/show_bug.cgi?id=82611
1786 * https://bugzilla.kernel.org/show_bug.cgi?id=97381
Lv Zheng79149002014-10-29 11:33:49 +08001787 */
1788static int ec_flag_query_handshake(const struct dmi_system_id *id)
1789{
1790 pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1791 EC_FLAGS_QUERY_HANDSHAKE = 1;
1792 return 0;
1793}
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001794#endif
Lv Zheng79149002014-10-29 11:33:49 +08001795
1796/*
Zhang Ruib6a3e142019-02-01 14:13:41 +08001797 * On some hardware it is necessary to clear events accumulated by the EC during
1798 * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1799 * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1800 *
1801 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1802 *
1803 * Ideally, the EC should also be instructed NOT to accumulate events during
1804 * sleep (which Windows seems to do somehow), but the interface to control this
1805 * behaviour is not known at this time.
1806 *
1807 * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1808 * however it is very likely that other Samsung models are affected.
1809 *
1810 * On systems which don't accumulate _Q events during sleep, this extra check
1811 * should be harmless.
1812 */
1813static int ec_clear_on_resume(const struct dmi_system_id *id)
1814{
1815 pr_debug("Detected system needing EC poll on resume.\n");
1816 EC_FLAGS_CLEAR_ON_RESUME = 1;
1817 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1818 return 0;
1819}
1820
1821/*
Lv Zhengbc539562016-06-21 17:42:12 +08001822 * Some ECDTs contain wrong register addresses.
1823 * MSI MS-171F
1824 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1825 */
Lv Zheng59f0aa92016-03-24 10:42:53 +08001826static int ec_correct_ecdt(const struct dmi_system_id *id)
1827{
1828 pr_debug("Detected system needing ECDT address correction.\n");
1829 EC_FLAGS_CORRECT_ECDT = 1;
1830 return 0;
1831}
1832
Chris Chiu440f53d2017-06-15 09:41:47 +08001833/*
1834 * Some DSDTs contain wrong GPE setting.
Carlo Caioneef750402017-06-15 09:41:53 +08001835 * Asus FX502VD/VE, GL702VMK, X550VXK, X580VD
Chris Chiu440f53d2017-06-15 09:41:47 +08001836 * https://bugzilla.kernel.org/show_bug.cgi?id=195651
1837 */
1838static int ec_honor_ecdt_gpe(const struct dmi_system_id *id)
1839{
1840 pr_debug("Detected system needing ignore DSDT GPE setting.\n");
1841 EC_FLAGS_IGNORE_DSDT_GPE = 1;
1842 return 0;
1843}
1844
Christoph Hellwig6faadbb2017-09-14 11:59:30 +02001845static const struct dmi_system_id ec_dmi_table[] __initconst = {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001846 {
Lv Zheng59f0aa92016-03-24 10:42:53 +08001847 ec_correct_ecdt, "MSI MS-171F", {
Lv Zheng3174abc2015-05-15 14:37:11 +08001848 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1849 DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
Chris Chiu440f53d2017-06-15 09:41:47 +08001850 {
1851 ec_honor_ecdt_gpe, "ASUS FX502VD", {
1852 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1853 DMI_MATCH(DMI_PRODUCT_NAME, "FX502VD"),}, NULL},
1854 {
1855 ec_honor_ecdt_gpe, "ASUS FX502VE", {
1856 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1857 DMI_MATCH(DMI_PRODUCT_NAME, "FX502VE"),}, NULL},
1858 {
Carlo Caioneef750402017-06-15 09:41:53 +08001859 ec_honor_ecdt_gpe, "ASUS GL702VMK", {
1860 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1861 DMI_MATCH(DMI_PRODUCT_NAME, "GL702VMK"),}, NULL},
1862 {
Chris Chiu440f53d2017-06-15 09:41:47 +08001863 ec_honor_ecdt_gpe, "ASUS X550VXK", {
1864 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1865 DMI_MATCH(DMI_PRODUCT_NAME, "X550VXK"),}, NULL},
1866 {
1867 ec_honor_ecdt_gpe, "ASUS X580VD", {
1868 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1869 DMI_MATCH(DMI_PRODUCT_NAME, "X580VD"),}, NULL},
Zhang Ruib6a3e142019-02-01 14:13:41 +08001870 {
1871 ec_clear_on_resume, "Samsung hardware", {
1872 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001873 {},
1874};
1875
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001876void __init acpi_ec_ecdt_probe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001878 struct acpi_table_ecdt *ecdt_ptr;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001879 struct acpi_ec *ec;
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001880 acpi_status status;
1881 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001883 /* Generate a boot ec context. */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001884 dmi_check_system(ec_dmi_table);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001885 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1886 (struct acpi_table_header **)&ecdt_ptr);
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001887 if (ACPI_FAILURE(status))
1888 return;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001889
1890 if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1891 /*
1892 * Asus X50GL:
1893 * https://bugzilla.kernel.org/show_bug.cgi?id=11880
1894 */
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001895 return;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001896 }
1897
Rafael J. Wysockifdb3c1772019-01-21 13:07:50 +01001898 ec = acpi_ec_alloc();
1899 if (!ec)
1900 return;
1901
Lv Zheng59f0aa92016-03-24 10:42:53 +08001902 if (EC_FLAGS_CORRECT_ECDT) {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001903 ec->command_addr = ecdt_ptr->data.address;
1904 ec->data_addr = ecdt_ptr->control.address;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001905 } else {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001906 ec->command_addr = ecdt_ptr->control.address;
1907 ec->data_addr = ecdt_ptr->data.address;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001908 }
Lv Zhengfd6231e2016-06-21 17:42:05 +08001909 ec->gpe = ecdt_ptr->gpe;
Rafael J. Wysocki15684262019-02-01 10:58:20 +01001910 ec->handle = ACPI_ROOT_OBJECT;
Lv Zheng2a570842016-09-07 16:50:21 +08001911
1912 /*
1913 * At this point, the namespace is not initialized, so do not find
1914 * the namespace objects, or handle the events.
1915 */
Rafael J. Wysocki15684262019-02-01 10:58:20 +01001916 ret = acpi_ec_setup(ec, false);
1917 if (ret) {
Lv Zheng72c77b72016-09-07 16:50:08 +08001918 acpi_ec_free(ec);
Rafael J. Wysocki15684262019-02-01 10:58:20 +01001919 return;
1920 }
1921
1922 boot_ec = ec;
1923 boot_ec_is_ecdt = true;
1924
1925 pr_info("Boot ECDT EC used to handle transactions\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926}
1927
Lv Zhengdf45db62016-08-03 09:07:58 +08001928#ifdef CONFIG_PM_SLEEP
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001929static int acpi_ec_suspend(struct device *dev)
1930{
1931 struct acpi_ec *ec =
1932 acpi_driver_data(to_acpi_device(dev));
1933
Rafael J. Wysocki8110dd282017-06-23 15:24:32 +02001934 if (acpi_sleep_no_ec_events() && ec_freeze_events)
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001935 acpi_ec_disable_event(ec);
1936 return 0;
1937}
1938
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001939static int acpi_ec_suspend_noirq(struct device *dev)
1940{
1941 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1942
1943 /*
1944 * The SCI handler doesn't run at this point, so the GPE can be
1945 * masked at the low level without side effects.
1946 */
1947 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1948 ec->reference_count >= 1)
1949 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1950
Rafael J. Wysocki3cd091a2018-02-09 22:55:28 +01001951 if (acpi_sleep_no_ec_events())
1952 acpi_ec_enter_noirq(ec);
1953
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001954 return 0;
1955}
1956
1957static int acpi_ec_resume_noirq(struct device *dev)
1958{
1959 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1960
Rafael J. Wysocki3cd091a2018-02-09 22:55:28 +01001961 if (acpi_sleep_no_ec_events())
1962 acpi_ec_leave_noirq(ec);
1963
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001964 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1965 ec->reference_count >= 1)
1966 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
1967
1968 return 0;
1969}
1970
Lv Zhengc2b46d62016-08-03 16:01:36 +08001971static int acpi_ec_resume(struct device *dev)
1972{
1973 struct acpi_ec *ec =
1974 acpi_driver_data(to_acpi_device(dev));
1975
1976 acpi_ec_enable_event(ec);
1977 return 0;
1978}
Lv Zhengdf45db62016-08-03 09:07:58 +08001979#endif
1980
1981static const struct dev_pm_ops acpi_ec_pm = {
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001982 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001983 SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
Lv Zhengdf45db62016-08-03 09:07:58 +08001984};
1985
Kees Cooke4dca7b2017-10-17 19:04:42 -07001986static int param_set_event_clearing(const char *val,
1987 const struct kernel_param *kp)
Lv Zheng1d68d262015-06-11 13:21:38 +08001988{
1989 int result = 0;
1990
1991 if (!strncmp(val, "status", sizeof("status") - 1)) {
1992 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1993 pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
1994 } else if (!strncmp(val, "query", sizeof("query") - 1)) {
1995 ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
1996 pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
1997 } else if (!strncmp(val, "event", sizeof("event") - 1)) {
1998 ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
1999 pr_info("Assuming SCI_EVT clearing on event reads\n");
2000 } else
2001 result = -EINVAL;
2002 return result;
2003}
2004
Kees Cooke4dca7b2017-10-17 19:04:42 -07002005static int param_get_event_clearing(char *buffer,
2006 const struct kernel_param *kp)
Lv Zheng1d68d262015-06-11 13:21:38 +08002007{
2008 switch (ec_event_clearing) {
2009 case ACPI_EC_EVT_TIMING_STATUS:
2010 return sprintf(buffer, "status");
2011 case ACPI_EC_EVT_TIMING_QUERY:
2012 return sprintf(buffer, "query");
2013 case ACPI_EC_EVT_TIMING_EVENT:
2014 return sprintf(buffer, "event");
2015 default:
2016 return sprintf(buffer, "invalid");
2017 }
2018 return 0;
2019}
2020
2021module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
2022 NULL, 0644);
2023MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
2024
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03002025static struct acpi_driver acpi_ec_driver = {
2026 .name = "ec",
2027 .class = ACPI_EC_CLASS,
2028 .ids = ec_device_ids,
2029 .ops = {
2030 .add = acpi_ec_add,
2031 .remove = acpi_ec_remove,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03002032 },
Lv Zhengdf45db62016-08-03 09:07:58 +08002033 .drv.pm = &acpi_ec_pm,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03002034};
2035
Lv Zhenge1191bd2016-08-03 09:00:14 +08002036static inline int acpi_ec_query_init(void)
2037{
2038 if (!ec_query_wq) {
2039 ec_query_wq = alloc_workqueue("kec_query", 0,
2040 ec_max_queries);
2041 if (!ec_query_wq)
2042 return -ENODEV;
2043 }
2044 return 0;
2045}
2046
2047static inline void acpi_ec_query_exit(void)
2048{
2049 if (ec_query_wq) {
2050 destroy_workqueue(ec_query_wq);
2051 ec_query_wq = NULL;
2052 }
2053}
2054
Mika Westerberg8195a652018-06-18 14:17:16 +03002055static const struct dmi_system_id acpi_ec_no_wakeup[] = {
2056 {
2057 .ident = "Thinkpad X1 Carbon 6th",
2058 .matches = {
2059 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
Robin H. Johnson2c4d6ba2018-07-13 20:50:47 +00002060 DMI_MATCH(DMI_PRODUCT_FAMILY, "Thinkpad X1 Carbon 6th"),
Mika Westerberg8195a652018-06-18 14:17:16 +03002061 },
2062 },
Aaron Mab047c622018-07-31 18:52:39 +08002063 {
Mika Westerberg4c3be61e2018-08-08 12:50:37 +03002064 .ident = "ThinkPad X1 Carbon 6th",
2065 .matches = {
2066 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2067 DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Carbon 6th"),
2068 },
2069 },
2070 {
Aaron Mab047c622018-07-31 18:52:39 +08002071 .ident = "ThinkPad X1 Yoga 3rd",
2072 .matches = {
2073 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2074 DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Yoga 3rd"),
2075 },
2076 },
Mika Westerberg8195a652018-06-18 14:17:16 +03002077 { },
2078};
2079
Bjorn Helgaasa5f820f2009-03-24 16:49:48 -06002080int __init acpi_ec_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081{
Lv Zhenge1191bd2016-08-03 09:00:14 +08002082 int result;
Lv Zheng98529b92017-08-16 15:29:49 +08002083 int ecdt_fail, dsdt_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084
Lv Zhenge1191bd2016-08-03 09:00:14 +08002085 /* register workqueue for _Qxx evaluations */
2086 result = acpi_ec_query_init();
2087 if (result)
Lv Zheng98529b92017-08-16 15:29:49 +08002088 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089
Mika Westerberg8195a652018-06-18 14:17:16 +03002090 /*
2091 * Disable EC wakeup on following systems to prevent periodic
2092 * wakeup from EC GPE.
2093 */
2094 if (dmi_check_system(acpi_ec_no_wakeup)) {
2095 ec_no_wakeup = true;
2096 pr_debug("Disabling EC wakeup on suspend-to-idle\n");
2097 }
2098
Lv Zheng98529b92017-08-16 15:29:49 +08002099 /* Drivers must be started after acpi_ec_query_init() */
Lv Zheng98529b92017-08-16 15:29:49 +08002100 dsdt_fail = acpi_bus_register_driver(&acpi_ec_driver);
Lv Zhenga64a62c2017-09-26 16:54:09 +08002101 /*
2102 * Register ECDT to ACPI bus only when PNP0C09 probe fails. This is
2103 * useful for platforms (confirmed on ASUS X550ZE) with valid ECDT
2104 * settings but invalid DSDT settings.
2105 * https://bugzilla.kernel.org/show_bug.cgi?id=196847
2106 */
Lv Zheng69b957c2017-08-17 10:21:12 +08002107 ecdt_fail = acpi_ec_ecdt_start();
Lv Zheng98529b92017-08-16 15:29:49 +08002108 return ecdt_fail && dsdt_fail ? -ENODEV : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109}
2110
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111/* EC driver currently not unloadable */
2112#if 0
Len Brown50526df2005-08-11 17:32:05 -04002113static void __exit acpi_ec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115
2116 acpi_bus_unregister_driver(&acpi_ec_driver);
Lv Zhenge1191bd2016-08-03 09:00:14 +08002117 acpi_ec_query_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118}
Alexey Starikovskiy78439322007-10-22 14:18:43 +04002119#endif /* 0 */