blob: 7ea7aa9701e394c89909e87473a40ecacda4dd9c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Lv Zhenga8d4fc22015-02-05 16:27:35 +08002 * ec.c - ACPI Embedded Controller Driver (v3)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Lv Zhenga8d4fc22015-02-05 16:27:35 +08004 * Copyright (C) 2001-2015 Intel Corporation
5 * Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
Lv Zheng4a3f6b52014-06-15 08:42:19 +08006 * 2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
7 * 2006 Denis Sadykov <denis.m.sadykov@intel.com>
8 * 2004 Luming Yu <luming.yu@intel.com>
9 * 2001, 2002 Andy Grover <andrew.grover@intel.com>
10 * 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
11 * Copyright (C) 2008 Alexey Starikovskiy <astarikovskiy@suse.de>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 *
13 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or (at
18 * your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * General Public License for more details.
24 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 */
27
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040028/* Uncomment next line to get verbose printout */
Márton Némethd772b3b2008-01-23 22:34:09 -050029/* #define DEBUG */
Vincent Legollb6aeab42017-05-20 20:38:13 +020030#define pr_fmt(fmt) "ACPI: EC: " fmt
Márton Némethd772b3b2008-01-23 22:34:09 -050031
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/kernel.h>
33#include <linux/module.h>
34#include <linux/init.h>
35#include <linux/types.h>
36#include <linux/delay.h>
Dmitry Torokhov451566f2005-03-19 01:10:05 -050037#include <linux/interrupt.h>
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040038#include <linux/list.h>
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040039#include <linux/spinlock.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090040#include <linux/slab.h>
Lv Zheng8b484632013-12-03 08:49:16 +080041#include <linux/acpi.h>
Len Browneb27cae2009-07-06 23:40:19 -040042#include <linux/dmi.h>
Lv Zheng8b484632013-12-03 08:49:16 +080043#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Thomas Renninger1195a092010-07-16 13:11:31 +020045#include "internal.h"
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#define ACPI_EC_CLASS "embedded_controller"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#define ACPI_EC_DEVICE_NAME "Embedded Controller"
49#define ACPI_EC_FILE_INFO "info"
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040050
Denis M. Sadykov703959d2006-09-26 19:50:33 +040051/* EC status register */
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
53#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
Lv Zhengdd43de22014-06-15 08:42:42 +080054#define ACPI_EC_FLAG_CMD 0x08 /* Input buffer contains a command */
Dmitry Torokhov451566f2005-03-19 01:10:05 -050055#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
Alexey Starikovskiy43509332007-05-29 16:42:57 +040057
Lv Zheng1d68d262015-06-11 13:21:38 +080058/*
59 * The SCI_EVT clearing timing is not defined by the ACPI specification.
60 * This leads to lots of practical timing issues for the host EC driver.
61 * The following variations are defined (from the target EC firmware's
62 * perspective):
63 * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
64 * target can clear SCI_EVT at any time so long as the host can see
65 * the indication by reading the status register (EC_SC). So the
66 * host should re-check SCI_EVT after the first time the SCI_EVT
67 * indication is seen, which is the same time the query request
68 * (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
69 * at any later time could indicate another event. Normally such
70 * kind of EC firmware has implemented an event queue and will
71 * return 0x00 to indicate "no outstanding event".
72 * QUERY: After seeing the query request (QR_EC) written to the command
73 * register (EC_CMD) by the host and having prepared the responding
74 * event value in the data register (EC_DATA), the target can safely
75 * clear SCI_EVT because the target can confirm that the current
76 * event is being handled by the host. The host then should check
77 * SCI_EVT right after reading the event response from the data
78 * register (EC_DATA).
79 * EVENT: After seeing the event response read from the data register
80 * (EC_DATA) by the host, the target can clear SCI_EVT. As the
81 * target requires time to notice the change in the data register
82 * (EC_DATA), the host may be required to wait additional guarding
83 * time before checking the SCI_EVT again. Such guarding may not be
84 * necessary if the host is notified via another IRQ.
85 */
86#define ACPI_EC_EVT_TIMING_STATUS 0x00
87#define ACPI_EC_EVT_TIMING_QUERY 0x01
88#define ACPI_EC_EVT_TIMING_EVENT 0x02
89
Denis M. Sadykov703959d2006-09-26 19:50:33 +040090/* EC commands */
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030091enum ec_command {
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +030092 ACPI_EC_COMMAND_READ = 0x80,
93 ACPI_EC_COMMAND_WRITE = 0x81,
94 ACPI_EC_BURST_ENABLE = 0x82,
95 ACPI_EC_BURST_DISABLE = 0x83,
96 ACPI_EC_COMMAND_QUERY = 0x84,
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030097};
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040098
Alexey Starikovskiy5c406412006-12-07 18:42:16 +030099#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400100#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
Lv Zhengd8d031a2015-05-15 14:16:42 +0800101#define ACPI_EC_UDELAY_POLL 550 /* Wait 1ms for EC transaction polling */
Kieran Clancyad332c82014-03-01 00:42:28 +1030102#define ACPI_EC_CLEAR_MAX 100 /* Maximum number of events to query
103 * when trying to clear the EC */
Lv Zhenge1191bd2016-08-03 09:00:14 +0800104#define ACPI_EC_MAX_QUERIES 16 /* Maximum number of parallel queries */
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400105
Alexey Starikovskiy080e4122007-10-22 14:18:30 +0400106enum {
Lv Zheng750f6282016-08-03 16:01:24 +0800107 EC_FLAGS_QUERY_ENABLED, /* Query is enabled */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100108 EC_FLAGS_QUERY_PENDING, /* Query is pending */
Lv Zheng1d68d262015-06-11 13:21:38 +0800109 EC_FLAGS_QUERY_GUARDING, /* Guard for SCI_EVT check */
Lv Zheng0e1affe2016-03-24 10:42:47 +0800110 EC_FLAGS_GPE_HANDLER_INSTALLED, /* GPE handler installed */
111 EC_FLAGS_EC_HANDLER_INSTALLED, /* OpReg handler installed */
Lv Zheng2a570842016-09-07 16:50:21 +0800112 EC_FLAGS_EVT_HANDLER_INSTALLED, /* _Qxx handlers installed */
Lv Zhengad479e72015-02-06 08:57:52 +0800113 EC_FLAGS_STARTED, /* Driver is started */
114 EC_FLAGS_STOPPED, /* Driver is stopped */
Lv Zhenge1d4d902015-02-06 08:58:05 +0800115 EC_FLAGS_COMMAND_STORM, /* GPE storms occurred to the
116 * current command processing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117};
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400118
Lv Zhengf92fca02014-06-15 08:41:35 +0800119#define ACPI_EC_COMMAND_POLL 0x01 /* Available for command byte */
120#define ACPI_EC_COMMAND_COMPLETE 0x02 /* Completed last byte */
121
Thomas Renninger7a18e962010-10-21 18:24:57 +0200122/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
123static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
124module_param(ec_delay, uint, 0644);
125MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
126
Lv Zhenge1191bd2016-08-03 09:00:14 +0800127static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
128module_param(ec_max_queries, uint, 0644);
129MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
130
Lv Zheng15de6032015-05-15 14:16:48 +0800131static bool ec_busy_polling __read_mostly;
132module_param(ec_busy_polling, bool, 0644);
133MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
134
135static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
136module_param(ec_polling_guard, uint, 0644);
137MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
138
Lv Zheng3cb02ae2015-06-11 13:21:45 +0800139static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
Lv Zheng1d68d262015-06-11 13:21:38 +0800140
Feng Tanga520d522012-09-28 15:22:00 +0800141/*
142 * If the number of false interrupts per one transaction exceeds
143 * this threshold, will think there is a GPE storm happened and
144 * will disable the GPE for normal transaction.
145 */
146static unsigned int ec_storm_threshold __read_mostly = 8;
147module_param(ec_storm_threshold, uint, 0644);
148MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
149
Lv Zheng9c40f952017-07-12 11:09:17 +0800150static bool ec_freeze_events __read_mostly = false;
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800151module_param(ec_freeze_events, bool, 0644);
152MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
153
Rafael J. Wysocki76380632017-07-19 14:41:58 +0200154static bool ec_no_wakeup __read_mostly;
155module_param(ec_no_wakeup, bool, 0644);
156MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
157
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400158struct acpi_ec_query_handler {
159 struct list_head node;
160 acpi_ec_query_func func;
161 acpi_handle handle;
162 void *data;
163 u8 query_bit;
Lv Zheng01305d42015-01-14 19:28:28 +0800164 struct kref kref;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400165};
166
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400167struct transaction {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400168 const u8 *wdata;
169 u8 *rdata;
170 unsigned short irq_count;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400171 u8 command;
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300172 u8 wi;
173 u8 ri;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400174 u8 wlen;
175 u8 rlen;
Lv Zhengf92fca02014-06-15 08:41:35 +0800176 u8 flags;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400177};
178
Lv Zheng02b771b2015-08-12 11:12:02 +0800179struct acpi_ec_query {
180 struct transaction transaction;
181 struct work_struct work;
182 struct acpi_ec_query_handler *handler;
183};
184
Lv Zheng550b3aac2015-01-14 19:28:53 +0800185static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800186static void advance_transaction(struct acpi_ec *ec);
Lv Zheng02b771b2015-08-12 11:12:02 +0800187static void acpi_ec_event_handler(struct work_struct *work);
188static void acpi_ec_event_processor(struct work_struct *work);
Lv Zheng74443bb2015-01-14 19:28:47 +0800189
Thomas Renninger1195a092010-07-16 13:11:31 +0200190struct acpi_ec *boot_ec, *first_ec;
191EXPORT_SYMBOL(first_ec);
Lv Zheng72c77b72016-09-07 16:50:08 +0800192static bool boot_ec_is_ecdt = false;
Lv Zhenge1191bd2016-08-03 09:00:14 +0800193static struct workqueue_struct *ec_query_wq;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400194
Lv Zheng79149002014-10-29 11:33:49 +0800195static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
Lv Zheng59f0aa92016-03-24 10:42:53 +0800196static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
Chris Chiu440f53d2017-06-15 09:41:47 +0800197static int EC_FLAGS_IGNORE_DSDT_GPE; /* Needs ECDT GPE as correction setting */
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199/* --------------------------------------------------------------------------
Lv Zheng3535a3c2015-02-27 14:48:15 +0800200 * Logging/Debugging
201 * -------------------------------------------------------------------------- */
202
203/*
204 * Splitters used by the developers to track the boundary of the EC
205 * handling processes.
206 */
207#ifdef DEBUG
208#define EC_DBG_SEP " "
209#define EC_DBG_DRV "+++++"
210#define EC_DBG_STM "====="
211#define EC_DBG_REQ "*****"
212#define EC_DBG_EVT "#####"
213#else
214#define EC_DBG_SEP ""
215#define EC_DBG_DRV
216#define EC_DBG_STM
217#define EC_DBG_REQ
218#define EC_DBG_EVT
219#endif
220
221#define ec_log_raw(fmt, ...) \
222 pr_info(fmt "\n", ##__VA_ARGS__)
223#define ec_dbg_raw(fmt, ...) \
224 pr_debug(fmt "\n", ##__VA_ARGS__)
225#define ec_log(filter, fmt, ...) \
226 ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
227#define ec_dbg(filter, fmt, ...) \
228 ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
229
230#define ec_log_drv(fmt, ...) \
231 ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
232#define ec_dbg_drv(fmt, ...) \
233 ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
234#define ec_dbg_stm(fmt, ...) \
235 ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
236#define ec_dbg_req(fmt, ...) \
237 ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
238#define ec_dbg_evt(fmt, ...) \
239 ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
Lv Zheng770970f2015-02-27 14:48:24 +0800240#define ec_dbg_ref(ec, fmt, ...) \
241 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
Lv Zheng3535a3c2015-02-27 14:48:15 +0800242
243/* --------------------------------------------------------------------------
Lv Zhengad479e72015-02-06 08:57:52 +0800244 * Device Flags
245 * -------------------------------------------------------------------------- */
246
247static bool acpi_ec_started(struct acpi_ec *ec)
248{
249 return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
250 !test_bit(EC_FLAGS_STOPPED, &ec->flags);
251}
252
Lv Zheng750f6282016-08-03 16:01:24 +0800253static bool acpi_ec_event_enabled(struct acpi_ec *ec)
254{
255 /*
256 * There is an OSPM early stage logic. During the early stages
257 * (boot/resume), OSPMs shouldn't enable the event handling, only
258 * the EC transactions are allowed to be performed.
259 */
260 if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
261 return false;
262 /*
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800263 * However, disabling the event handling is experimental for late
264 * stage (suspend), and is controlled by the boot parameter of
265 * "ec_freeze_events":
266 * 1. true: The EC event handling is disabled before entering
267 * the noirq stage.
268 * 2. false: The EC event handling is automatically disabled as
269 * soon as the EC driver is stopped.
Lv Zheng750f6282016-08-03 16:01:24 +0800270 */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800271 if (ec_freeze_events)
272 return acpi_ec_started(ec);
273 else
274 return test_bit(EC_FLAGS_STARTED, &ec->flags);
Lv Zheng750f6282016-08-03 16:01:24 +0800275}
276
Lv Zheng9887d222015-02-06 08:57:59 +0800277static bool acpi_ec_flushed(struct acpi_ec *ec)
278{
279 return ec->reference_count == 1;
280}
281
Lv Zhengad479e72015-02-06 08:57:52 +0800282/* --------------------------------------------------------------------------
Lv Zhengca37bfd2015-02-05 16:27:22 +0800283 * EC Registers
Lv Zheng7a73e602014-10-14 14:24:01 +0800284 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400286static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300288 u8 x = inb(ec->command_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800289
Lv Zheng3535a3c2015-02-27 14:48:15 +0800290 ec_dbg_raw("EC_SC(R) = 0x%2.2x "
291 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
292 x,
293 !!(x & ACPI_EC_FLAG_SCI),
294 !!(x & ACPI_EC_FLAG_BURST),
295 !!(x & ACPI_EC_FLAG_CMD),
296 !!(x & ACPI_EC_FLAG_IBF),
297 !!(x & ACPI_EC_FLAG_OBF));
Márton Németh3ebe08a2007-11-21 03:23:26 +0300298 return x;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400301static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400302{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300303 u8 x = inb(ec->data_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800304
Lv Zhengd8d031a2015-05-15 14:16:42 +0800305 ec->timestamp = jiffies;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800306 ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400307 return x;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400308}
309
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400310static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400311{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800312 ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400313 outb(command, ec->command_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800314 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400315}
316
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400317static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400318{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800319 ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400320 outb(data, ec->data_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800321 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400322}
323
Lv Zheng4625d752017-06-14 13:59:18 +0800324#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
Lv Zhenge34c0e22014-10-14 14:23:49 +0800325static const char *acpi_ec_cmd_string(u8 cmd)
326{
327 switch (cmd) {
328 case 0x80:
329 return "RD_EC";
330 case 0x81:
331 return "WR_EC";
332 case 0x82:
333 return "BE_EC";
334 case 0x83:
335 return "BD_EC";
336 case 0x84:
337 return "QR_EC";
338 }
339 return "UNKNOWN";
340}
341#else
342#define acpi_ec_cmd_string(cmd) "UNDEF"
343#endif
344
Lv Zhengca37bfd2015-02-05 16:27:22 +0800345/* --------------------------------------------------------------------------
346 * GPE Registers
347 * -------------------------------------------------------------------------- */
348
349static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
350{
351 acpi_event_status gpe_status = 0;
352
353 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
Lv Zheng7c0b2592015-05-15 14:16:17 +0800354 return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
Lv Zhengca37bfd2015-02-05 16:27:22 +0800355}
356
357static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
358{
359 if (open)
360 acpi_enable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800361 else {
362 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800363 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800364 }
Lv Zhengca37bfd2015-02-05 16:27:22 +0800365 if (acpi_ec_is_gpe_raised(ec)) {
366 /*
367 * On some platforms, EN=1 writes cannot trigger GPE. So
368 * software need to manually trigger a pseudo GPE event on
369 * EN=1 writes.
370 */
Lv Zheng3535a3c2015-02-27 14:48:15 +0800371 ec_dbg_raw("Polling quirk");
Lv Zhengca37bfd2015-02-05 16:27:22 +0800372 advance_transaction(ec);
373 }
374}
375
376static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
377{
378 if (close)
379 acpi_disable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800380 else {
381 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800382 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800383 }
Lv Zhengca37bfd2015-02-05 16:27:22 +0800384}
385
386static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
387{
388 /*
389 * GPE STS is a W1C register, which means:
390 * 1. Software can clear it without worrying about clearing other
391 * GPEs' STS bits when the hardware sets them in parallel.
392 * 2. As long as software can ensure only clearing it when it is
393 * set, hardware won't set it in parallel.
394 * So software can clear GPE in any contexts.
395 * Warning: do not move the check into advance_transaction() as the
396 * EC commands will be sent without GPE raised.
397 */
398 if (!acpi_ec_is_gpe_raised(ec))
399 return;
400 acpi_clear_gpe(NULL, ec->gpe);
401}
402
403/* --------------------------------------------------------------------------
404 * Transaction Management
405 * -------------------------------------------------------------------------- */
406
Lv Zheng9887d222015-02-06 08:57:59 +0800407static void acpi_ec_submit_request(struct acpi_ec *ec)
408{
409 ec->reference_count++;
Lv Zheng0e1affe2016-03-24 10:42:47 +0800410 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
411 ec->reference_count == 1)
Lv Zheng9887d222015-02-06 08:57:59 +0800412 acpi_ec_enable_gpe(ec, true);
413}
414
415static void acpi_ec_complete_request(struct acpi_ec *ec)
416{
417 bool flushed = false;
418
419 ec->reference_count--;
Lv Zheng0e1affe2016-03-24 10:42:47 +0800420 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
421 ec->reference_count == 0)
Lv Zheng9887d222015-02-06 08:57:59 +0800422 acpi_ec_disable_gpe(ec, true);
423 flushed = acpi_ec_flushed(ec);
424 if (flushed)
425 wake_up(&ec->wait);
426}
427
Lv Zhenge1d4d902015-02-06 08:58:05 +0800428static void acpi_ec_set_storm(struct acpi_ec *ec, u8 flag)
429{
430 if (!test_bit(flag, &ec->flags)) {
431 acpi_ec_disable_gpe(ec, false);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800432 ec_dbg_drv("Polling enabled");
Lv Zhenge1d4d902015-02-06 08:58:05 +0800433 set_bit(flag, &ec->flags);
434 }
435}
436
437static void acpi_ec_clear_storm(struct acpi_ec *ec, u8 flag)
438{
439 if (test_bit(flag, &ec->flags)) {
440 clear_bit(flag, &ec->flags);
441 acpi_ec_enable_gpe(ec, false);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800442 ec_dbg_drv("Polling disabled");
Lv Zhenge1d4d902015-02-06 08:58:05 +0800443 }
444}
445
Lv Zheng9887d222015-02-06 08:57:59 +0800446/*
447 * acpi_ec_submit_flushable_request() - Increase the reference count unless
448 * the flush operation is not in
449 * progress
450 * @ec: the EC device
451 *
452 * This function must be used before taking a new action that should hold
453 * the reference count. If this function returns false, then the action
454 * must be discarded or it will prevent the flush operation from being
455 * completed.
456 */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100457static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
Lv Zheng9887d222015-02-06 08:57:59 +0800458{
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100459 if (!acpi_ec_started(ec))
460 return false;
Lv Zheng9887d222015-02-06 08:57:59 +0800461 acpi_ec_submit_request(ec);
462 return true;
463}
464
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100465static void acpi_ec_submit_query(struct acpi_ec *ec)
Lv Zheng74443bb2015-01-14 19:28:47 +0800466{
Lv Zheng1ab69f22017-06-14 13:59:09 +0800467 acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM);
468 if (!acpi_ec_event_enabled(ec))
469 return;
470 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
Lv Zheng9d8993b2015-06-11 13:21:32 +0800471 ec_dbg_evt("Command(%s) submitted/blocked",
472 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
473 ec->nr_pending_queries++;
Lv Zheng74443bb2015-01-14 19:28:47 +0800474 schedule_work(&ec->work);
Lv Zhengf252cb02015-02-06 08:58:10 +0800475 }
Lv Zhengf252cb02015-02-06 08:58:10 +0800476}
477
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100478static void acpi_ec_complete_query(struct acpi_ec *ec)
Lv Zhengf252cb02015-02-06 08:58:10 +0800479{
Lv Zheng1ab69f22017-06-14 13:59:09 +0800480 if (test_and_clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
Lv Zheng9d8993b2015-06-11 13:21:32 +0800481 ec_dbg_evt("Command(%s) unblocked",
482 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zheng1ab69f22017-06-14 13:59:09 +0800483 acpi_ec_clear_storm(ec, EC_FLAGS_COMMAND_STORM);
Lv Zheng74443bb2015-01-14 19:28:47 +0800484}
485
Lv Zheng750f6282016-08-03 16:01:24 +0800486static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
487{
488 if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
489 ec_log_drv("event unblocked");
Lv Zhenge923e8e2016-08-03 16:01:30 +0800490 if (!test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
491 advance_transaction(ec);
Lv Zheng750f6282016-08-03 16:01:24 +0800492}
493
494static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
495{
496 if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
497 ec_log_drv("event blocked");
498}
499
Lv Zheng750f6282016-08-03 16:01:24 +0800500static void acpi_ec_enable_event(struct acpi_ec *ec)
501{
502 unsigned long flags;
503
504 spin_lock_irqsave(&ec->lock, flags);
505 if (acpi_ec_started(ec))
506 __acpi_ec_enable_event(ec);
507 spin_unlock_irqrestore(&ec->lock, flags);
Lv Zheng750f6282016-08-03 16:01:24 +0800508}
509
Eric Biggerseab05ec2016-10-05 10:33:16 -0700510#ifdef CONFIG_PM_SLEEP
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800511static bool acpi_ec_query_flushed(struct acpi_ec *ec)
512{
513 bool flushed;
514 unsigned long flags;
515
516 spin_lock_irqsave(&ec->lock, flags);
517 flushed = !ec->nr_pending_queries;
518 spin_unlock_irqrestore(&ec->lock, flags);
519 return flushed;
520}
521
522static void __acpi_ec_flush_event(struct acpi_ec *ec)
523{
524 /*
525 * When ec_freeze_events is true, we need to flush events in
526 * the proper position before entering the noirq stage.
527 */
528 wait_event(ec->wait, acpi_ec_query_flushed(ec));
529 if (ec_query_wq)
530 flush_workqueue(ec_query_wq);
531}
532
533static void acpi_ec_disable_event(struct acpi_ec *ec)
534{
535 unsigned long flags;
536
537 spin_lock_irqsave(&ec->lock, flags);
538 __acpi_ec_disable_event(ec);
539 spin_unlock_irqrestore(&ec->lock, flags);
540 __acpi_ec_flush_event(ec);
541}
Rafael J. Wysocki880a6622017-07-20 03:43:12 +0200542
543void acpi_ec_flush_work(void)
544{
545 if (first_ec)
546 __acpi_ec_flush_event(first_ec);
547
548 flush_scheduled_work();
549}
Eric Biggerseab05ec2016-10-05 10:33:16 -0700550#endif /* CONFIG_PM_SLEEP */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800551
Lv Zheng1d68d262015-06-11 13:21:38 +0800552static bool acpi_ec_guard_event(struct acpi_ec *ec)
553{
Lv Zheng61197542015-09-24 14:54:54 +0800554 bool guarded = true;
555 unsigned long flags;
556
557 spin_lock_irqsave(&ec->lock, flags);
558 /*
559 * If firmware SCI_EVT clearing timing is "event", we actually
560 * don't know when the SCI_EVT will be cleared by firmware after
561 * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
562 * acceptable period.
563 *
564 * The guarding period begins when EC_FLAGS_QUERY_PENDING is
565 * flagged, which means SCI_EVT check has just been performed.
566 * But if the current transaction is ACPI_EC_COMMAND_QUERY, the
567 * guarding should have already been performed (via
568 * EC_FLAGS_QUERY_GUARDING) and should not be applied so that the
569 * ACPI_EC_COMMAND_QUERY transaction can be transitioned into
570 * ACPI_EC_COMMAND_POLL state immediately.
571 */
Lv Zheng1d68d262015-06-11 13:21:38 +0800572 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
573 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY ||
574 !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
575 (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
Lv Zheng61197542015-09-24 14:54:54 +0800576 guarded = false;
577 spin_unlock_irqrestore(&ec->lock, flags);
578 return guarded;
Lv Zheng1d68d262015-06-11 13:21:38 +0800579}
580
Lv Zhengd8d031a2015-05-15 14:16:42 +0800581static int ec_transaction_polled(struct acpi_ec *ec)
582{
583 unsigned long flags;
584 int ret = 0;
585
586 spin_lock_irqsave(&ec->lock, flags);
587 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
588 ret = 1;
589 spin_unlock_irqrestore(&ec->lock, flags);
590 return ret;
591}
592
Lv Zhengf92fca02014-06-15 08:41:35 +0800593static int ec_transaction_completed(struct acpi_ec *ec)
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400594{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400595 unsigned long flags;
596 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800597
Feng Tangf351d022012-10-23 01:29:27 +0200598 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengc0d65342014-06-15 08:42:07 +0800599 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400600 ret = 1;
Feng Tangf351d022012-10-23 01:29:27 +0200601 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400602 return ret;
603}
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400604
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800605static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
606{
607 ec->curr->flags |= flag;
608 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
Lv Zheng1d68d262015-06-11 13:21:38 +0800609 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS &&
610 flag == ACPI_EC_COMMAND_POLL)
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800611 acpi_ec_complete_query(ec);
Lv Zheng1d68d262015-06-11 13:21:38 +0800612 if (ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY &&
613 flag == ACPI_EC_COMMAND_COMPLETE)
614 acpi_ec_complete_query(ec);
615 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
616 flag == ACPI_EC_COMMAND_COMPLETE)
617 set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800618 }
619}
620
Lv Zheng0c788082015-01-14 19:28:22 +0800621static void advance_transaction(struct acpi_ec *ec)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400622{
Puneet Kumar36b15872013-11-15 11:41:29 -0800623 struct transaction *t;
Lv Zheng66b42b72014-06-15 08:41:17 +0800624 u8 status;
Lv Zhengc0d65342014-06-15 08:42:07 +0800625 bool wakeup = false;
Feng Tangb76b51b2012-10-23 01:29:38 +0200626
Lv Zheng3535a3c2015-02-27 14:48:15 +0800627 ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
628 smp_processor_id());
Lv Zhengca37bfd2015-02-05 16:27:22 +0800629 /*
630 * By always clearing STS before handling all indications, we can
631 * ensure a hardware STS 0->1 change after this clearing can always
632 * trigger a GPE interrupt.
633 */
634 acpi_ec_clear_gpe(ec);
Lv Zheng66b42b72014-06-15 08:41:17 +0800635 status = acpi_ec_read_status(ec);
Puneet Kumar36b15872013-11-15 11:41:29 -0800636 t = ec->curr;
Lv Zheng1d68d262015-06-11 13:21:38 +0800637 /*
638 * Another IRQ or a guarded polling mode advancement is detected,
639 * the next QR_EC submission is then allowed.
640 */
641 if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
642 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
Lv Zheng66db3832015-06-11 13:21:51 +0800643 (!ec->nr_pending_queries ||
644 test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
Lv Zheng1d68d262015-06-11 13:21:38 +0800645 clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
646 acpi_ec_complete_query(ec);
647 }
648 }
Feng Tangb76b51b2012-10-23 01:29:38 +0200649 if (!t)
Lv Zhengf92fca02014-06-15 08:41:35 +0800650 goto err;
651 if (t->flags & ACPI_EC_COMMAND_POLL) {
652 if (t->wlen > t->wi) {
653 if ((status & ACPI_EC_FLAG_IBF) == 0)
654 acpi_ec_write_data(ec, t->wdata[t->wi++]);
655 else
656 goto err;
657 } else if (t->rlen > t->ri) {
658 if ((status & ACPI_EC_FLAG_OBF) == 1) {
659 t->rdata[t->ri++] = acpi_ec_read_data(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +0800660 if (t->rlen == t->ri) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800661 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800662 if (t->command == ACPI_EC_COMMAND_QUERY)
Lv Zheng9d8993b2015-06-11 13:21:32 +0800663 ec_dbg_evt("Command(%s) completed by hardware",
664 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zhengc0d65342014-06-15 08:42:07 +0800665 wakeup = true;
666 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800667 } else
668 goto err;
669 } else if (t->wlen == t->wi &&
Lv Zhengc0d65342014-06-15 08:42:07 +0800670 (status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800671 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zhengc0d65342014-06-15 08:42:07 +0800672 wakeup = true;
673 }
Lv Zheng0c788082015-01-14 19:28:22 +0800674 goto out;
Lv Zhengf92fca02014-06-15 08:41:35 +0800675 } else {
Lv Zheng79149002014-10-29 11:33:49 +0800676 if (EC_FLAGS_QUERY_HANDSHAKE &&
677 !(status & ACPI_EC_FLAG_SCI) &&
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800678 (t->command == ACPI_EC_COMMAND_QUERY)) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800679 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800680 t->rdata[t->ri++] = 0x00;
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800681 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zheng9d8993b2015-06-11 13:21:32 +0800682 ec_dbg_evt("Command(%s) completed by software",
683 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800684 wakeup = true;
685 } else if ((status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf92fca02014-06-15 08:41:35 +0800686 acpi_ec_write_cmd(ec, t->command);
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800687 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400688 } else
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300689 goto err;
Lv Zheng0c788082015-01-14 19:28:22 +0800690 goto out;
Lv Zhengf92fca02014-06-15 08:41:35 +0800691 }
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300692err:
Feng Tanga3cd8d22012-10-23 01:30:12 +0200693 /*
694 * If SCI bit is set, then don't think it's a false IRQ
695 * otherwise will take a not handled IRQ as a false one.
696 */
Lv Zhengf92fca02014-06-15 08:41:35 +0800697 if (!(status & ACPI_EC_FLAG_SCI)) {
Lv Zhenge1d4d902015-02-06 08:58:05 +0800698 if (in_interrupt() && t) {
699 if (t->irq_count < ec_storm_threshold)
700 ++t->irq_count;
701 /* Allow triggering on 0 threshold */
702 if (t->irq_count == ec_storm_threshold)
703 acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM);
704 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800705 }
Lv Zheng0c788082015-01-14 19:28:22 +0800706out:
Lv Zheng74443bb2015-01-14 19:28:47 +0800707 if (status & ACPI_EC_FLAG_SCI)
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100708 acpi_ec_submit_query(ec);
Lv Zheng0c788082015-01-14 19:28:22 +0800709 if (wakeup && in_interrupt())
710 wake_up(&ec->wait);
Lv Zhengf92fca02014-06-15 08:41:35 +0800711}
Feng Tanga3cd8d22012-10-23 01:30:12 +0200712
Lv Zhengf92fca02014-06-15 08:41:35 +0800713static void start_transaction(struct acpi_ec *ec)
714{
715 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
716 ec->curr->flags = 0;
Lv Zhengd8d031a2015-05-15 14:16:42 +0800717}
718
719static int ec_guard(struct acpi_ec *ec)
720{
Lv Zhengc3a696b2017-01-20 16:42:48 +0800721 unsigned long guard = usecs_to_jiffies(ec->polling_guard);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800722 unsigned long timeout = ec->timestamp + guard;
723
Lv Zheng61197542015-09-24 14:54:54 +0800724 /* Ensure guarding period before polling EC status */
Lv Zhengd8d031a2015-05-15 14:16:42 +0800725 do {
Lv Zhengc3a696b2017-01-20 16:42:48 +0800726 if (ec->busy_polling) {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800727 /* Perform busy polling */
728 if (ec_transaction_completed(ec))
729 return 0;
730 udelay(jiffies_to_usecs(guard));
731 } else {
732 /*
733 * Perform wait polling
Lv Zheng61197542015-09-24 14:54:54 +0800734 * 1. Wait the transaction to be completed by the
735 * GPE handler after the transaction enters
736 * ACPI_EC_COMMAND_POLL state.
737 * 2. A special guarding logic is also required
738 * for event clearing mode "event" before the
739 * transaction enters ACPI_EC_COMMAND_POLL
740 * state.
Lv Zhengd8d031a2015-05-15 14:16:42 +0800741 */
Lv Zheng1d68d262015-06-11 13:21:38 +0800742 if (!ec_transaction_polled(ec) &&
743 !acpi_ec_guard_event(ec))
Lv Zhengd8d031a2015-05-15 14:16:42 +0800744 break;
745 if (wait_event_timeout(ec->wait,
746 ec_transaction_completed(ec),
747 guard))
748 return 0;
749 }
Lv Zhengd8d031a2015-05-15 14:16:42 +0800750 } while (time_before(jiffies, timeout));
751 return -ETIME;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400752}
753
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400754static int ec_poll(struct acpi_ec *ec)
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300755{
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400756 unsigned long flags;
Lan Tianyu28fe5c82013-05-06 03:23:40 +0000757 int repeat = 5; /* number of command restarts */
Lv Zheng7a73e602014-10-14 14:24:01 +0800758
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400759 while (repeat--) {
760 unsigned long delay = jiffies +
Thomas Renninger7a18e962010-10-21 18:24:57 +0200761 msecs_to_jiffies(ec_delay);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400762 do {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800763 if (!ec_guard(ec))
764 return 0;
Lv Zhengf92fca02014-06-15 08:41:35 +0800765 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800766 advance_transaction(ec);
Lv Zhengf92fca02014-06-15 08:41:35 +0800767 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400768 } while (time_before(jiffies, delay));
Lan Tianyu16a26e82013-09-12 03:32:04 -0400769 pr_debug("controller reset, restart transaction\n");
Feng Tangf351d022012-10-23 01:29:27 +0200770 spin_lock_irqsave(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400771 start_transaction(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200772 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiyaf3fd142006-12-07 18:42:16 +0300773 }
Alexey Starikovskiyb77d81b2008-03-21 17:07:15 +0300774 return -ETIME;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500775}
776
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400777static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400778 struct transaction *t)
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400779{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400780 unsigned long tmp;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400781 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800782
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400783 /* start transaction */
Feng Tangf351d022012-10-23 01:29:27 +0200784 spin_lock_irqsave(&ec->lock, tmp);
Lv Zheng9887d222015-02-06 08:57:59 +0800785 /* Enable GPE for command processing (IBF=0/OBF=1) */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100786 if (!acpi_ec_submit_flushable_request(ec)) {
Lv Zhengad479e72015-02-06 08:57:52 +0800787 ret = -EINVAL;
788 goto unlock;
789 }
Lv Zheng770970f2015-02-27 14:48:24 +0800790 ec_dbg_ref(ec, "Increase command");
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400791 /* following two actions should be kept atomic */
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400792 ec->curr = t;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800793 ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300794 start_transaction(ec);
Lv Zhengdf9ff912014-10-29 11:33:43 +0800795 spin_unlock_irqrestore(&ec->lock, tmp);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800796
Lv Zhengdf9ff912014-10-29 11:33:43 +0800797 ret = ec_poll(ec);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800798
Lv Zhengdf9ff912014-10-29 11:33:43 +0800799 spin_lock_irqsave(&ec->lock, tmp);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800800 if (t->irq_count == ec_storm_threshold)
801 acpi_ec_clear_storm(ec, EC_FLAGS_COMMAND_STORM);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800802 ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400803 ec->curr = NULL;
Lv Zheng9887d222015-02-06 08:57:59 +0800804 /* Disable GPE for command processing (IBF=0/OBF=1) */
805 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800806 ec_dbg_ref(ec, "Decrease command");
Lv Zhengad479e72015-02-06 08:57:52 +0800807unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200808 spin_unlock_irqrestore(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400809 return ret;
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400810}
811
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400812static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
Luming Yu45bea152005-07-23 04:08:00 -0400813{
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400814 int status;
Len Brown50526df2005-08-11 17:32:05 -0400815 u32 glk;
Lv Zheng7a73e602014-10-14 14:24:01 +0800816
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400817 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
Patrick Mocheld550d982006-06-27 00:41:40 -0400818 return -EINVAL;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400819 if (t->rdata)
820 memset(t->rdata, 0, t->rlen);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800821
Feng Tangf351d022012-10-23 01:29:27 +0200822 mutex_lock(&ec->mutex);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400823 if (ec->global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300825 if (ACPI_FAILURE(status)) {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400826 status = -ENODEV;
827 goto unlock;
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300828 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 }
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300830
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400831 status = acpi_ec_transaction_unlocked(ec, t);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300832
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400833 if (ec->global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 acpi_release_global_lock(glk);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400835unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200836 mutex_unlock(&ec->mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400837 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838}
839
Roel Kluin8a383ef2008-12-09 20:45:30 +0100840static int acpi_ec_burst_enable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300841{
842 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400843 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
844 .wdata = NULL, .rdata = &d,
845 .wlen = 0, .rlen = 1};
846
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400847 return acpi_ec_transaction(ec, &t);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300848}
849
Roel Kluin8a383ef2008-12-09 20:45:30 +0100850static int acpi_ec_burst_disable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300851{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400852 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
853 .wdata = NULL, .rdata = NULL,
854 .wlen = 0, .rlen = 0};
855
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400856 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400857 acpi_ec_transaction(ec, &t) : 0;
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300858}
859
Lv Zheng7a73e602014-10-14 14:24:01 +0800860static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400861{
862 int result;
863 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400864 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
865 .wdata = &address, .rdata = &d,
866 .wlen = 1, .rlen = 1};
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400867
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400868 result = acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400869 *data = d;
870 return result;
871}
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400872
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400873static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
874{
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300875 u8 wdata[2] = { address, data };
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400876 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
877 .wdata = wdata, .rdata = NULL,
878 .wlen = 2, .rlen = 0};
879
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400880 return acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400881}
882
Feng Tangb76b51b2012-10-23 01:29:38 +0200883int ec_read(u8 addr, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 int err;
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400886 u8 temp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888 if (!first_ec)
889 return -ENODEV;
890
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300891 err = acpi_ec_read(first_ec, addr, &temp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893 if (!err) {
894 *val = temp_data;
895 return 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800896 }
897 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898}
899EXPORT_SYMBOL(ec_read);
900
Len Brown50526df2005-08-11 17:32:05 -0400901int ec_write(u8 addr, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 int err;
904
905 if (!first_ec)
906 return -ENODEV;
907
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300908 err = acpi_ec_write(first_ec, addr, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
910 return err;
911}
912EXPORT_SYMBOL(ec_write);
913
Randy Dunlap616362d2006-10-27 01:47:34 -0400914int ec_transaction(u8 command,
Lv Zheng7a73e602014-10-14 14:24:01 +0800915 const u8 *wdata, unsigned wdata_len,
916 u8 *rdata, unsigned rdata_len)
Luming Yu45bea152005-07-23 04:08:00 -0400917{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400918 struct transaction t = {.command = command,
919 .wdata = wdata, .rdata = rdata,
920 .wlen = wdata_len, .rlen = rdata_len};
Lv Zheng7a73e602014-10-14 14:24:01 +0800921
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400922 if (!first_ec)
923 return -ENODEV;
924
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400925 return acpi_ec_transaction(first_ec, &t);
Luming Yu45bea152005-07-23 04:08:00 -0400926}
Lennart Poetteringab9e43c2006-10-03 22:49:00 -0400927EXPORT_SYMBOL(ec_transaction);
928
Seth Forshee3e2abc52012-01-18 13:44:08 -0600929/* Get the handle to the EC device */
930acpi_handle ec_get_handle(void)
931{
932 if (!first_ec)
933 return NULL;
934 return first_ec->handle;
935}
Seth Forshee3e2abc52012-01-18 13:44:08 -0600936EXPORT_SYMBOL(ec_get_handle);
937
Lv Zhengad479e72015-02-06 08:57:52 +0800938static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
939{
940 unsigned long flags;
941
942 spin_lock_irqsave(&ec->lock, flags);
943 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800944 ec_dbg_drv("Starting EC");
Lv Zheng9887d222015-02-06 08:57:59 +0800945 /* Enable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800946 if (!resuming) {
Lv Zheng9887d222015-02-06 08:57:59 +0800947 acpi_ec_submit_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800948 ec_dbg_ref(ec, "Increase driver");
Lv Zhengc2b46d62016-08-03 16:01:36 +0800949 }
Lv Zheng3535a3c2015-02-27 14:48:15 +0800950 ec_log_drv("EC started");
Lv Zhengad479e72015-02-06 08:57:52 +0800951 }
952 spin_unlock_irqrestore(&ec->lock, flags);
953}
954
Lv Zheng9887d222015-02-06 08:57:59 +0800955static bool acpi_ec_stopped(struct acpi_ec *ec)
956{
957 unsigned long flags;
958 bool flushed;
959
960 spin_lock_irqsave(&ec->lock, flags);
961 flushed = acpi_ec_flushed(ec);
962 spin_unlock_irqrestore(&ec->lock, flags);
963 return flushed;
964}
965
Lv Zhengad479e72015-02-06 08:57:52 +0800966static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
967{
968 unsigned long flags;
969
970 spin_lock_irqsave(&ec->lock, flags);
971 if (acpi_ec_started(ec)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800972 ec_dbg_drv("Stopping EC");
Lv Zhengad479e72015-02-06 08:57:52 +0800973 set_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng9887d222015-02-06 08:57:59 +0800974 spin_unlock_irqrestore(&ec->lock, flags);
975 wait_event(ec->wait, acpi_ec_stopped(ec));
976 spin_lock_irqsave(&ec->lock, flags);
977 /* Disable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800978 if (!suspending) {
Lv Zheng9887d222015-02-06 08:57:59 +0800979 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800980 ec_dbg_ref(ec, "Decrease driver");
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800981 } else if (!ec_freeze_events)
Lv Zheng750f6282016-08-03 16:01:24 +0800982 __acpi_ec_disable_event(ec);
Lv Zhengad479e72015-02-06 08:57:52 +0800983 clear_bit(EC_FLAGS_STARTED, &ec->flags);
984 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800985 ec_log_drv("EC stopped");
Lv Zhengad479e72015-02-06 08:57:52 +0800986 }
987 spin_unlock_irqrestore(&ec->lock, flags);
988}
989
Lv Zhengc3a696b2017-01-20 16:42:48 +0800990static void acpi_ec_enter_noirq(struct acpi_ec *ec)
991{
992 unsigned long flags;
993
994 spin_lock_irqsave(&ec->lock, flags);
995 ec->busy_polling = true;
996 ec->polling_guard = 0;
997 ec_log_drv("interrupt blocked");
998 spin_unlock_irqrestore(&ec->lock, flags);
999}
1000
1001static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1002{
1003 unsigned long flags;
1004
1005 spin_lock_irqsave(&ec->lock, flags);
1006 ec->busy_polling = ec_busy_polling;
1007 ec->polling_guard = ec_polling_guard;
1008 ec_log_drv("interrupt unblocked");
1009 spin_unlock_irqrestore(&ec->lock, flags);
1010}
1011
Rafael J. Wysockife955682010-04-09 01:40:38 +02001012void acpi_ec_block_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001013{
1014 struct acpi_ec *ec = first_ec;
1015
1016 if (!ec)
1017 return;
1018
Feng Tangf351d022012-10-23 01:29:27 +02001019 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001020 /* Prevent transactions from being carried out */
Lv Zhengad479e72015-02-06 08:57:52 +08001021 acpi_ec_stop(ec, true);
Feng Tangf351d022012-10-23 01:29:27 +02001022 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001023}
1024
Rafael J. Wysockife955682010-04-09 01:40:38 +02001025void acpi_ec_unblock_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001026{
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001027 /*
1028 * Allow transactions to happen again (this function is called from
1029 * atomic context during wakeup, so we don't need to acquire the mutex).
1030 */
1031 if (first_ec)
Lv Zhengad479e72015-02-06 08:57:52 +08001032 acpi_ec_start(first_ec, true);
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001033}
1034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035/* --------------------------------------------------------------------------
1036 Event Management
1037 -------------------------------------------------------------------------- */
Lv Zheng01305d42015-01-14 19:28:28 +08001038static struct acpi_ec_query_handler *
1039acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler)
1040{
1041 if (handler)
1042 kref_get(&handler->kref);
1043 return handler;
1044}
1045
Lv Zheng0700c042015-09-24 14:54:48 +08001046static struct acpi_ec_query_handler *
1047acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1048{
1049 struct acpi_ec_query_handler *handler;
1050 bool found = false;
1051
1052 mutex_lock(&ec->mutex);
1053 list_for_each_entry(handler, &ec->list, node) {
1054 if (value == handler->query_bit) {
1055 found = true;
1056 break;
1057 }
1058 }
1059 mutex_unlock(&ec->mutex);
1060 return found ? acpi_ec_get_query_handler(handler) : NULL;
1061}
1062
Lv Zheng01305d42015-01-14 19:28:28 +08001063static void acpi_ec_query_handler_release(struct kref *kref)
1064{
1065 struct acpi_ec_query_handler *handler =
1066 container_of(kref, struct acpi_ec_query_handler, kref);
1067
1068 kfree(handler);
1069}
1070
1071static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1072{
1073 kref_put(&handler->kref, acpi_ec_query_handler_release);
1074}
1075
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001076int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1077 acpi_handle handle, acpi_ec_query_func func,
1078 void *data)
1079{
1080 struct acpi_ec_query_handler *handler =
1081 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001082
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001083 if (!handler)
1084 return -ENOMEM;
1085
1086 handler->query_bit = query_bit;
1087 handler->handle = handle;
1088 handler->func = func;
1089 handler->data = data;
Feng Tangf351d022012-10-23 01:29:27 +02001090 mutex_lock(&ec->mutex);
Lv Zheng01305d42015-01-14 19:28:28 +08001091 kref_init(&handler->kref);
Alexey Starikovskiy30c08572007-09-26 19:43:22 +04001092 list_add(&handler->node, &ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001093 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001094 return 0;
1095}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001096EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1097
Lv Zheng0700c042015-09-24 14:54:48 +08001098static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1099 bool remove_all, u8 query_bit)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001100{
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001101 struct acpi_ec_query_handler *handler, *tmp;
Lv Zheng01305d42015-01-14 19:28:28 +08001102 LIST_HEAD(free_list);
Lv Zheng7a73e602014-10-14 14:24:01 +08001103
Feng Tangf351d022012-10-23 01:29:27 +02001104 mutex_lock(&ec->mutex);
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001105 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
Lv Zheng0700c042015-09-24 14:54:48 +08001106 if (remove_all || query_bit == handler->query_bit) {
Lv Zheng01305d42015-01-14 19:28:28 +08001107 list_del_init(&handler->node);
1108 list_add(&handler->node, &free_list);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001109 }
1110 }
Feng Tangf351d022012-10-23 01:29:27 +02001111 mutex_unlock(&ec->mutex);
Chris Bainbridge6b5eab52015-04-22 00:25:36 +01001112 list_for_each_entry_safe(handler, tmp, &free_list, node)
Lv Zheng01305d42015-01-14 19:28:28 +08001113 acpi_ec_put_query_handler(handler);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001114}
Lv Zheng0700c042015-09-24 14:54:48 +08001115
1116void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1117{
1118 acpi_ec_remove_query_handlers(ec, false, query_bit);
1119}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001120EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Lv Zheng02b771b2015-08-12 11:12:02 +08001122static struct acpi_ec_query *acpi_ec_create_query(u8 *pval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123{
Lv Zheng02b771b2015-08-12 11:12:02 +08001124 struct acpi_ec_query *q;
1125 struct transaction *t;
Lv Zheng7a73e602014-10-14 14:24:01 +08001126
Lv Zheng02b771b2015-08-12 11:12:02 +08001127 q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1128 if (!q)
1129 return NULL;
1130 INIT_WORK(&q->work, acpi_ec_event_processor);
1131 t = &q->transaction;
1132 t->command = ACPI_EC_COMMAND_QUERY;
1133 t->rdata = pval;
1134 t->rlen = 1;
1135 return q;
1136}
1137
1138static void acpi_ec_delete_query(struct acpi_ec_query *q)
1139{
1140 if (q) {
1141 if (q->handler)
1142 acpi_ec_put_query_handler(q->handler);
1143 kfree(q);
1144 }
1145}
1146
1147static void acpi_ec_event_processor(struct work_struct *work)
1148{
1149 struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1150 struct acpi_ec_query_handler *handler = q->handler;
1151
Lv Zheng3535a3c2015-02-27 14:48:15 +08001152 ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001153 if (handler->func)
1154 handler->func(handler->data);
1155 else if (handler->handle)
1156 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
Lv Zheng3535a3c2015-02-27 14:48:15 +08001157 ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
Lv Zheng02b771b2015-08-12 11:12:02 +08001158 acpi_ec_delete_query(q);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001159}
1160
Lv Zheng550b3aac2015-01-14 19:28:53 +08001161static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001162{
1163 u8 value = 0;
Lv Zhengc2cf5762015-01-14 19:28:33 +08001164 int result;
Lv Zheng02b771b2015-08-12 11:12:02 +08001165 struct acpi_ec_query *q;
1166
1167 q = acpi_ec_create_query(&value);
1168 if (!q)
1169 return -ENOMEM;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301170
Lv Zheng550b3aac2015-01-14 19:28:53 +08001171 /*
1172 * Query the EC to find out which _Qxx method we need to evaluate.
1173 * Note that successful completion of the query causes the ACPI_EC_SCI
1174 * bit to be cleared (and thus clearing the interrupt source).
1175 */
Lv Zheng02b771b2015-08-12 11:12:02 +08001176 result = acpi_ec_transaction(ec, &q->transaction);
Lv Zheng550b3aac2015-01-14 19:28:53 +08001177 if (!value)
Lv Zheng02b771b2015-08-12 11:12:02 +08001178 result = -ENODATA;
1179 if (result)
1180 goto err_exit;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301181
Lv Zheng0700c042015-09-24 14:54:48 +08001182 q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1183 if (!q->handler) {
1184 result = -ENODATA;
1185 goto err_exit;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001186 }
Lv Zheng0700c042015-09-24 14:54:48 +08001187
1188 /*
1189 * It is reported that _Qxx are evaluated in a parallel way on
1190 * Windows:
1191 * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1192 *
1193 * Put this log entry before schedule_work() in order to make
1194 * it appearing before any other log entries occurred during the
1195 * work queue execution.
1196 */
1197 ec_dbg_evt("Query(0x%02x) scheduled", value);
Lv Zhenge1191bd2016-08-03 09:00:14 +08001198 if (!queue_work(ec_query_wq, &q->work)) {
Lv Zheng0700c042015-09-24 14:54:48 +08001199 ec_dbg_evt("Query(0x%02x) overlapped", value);
1200 result = -EBUSY;
1201 }
Lv Zheng02b771b2015-08-12 11:12:02 +08001202
1203err_exit:
Markus Elfring4981c2b2015-11-15 22:42:27 +01001204 if (result)
Lv Zheng02b771b2015-08-12 11:12:02 +08001205 acpi_ec_delete_query(q);
1206 if (data)
1207 *data = value;
Lv Zhengc2cf5762015-01-14 19:28:33 +08001208 return result;
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001209}
1210
Lv Zheng1d68d262015-06-11 13:21:38 +08001211static void acpi_ec_check_event(struct acpi_ec *ec)
1212{
1213 unsigned long flags;
1214
1215 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1216 if (ec_guard(ec)) {
1217 spin_lock_irqsave(&ec->lock, flags);
1218 /*
1219 * Take care of the SCI_EVT unless no one else is
1220 * taking care of it.
1221 */
1222 if (!ec->curr)
1223 advance_transaction(ec);
1224 spin_unlock_irqrestore(&ec->lock, flags);
1225 }
1226 }
1227}
1228
Lv Zheng9d8993b2015-06-11 13:21:32 +08001229static void acpi_ec_event_handler(struct work_struct *work)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001230{
Lv Zheng9d8993b2015-06-11 13:21:32 +08001231 unsigned long flags;
Lv Zheng74443bb2015-01-14 19:28:47 +08001232 struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
Lv Zheng7a73e602014-10-14 14:24:01 +08001233
Lv Zheng9d8993b2015-06-11 13:21:32 +08001234 ec_dbg_evt("Event started");
1235
1236 spin_lock_irqsave(&ec->lock, flags);
1237 while (ec->nr_pending_queries) {
1238 spin_unlock_irqrestore(&ec->lock, flags);
1239 (void)acpi_ec_query(ec, NULL);
1240 spin_lock_irqsave(&ec->lock, flags);
1241 ec->nr_pending_queries--;
Lv Zheng66db3832015-06-11 13:21:51 +08001242 /*
1243 * Before exit, make sure that this work item can be
1244 * scheduled again. There might be QR_EC failures, leaving
1245 * EC_FLAGS_QUERY_PENDING uncleared and preventing this work
1246 * item from being scheduled again.
1247 */
1248 if (!ec->nr_pending_queries) {
1249 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
1250 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY)
1251 acpi_ec_complete_query(ec);
1252 }
Lv Zheng9d8993b2015-06-11 13:21:32 +08001253 }
1254 spin_unlock_irqrestore(&ec->lock, flags);
1255
1256 ec_dbg_evt("Event stopped");
Lv Zheng1d68d262015-06-11 13:21:38 +08001257
1258 acpi_ec_check_event(ec);
Luming Yu45bea152005-07-23 04:08:00 -04001259}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Lin Ming8b6cd8a2010-12-13 13:38:46 +08001261static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1262 u32 gpe_number, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263{
Lv Zhengf92fca02014-06-15 08:41:35 +08001264 unsigned long flags;
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +03001265 struct acpi_ec *ec = data;
Lennart Poettering00eb43a2007-05-04 14:16:19 +02001266
Lv Zhengf92fca02014-06-15 08:41:35 +08001267 spin_lock_irqsave(&ec->lock, flags);
Lv Zheng0c788082015-01-14 19:28:22 +08001268 advance_transaction(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +08001269 spin_unlock_irqrestore(&ec->lock, flags);
Lv Zhengca37bfd2015-02-05 16:27:22 +08001270 return ACPI_INTERRUPT_HANDLED;
Alexey Starikovskiy845625c2008-03-21 17:07:03 +03001271}
1272
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001274 * Address Space Management
1275 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
1277static acpi_status
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001278acpi_ec_space_handler(u32 function, acpi_physical_address address,
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001279 u32 bits, u64 *value64,
Len Brown50526df2005-08-11 17:32:05 -04001280 void *handler_context, void *region_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281{
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +03001282 struct acpi_ec *ec = handler_context;
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001283 int result = 0, i, bytes = bits / 8;
1284 u8 *value = (u8 *)value64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 if ((address > 0xFF) || !value || !handler_context)
Patrick Mocheld550d982006-06-27 00:41:40 -04001287 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001289 if (function != ACPI_READ && function != ACPI_WRITE)
Patrick Mocheld550d982006-06-27 00:41:40 -04001290 return AE_BAD_PARAMETER;
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001291
Lv Zhengc3a696b2017-01-20 16:42:48 +08001292 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001293 acpi_ec_burst_enable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001294
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001295 for (i = 0; i < bytes; ++i, ++address, ++value)
1296 result = (function == ACPI_READ) ?
1297 acpi_ec_read(ec, address, value) :
1298 acpi_ec_write(ec, address, *value);
Alexey Starikovskiy3e71a872008-01-11 02:42:51 +03001299
Lv Zhengc3a696b2017-01-20 16:42:48 +08001300 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001301 acpi_ec_burst_disable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 switch (result) {
1304 case -EINVAL:
Patrick Mocheld550d982006-06-27 00:41:40 -04001305 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 case -ENODEV:
Patrick Mocheld550d982006-06-27 00:41:40 -04001307 return AE_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 case -ETIME:
Patrick Mocheld550d982006-06-27 00:41:40 -04001309 return AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 default:
Patrick Mocheld550d982006-06-27 00:41:40 -04001311 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313}
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001316 * Driver Interface
1317 * -------------------------------------------------------------------------- */
1318
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001319static acpi_status
1320ec_parse_io_ports(struct acpi_resource *resource, void *context);
1321
Lv Zheng72c77b72016-09-07 16:50:08 +08001322static void acpi_ec_free(struct acpi_ec *ec)
1323{
1324 if (first_ec == ec)
1325 first_ec = NULL;
1326 if (boot_ec == ec)
1327 boot_ec = NULL;
1328 kfree(ec);
1329}
1330
1331static struct acpi_ec *acpi_ec_alloc(void)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001332{
1333 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001334
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001335 if (!ec)
1336 return NULL;
Feng Tangf351d022012-10-23 01:29:27 +02001337 mutex_init(&ec->mutex);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001338 init_waitqueue_head(&ec->wait);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001339 INIT_LIST_HEAD(&ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001340 spin_lock_init(&ec->lock);
Lv Zheng9d8993b2015-06-11 13:21:32 +08001341 INIT_WORK(&ec->work, acpi_ec_event_handler);
Lv Zhengd8d031a2015-05-15 14:16:42 +08001342 ec->timestamp = jiffies;
Lv Zhengc3a696b2017-01-20 16:42:48 +08001343 ec->busy_polling = true;
1344 ec->polling_guard = 0;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001345 return ec;
1346}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001348static acpi_status
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001349acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1350 void *context, void **return_value)
1351{
Lin Ming0175d562008-12-16 16:46:12 +08001352 char node_name[5];
1353 struct acpi_buffer buffer = { sizeof(node_name), node_name };
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001354 struct acpi_ec *ec = context;
1355 int value = 0;
Lin Ming0175d562008-12-16 16:46:12 +08001356 acpi_status status;
1357
1358 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1359
Lv Zheng7a73e602014-10-14 14:24:01 +08001360 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001361 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001362 return AE_OK;
1363}
1364
1365static acpi_status
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001366ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001367{
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001368 acpi_status status;
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001369 unsigned long long tmp = 0;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001370 struct acpi_ec *ec = context;
Alexey Starikovskiya5032bf2009-04-01 01:33:15 -04001371
1372 /* clear addr values, ec_parse_io_ports depend on it */
1373 ec->command_addr = ec->data_addr = 0;
1374
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001375 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1376 ec_parse_io_ports, ec);
1377 if (ACPI_FAILURE(status))
1378 return status;
Lv Zhengae56c9f2017-06-15 09:41:35 +08001379 if (ec->data_addr == 0 || ec->command_addr == 0)
1380 return AE_OK;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001381
Chris Chiu440f53d2017-06-15 09:41:47 +08001382 if (boot_ec && boot_ec_is_ecdt && EC_FLAGS_IGNORE_DSDT_GPE) {
1383 /*
1384 * Always inherit the GPE number setting from the ECDT
1385 * EC.
1386 */
1387 ec->gpe = boot_ec->gpe;
1388 } else {
1389 /* Get GPE bit assignment (EC events). */
1390 /* TODO: Add support for _GPE returning a package */
1391 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1392 if (ACPI_FAILURE(status))
1393 return status;
1394 ec->gpe = tmp;
1395 }
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001396 /* Use the global lock for all EC transactions? */
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001397 tmp = 0;
Matthew Wilcox27663c52008-10-10 02:22:59 -04001398 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1399 ec->global_lock = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001400 ec->handle = handle;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001401 return AE_CTRL_TERMINATE;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001402}
1403
Lv Zheng72c77b72016-09-07 16:50:08 +08001404/*
1405 * Note: This function returns an error code only when the address space
1406 * handler is not installed, which means "not able to handle
1407 * transactions".
1408 */
Lv Zheng2a570842016-09-07 16:50:21 +08001409static int ec_install_handlers(struct acpi_ec *ec, bool handle_events)
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001410{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001411 acpi_status status;
Lv Zheng7a73e602014-10-14 14:24:01 +08001412
Lv Zhengad479e72015-02-06 08:57:52 +08001413 acpi_ec_start(ec, false);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001414
1415 if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
Lv Zhengc3a696b2017-01-20 16:42:48 +08001416 acpi_ec_enter_noirq(ec);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001417 status = acpi_install_address_space_handler(ec->handle,
1418 ACPI_ADR_SPACE_EC,
1419 &acpi_ec_space_handler,
1420 NULL, ec);
1421 if (ACPI_FAILURE(status)) {
1422 if (status == AE_NOT_FOUND) {
1423 /*
1424 * Maybe OS fails in evaluating the _REG
1425 * object. The AE_NOT_FOUND error will be
1426 * ignored and OS * continue to initialize
1427 * EC.
1428 */
1429 pr_err("Fail in evaluating the _REG object"
1430 " of EC device. Broken bios is suspected.\n");
1431 } else {
1432 acpi_ec_stop(ec, false);
1433 return -ENODEV;
1434 }
1435 }
1436 set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1437 }
1438
Lv Zheng2a570842016-09-07 16:50:21 +08001439 if (!handle_events)
1440 return 0;
1441
1442 if (!test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
1443 /* Find and register all query methods */
1444 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1445 acpi_ec_register_query_methods,
1446 NULL, ec, NULL);
1447 set_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1448 }
Lv Zheng0e1affe2016-03-24 10:42:47 +08001449 if (!test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1450 status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1451 ACPI_GPE_EDGE_TRIGGERED,
1452 &acpi_ec_gpe_handler, ec);
1453 /* This is not fatal as we can poll EC events */
1454 if (ACPI_SUCCESS(status)) {
1455 set_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
Lv Zhengc3a696b2017-01-20 16:42:48 +08001456 acpi_ec_leave_noirq(ec);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001457 if (test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1458 ec->reference_count >= 1)
1459 acpi_ec_enable_gpe(ec, true);
Lv Zheng2a570842016-09-07 16:50:21 +08001460
1461 /* EC is fully operational, allow queries */
1462 acpi_ec_enable_event(ec);
Zhao Yakui20edd742008-10-17 02:02:44 -04001463 }
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001464 }
1465
1466 return 0;
1467}
1468
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469static void ec_remove_handlers(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470{
Lv Zheng0e1affe2016-03-24 10:42:47 +08001471 if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1472 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1473 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1474 pr_err("failed to remove space handler\n");
1475 clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1476 }
1477
Lv Zhengfa5b4a52016-07-08 09:25:05 +08001478 /*
1479 * Stops handling the EC transactions after removing the operation
1480 * region handler. This is required because _REG(DISCONNECT)
1481 * invoked during the removal can result in new EC transactions.
1482 *
1483 * Flushes the EC requests and thus disables the GPE before
1484 * removing the GPE handler. This is required by the current ACPICA
1485 * GPE core. ACPICA GPE core will automatically disable a GPE when
1486 * it is indicated but there is no way to handle it. So the drivers
1487 * must disable the GPEs prior to removing the GPE handlers.
1488 */
1489 acpi_ec_stop(ec, false);
1490
Lv Zheng0e1affe2016-03-24 10:42:47 +08001491 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1492 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1493 &acpi_ec_gpe_handler)))
1494 pr_err("failed to remove gpe handler\n");
1495 clear_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
1496 }
Lv Zheng2a570842016-09-07 16:50:21 +08001497 if (test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
1498 acpi_ec_remove_query_handlers(ec, true, 0);
1499 clear_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1500 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
Lv Zheng2a570842016-09-07 16:50:21 +08001503static int acpi_ec_setup(struct acpi_ec *ec, bool handle_events)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
Lv Zheng72c77b72016-09-07 16:50:08 +08001505 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
Lv Zheng2a570842016-09-07 16:50:21 +08001507 ret = ec_install_handlers(ec, handle_events);
Lv Zheng72c77b72016-09-07 16:50:08 +08001508 if (ret)
1509 return ret;
1510
1511 /* First EC capable of handling transactions */
1512 if (!first_ec) {
1513 first_ec = ec;
1514 acpi_handle_info(first_ec->handle, "Used as first EC\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 }
Lv Zheng72c77b72016-09-07 16:50:08 +08001516
1517 acpi_handle_info(ec->handle,
1518 "GPE=0x%lx, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n",
1519 ec->gpe, ec->command_addr, ec->data_addr);
1520 return ret;
1521}
1522
Lv Zheng2a570842016-09-07 16:50:21 +08001523static int acpi_config_boot_ec(struct acpi_ec *ec, acpi_handle handle,
1524 bool handle_events, bool is_ecdt)
Lv Zheng72c77b72016-09-07 16:50:08 +08001525{
1526 int ret;
1527
Lv Zheng2a570842016-09-07 16:50:21 +08001528 /*
1529 * Changing the ACPI handle results in a re-configuration of the
1530 * boot EC. And if it happens after the namespace initialization,
1531 * it causes _REG evaluations.
1532 */
1533 if (boot_ec && boot_ec->handle != handle)
Lv Zheng72c77b72016-09-07 16:50:08 +08001534 ec_remove_handlers(boot_ec);
1535
1536 /* Unset old boot EC */
1537 if (boot_ec != ec)
1538 acpi_ec_free(boot_ec);
1539
Lv Zheng2a570842016-09-07 16:50:21 +08001540 /*
1541 * ECDT device creation is split into acpi_ec_ecdt_probe() and
1542 * acpi_ec_ecdt_start(). This function takes care of completing the
1543 * ECDT parsing logic as the handle update should be performed
1544 * between the installation/uninstallation of the handlers.
1545 */
1546 if (ec->handle != handle)
1547 ec->handle = handle;
1548
1549 ret = acpi_ec_setup(ec, handle_events);
Lv Zheng72c77b72016-09-07 16:50:08 +08001550 if (ret)
1551 return ret;
1552
1553 /* Set new boot EC */
1554 if (!boot_ec) {
1555 boot_ec = ec;
1556 boot_ec_is_ecdt = is_ecdt;
Lv Zheng72c77b72016-09-07 16:50:08 +08001557 }
Lv Zheng2a570842016-09-07 16:50:21 +08001558
1559 acpi_handle_info(boot_ec->handle,
1560 "Used as boot %s EC to handle transactions%s\n",
1561 is_ecdt ? "ECDT" : "DSDT",
1562 handle_events ? " and events" : "");
Lv Zheng72c77b72016-09-07 16:50:08 +08001563 return ret;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001564}
1565
Lv Zheng97cb1592016-09-07 16:50:27 +08001566static bool acpi_ec_ecdt_get_handle(acpi_handle *phandle)
1567{
1568 struct acpi_table_ecdt *ecdt_ptr;
1569 acpi_status status;
1570 acpi_handle handle;
1571
1572 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1573 (struct acpi_table_header **)&ecdt_ptr);
1574 if (ACPI_FAILURE(status))
1575 return false;
1576
1577 status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1578 if (ACPI_FAILURE(status))
1579 return false;
1580
1581 *phandle = handle;
1582 return true;
1583}
1584
1585static bool acpi_is_boot_ec(struct acpi_ec *ec)
1586{
1587 if (!boot_ec)
1588 return false;
Lv Zheng69b957c2017-08-17 10:21:12 +08001589 if (ec->command_addr == boot_ec->command_addr &&
Lv Zheng97cb1592016-09-07 16:50:27 +08001590 ec->data_addr == boot_ec->data_addr)
1591 return true;
1592 return false;
1593}
1594
Lv Zhengfd6231e2016-06-21 17:42:05 +08001595static int acpi_ec_add(struct acpi_device *device)
1596{
1597 struct acpi_ec *ec = NULL;
1598 int ret;
1599
1600 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1601 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1602
1603 ec = acpi_ec_alloc();
1604 if (!ec)
1605 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 if (ec_parse_device(device->handle, 0, ec, NULL) !=
1607 AE_CTRL_TERMINATE) {
Lv Zheng46922d22016-09-07 16:50:14 +08001608 ret = -EINVAL;
1609 goto err_alloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 }
1611
Lv Zheng97cb1592016-09-07 16:50:27 +08001612 if (acpi_is_boot_ec(ec)) {
1613 boot_ec_is_ecdt = false;
Lv Zheng69b957c2017-08-17 10:21:12 +08001614 /*
1615 * Trust PNP0C09 namespace location rather than ECDT ID.
1616 *
1617 * But trust ECDT GPE rather than _GPE because of ASUS quirks,
1618 * so do not change boot_ec->gpe to ec->gpe.
1619 */
1620 boot_ec->handle = ec->handle;
Lv Zheng97cb1592016-09-07 16:50:27 +08001621 acpi_handle_debug(ec->handle, "duplicated.\n");
1622 acpi_ec_free(ec);
1623 ec = boot_ec;
1624 ret = acpi_config_boot_ec(ec, ec->handle, true, false);
1625 } else
1626 ret = acpi_ec_setup(ec, true);
Lv Zheng46922d22016-09-07 16:50:14 +08001627 if (ret)
1628 goto err_query;
1629
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 device->driver_data = ec;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001631
Andi Kleend6795fe32012-02-06 08:17:08 -08001632 ret = !!request_region(ec->data_addr, 1, "EC data");
1633 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1634 ret = !!request_region(ec->command_addr, 1, "EC cmd");
1635 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001636
Lan Tianyu1c832b32015-04-01 09:47:18 +08001637 /* Reprobe devices depending on the EC */
1638 acpi_walk_dep_device_list(ec->handle);
Lv Zheng97cb1592016-09-07 16:50:27 +08001639 acpi_handle_debug(ec->handle, "enumerated.\n");
Lv Zheng46922d22016-09-07 16:50:14 +08001640 return 0;
1641
1642err_query:
Lv Zheng97cb1592016-09-07 16:50:27 +08001643 if (ec != boot_ec)
1644 acpi_ec_remove_query_handlers(ec, true, 0);
Lv Zheng46922d22016-09-07 16:50:14 +08001645err_alloc:
Lv Zheng97cb1592016-09-07 16:50:27 +08001646 if (ec != boot_ec)
1647 acpi_ec_free(ec);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001648 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649}
1650
Rafael J. Wysocki51fac832013-01-24 00:24:48 +01001651static int acpi_ec_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001653 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001656 return -EINVAL;
Alexey Starikovskiyf9319f92007-08-24 08:10:11 +04001657
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 ec = acpi_driver_data(device);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001659 release_region(ec->data_addr, 1);
1660 release_region(ec->command_addr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 device->driver_data = NULL;
Lv Zheng97cb1592016-09-07 16:50:27 +08001662 if (ec != boot_ec) {
1663 ec_remove_handlers(ec);
1664 acpi_ec_free(ec);
1665 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001666 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667}
1668
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669static acpi_status
1670ec_parse_io_ports(struct acpi_resource *resource, void *context)
1671{
1672 struct acpi_ec *ec = context;
1673
1674 if (resource->type != ACPI_RESOURCE_TYPE_IO)
1675 return AE_OK;
1676
1677 /*
1678 * The first address region returned is the data port, and
1679 * the second address region returned is the status/command
1680 * port.
1681 */
Thomas Renningerde4f1042010-07-29 22:08:44 +02001682 if (ec->data_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 ec->data_addr = resource->data.io.minimum;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001684 else if (ec->command_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 ec->command_addr = resource->data.io.minimum;
1686 else
1687 return AE_CTRL_TERMINATE;
1688
1689 return AE_OK;
1690}
1691
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001692static const struct acpi_device_id ec_device_ids[] = {
1693 {"PNP0C09", 0},
1694 {"", 0},
1695};
1696
Lv Zhengc712bb52017-06-15 09:41:41 +08001697/*
1698 * This function is not Windows-compatible as Windows never enumerates the
1699 * namespace EC before the main ACPI device enumeration process. It is
1700 * retained for historical reason and will be deprecated in the future.
1701 */
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001702int __init acpi_ec_dsdt_probe(void)
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001703{
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001704 acpi_status status;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001705 struct acpi_ec *ec;
1706 int ret;
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001707
Lv Zhengc712bb52017-06-15 09:41:41 +08001708 /*
1709 * If a platform has ECDT, there is no need to proceed as the
1710 * following probe is not a part of the ACPI device enumeration,
1711 * executing _STA is not safe, and thus this probe may risk of
1712 * picking up an invalid EC device.
1713 */
1714 if (boot_ec)
1715 return -ENODEV;
1716
Lv Zhengfd6231e2016-06-21 17:42:05 +08001717 ec = acpi_ec_alloc();
1718 if (!ec)
1719 return -ENOMEM;
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001720 /*
Lv Zheng2a570842016-09-07 16:50:21 +08001721 * At this point, the namespace is initialized, so start to find
1722 * the namespace objects.
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001723 */
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001724 status = acpi_get_devices(ec_device_ids[0].id,
Lv Zhengfd6231e2016-06-21 17:42:05 +08001725 ec_parse_device, ec, NULL);
1726 if (ACPI_FAILURE(status) || !ec->handle) {
1727 ret = -ENODEV;
1728 goto error;
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001729 }
Lv Zheng2a570842016-09-07 16:50:21 +08001730 /*
1731 * When the DSDT EC is available, always re-configure boot EC to
1732 * have _REG evaluated. _REG can only be evaluated after the
1733 * namespace initialization.
1734 * At this point, the GPE is not fully initialized, so do not to
1735 * handle the events.
1736 */
1737 ret = acpi_config_boot_ec(ec, ec->handle, false, false);
Lv Zhengfd6231e2016-06-21 17:42:05 +08001738error:
1739 if (ret)
Lv Zheng72c77b72016-09-07 16:50:08 +08001740 acpi_ec_free(ec);
Lv Zhengfd6231e2016-06-21 17:42:05 +08001741 return ret;
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001742}
1743
Lv Zheng2a570842016-09-07 16:50:21 +08001744/*
1745 * If the DSDT EC is not functioning, we still need to prepare a fully
1746 * functioning ECDT EC first in order to handle the events.
1747 * https://bugzilla.kernel.org/show_bug.cgi?id=115021
1748 */
Lv Zheng98529b92017-08-16 15:29:49 +08001749static int __init acpi_ec_ecdt_start(void)
Lv Zheng2a570842016-09-07 16:50:21 +08001750{
Lv Zheng2a570842016-09-07 16:50:21 +08001751 acpi_handle handle;
1752
1753 if (!boot_ec)
1754 return -ENODEV;
Lv Zheng69b957c2017-08-17 10:21:12 +08001755 /* In case acpi_ec_ecdt_start() is called after acpi_ec_add() */
Lv Zheng2a570842016-09-07 16:50:21 +08001756 if (!boot_ec_is_ecdt)
1757 return -ENODEV;
1758
Lv Zheng2a570842016-09-07 16:50:21 +08001759 /*
1760 * At this point, the namespace and the GPE is initialized, so
1761 * start to find the namespace objects and handle the events.
Lv Zheng69b957c2017-08-17 10:21:12 +08001762 *
1763 * Note: ec->handle can be valid if this function is called after
1764 * acpi_ec_add(), hence the fast path.
Lv Zheng2a570842016-09-07 16:50:21 +08001765 */
Lv Zheng69b957c2017-08-17 10:21:12 +08001766 if (boot_ec->handle != ACPI_ROOT_OBJECT)
1767 handle = boot_ec->handle;
1768 else if (!acpi_ec_ecdt_get_handle(&handle))
Lv Zheng2a570842016-09-07 16:50:21 +08001769 return -ENODEV;
1770 return acpi_config_boot_ec(boot_ec, handle, true, true);
1771}
1772
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001773#if 0
Feng Tang67bfa9b2012-09-28 15:22:01 +08001774/*
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001775 * Some EC firmware variations refuses to respond QR_EC when SCI_EVT is not
1776 * set, for which case, we complete the QR_EC without issuing it to the
1777 * firmware.
1778 * https://bugzilla.kernel.org/show_bug.cgi?id=82611
1779 * https://bugzilla.kernel.org/show_bug.cgi?id=97381
Lv Zheng79149002014-10-29 11:33:49 +08001780 */
1781static int ec_flag_query_handshake(const struct dmi_system_id *id)
1782{
1783 pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1784 EC_FLAGS_QUERY_HANDSHAKE = 1;
1785 return 0;
1786}
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001787#endif
Lv Zheng79149002014-10-29 11:33:49 +08001788
1789/*
Lv Zhengbc539562016-06-21 17:42:12 +08001790 * Some ECDTs contain wrong register addresses.
1791 * MSI MS-171F
1792 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1793 */
Lv Zheng59f0aa92016-03-24 10:42:53 +08001794static int ec_correct_ecdt(const struct dmi_system_id *id)
1795{
1796 pr_debug("Detected system needing ECDT address correction.\n");
1797 EC_FLAGS_CORRECT_ECDT = 1;
1798 return 0;
1799}
1800
Chris Chiu440f53d2017-06-15 09:41:47 +08001801/*
1802 * Some DSDTs contain wrong GPE setting.
Carlo Caioneef750402017-06-15 09:41:53 +08001803 * Asus FX502VD/VE, GL702VMK, X550VXK, X580VD
Chris Chiu440f53d2017-06-15 09:41:47 +08001804 * https://bugzilla.kernel.org/show_bug.cgi?id=195651
1805 */
1806static int ec_honor_ecdt_gpe(const struct dmi_system_id *id)
1807{
1808 pr_debug("Detected system needing ignore DSDT GPE setting.\n");
1809 EC_FLAGS_IGNORE_DSDT_GPE = 1;
1810 return 0;
1811}
1812
Sachin Kamat6cef7492013-08-07 17:16:55 +05301813static struct dmi_system_id ec_dmi_table[] __initdata = {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001814 {
Lv Zheng59f0aa92016-03-24 10:42:53 +08001815 ec_correct_ecdt, "MSI MS-171F", {
Lv Zheng3174abc2015-05-15 14:37:11 +08001816 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1817 DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
Chris Chiu440f53d2017-06-15 09:41:47 +08001818 {
1819 ec_honor_ecdt_gpe, "ASUS FX502VD", {
1820 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1821 DMI_MATCH(DMI_PRODUCT_NAME, "FX502VD"),}, NULL},
1822 {
1823 ec_honor_ecdt_gpe, "ASUS FX502VE", {
1824 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1825 DMI_MATCH(DMI_PRODUCT_NAME, "FX502VE"),}, NULL},
1826 {
Carlo Caioneef750402017-06-15 09:41:53 +08001827 ec_honor_ecdt_gpe, "ASUS GL702VMK", {
1828 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1829 DMI_MATCH(DMI_PRODUCT_NAME, "GL702VMK"),}, NULL},
1830 {
Chris Chiu440f53d2017-06-15 09:41:47 +08001831 ec_honor_ecdt_gpe, "ASUS X550VXK", {
1832 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1833 DMI_MATCH(DMI_PRODUCT_NAME, "X550VXK"),}, NULL},
1834 {
1835 ec_honor_ecdt_gpe, "ASUS X580VD", {
1836 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1837 DMI_MATCH(DMI_PRODUCT_NAME, "X580VD"),}, NULL},
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001838 {},
1839};
1840
Len Brown50526df2005-08-11 17:32:05 -04001841int __init acpi_ec_ecdt_probe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842{
Lv Zhengfd6231e2016-06-21 17:42:05 +08001843 int ret;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001844 acpi_status status;
1845 struct acpi_table_ecdt *ecdt_ptr;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001846 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
Lv Zhengfd6231e2016-06-21 17:42:05 +08001848 ec = acpi_ec_alloc();
1849 if (!ec)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001850 return -ENOMEM;
1851 /*
1852 * Generate a boot ec context
1853 */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001854 dmi_check_system(ec_dmi_table);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001855 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1856 (struct acpi_table_header **)&ecdt_ptr);
Lv Zheng59f0aa92016-03-24 10:42:53 +08001857 if (ACPI_FAILURE(status)) {
1858 ret = -ENODEV;
1859 goto error;
1860 }
1861
1862 if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1863 /*
1864 * Asus X50GL:
1865 * https://bugzilla.kernel.org/show_bug.cgi?id=11880
1866 */
1867 ret = -ENODEV;
1868 goto error;
1869 }
1870
Lv Zheng59f0aa92016-03-24 10:42:53 +08001871 if (EC_FLAGS_CORRECT_ECDT) {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001872 ec->command_addr = ecdt_ptr->data.address;
1873 ec->data_addr = ecdt_ptr->control.address;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001874 } else {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001875 ec->command_addr = ecdt_ptr->control.address;
1876 ec->data_addr = ecdt_ptr->data.address;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001877 }
Lv Zhengfd6231e2016-06-21 17:42:05 +08001878 ec->gpe = ecdt_ptr->gpe;
Lv Zheng2a570842016-09-07 16:50:21 +08001879
1880 /*
1881 * At this point, the namespace is not initialized, so do not find
1882 * the namespace objects, or handle the events.
1883 */
1884 ret = acpi_config_boot_ec(ec, ACPI_ROOT_OBJECT, false, true);
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001885error:
Lv Zhengfd6231e2016-06-21 17:42:05 +08001886 if (ret)
Lv Zheng72c77b72016-09-07 16:50:08 +08001887 acpi_ec_free(ec);
Lv Zheng59f0aa92016-03-24 10:42:53 +08001888 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889}
1890
Lv Zhengdf45db62016-08-03 09:07:58 +08001891#ifdef CONFIG_PM_SLEEP
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001892static int acpi_ec_suspend(struct device *dev)
1893{
1894 struct acpi_ec *ec =
1895 acpi_driver_data(to_acpi_device(dev));
1896
Rafael J. Wysocki8110dd282017-06-23 15:24:32 +02001897 if (acpi_sleep_no_ec_events() && ec_freeze_events)
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001898 acpi_ec_disable_event(ec);
1899 return 0;
1900}
1901
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001902static int acpi_ec_suspend_noirq(struct device *dev)
1903{
1904 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1905
1906 /*
1907 * The SCI handler doesn't run at this point, so the GPE can be
1908 * masked at the low level without side effects.
1909 */
1910 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1911 ec->reference_count >= 1)
1912 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1913
1914 return 0;
1915}
1916
1917static int acpi_ec_resume_noirq(struct device *dev)
1918{
1919 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1920
1921 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1922 ec->reference_count >= 1)
1923 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
1924
1925 return 0;
1926}
1927
Lv Zhengc2b46d62016-08-03 16:01:36 +08001928static int acpi_ec_resume(struct device *dev)
1929{
1930 struct acpi_ec *ec =
1931 acpi_driver_data(to_acpi_device(dev));
1932
1933 acpi_ec_enable_event(ec);
1934 return 0;
1935}
Lv Zhengdf45db62016-08-03 09:07:58 +08001936#endif
1937
1938static const struct dev_pm_ops acpi_ec_pm = {
Rafael J. Wysocki76380632017-07-19 14:41:58 +02001939 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001940 SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
Lv Zhengdf45db62016-08-03 09:07:58 +08001941};
1942
Lv Zheng1d68d262015-06-11 13:21:38 +08001943static int param_set_event_clearing(const char *val, struct kernel_param *kp)
1944{
1945 int result = 0;
1946
1947 if (!strncmp(val, "status", sizeof("status") - 1)) {
1948 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1949 pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
1950 } else if (!strncmp(val, "query", sizeof("query") - 1)) {
1951 ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
1952 pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
1953 } else if (!strncmp(val, "event", sizeof("event") - 1)) {
1954 ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
1955 pr_info("Assuming SCI_EVT clearing on event reads\n");
1956 } else
1957 result = -EINVAL;
1958 return result;
1959}
1960
1961static int param_get_event_clearing(char *buffer, struct kernel_param *kp)
1962{
1963 switch (ec_event_clearing) {
1964 case ACPI_EC_EVT_TIMING_STATUS:
1965 return sprintf(buffer, "status");
1966 case ACPI_EC_EVT_TIMING_QUERY:
1967 return sprintf(buffer, "query");
1968 case ACPI_EC_EVT_TIMING_EVENT:
1969 return sprintf(buffer, "event");
1970 default:
1971 return sprintf(buffer, "invalid");
1972 }
1973 return 0;
1974}
1975
1976module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
1977 NULL, 0644);
1978MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
1979
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001980static struct acpi_driver acpi_ec_driver = {
1981 .name = "ec",
1982 .class = ACPI_EC_CLASS,
1983 .ids = ec_device_ids,
1984 .ops = {
1985 .add = acpi_ec_add,
1986 .remove = acpi_ec_remove,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001987 },
Lv Zhengdf45db62016-08-03 09:07:58 +08001988 .drv.pm = &acpi_ec_pm,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001989};
1990
Lv Zhenge1191bd2016-08-03 09:00:14 +08001991static inline int acpi_ec_query_init(void)
1992{
1993 if (!ec_query_wq) {
1994 ec_query_wq = alloc_workqueue("kec_query", 0,
1995 ec_max_queries);
1996 if (!ec_query_wq)
1997 return -ENODEV;
1998 }
1999 return 0;
2000}
2001
2002static inline void acpi_ec_query_exit(void)
2003{
2004 if (ec_query_wq) {
2005 destroy_workqueue(ec_query_wq);
2006 ec_query_wq = NULL;
2007 }
2008}
2009
Bjorn Helgaasa5f820f2009-03-24 16:49:48 -06002010int __init acpi_ec_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011{
Lv Zhenge1191bd2016-08-03 09:00:14 +08002012 int result;
Lv Zheng98529b92017-08-16 15:29:49 +08002013 int ecdt_fail, dsdt_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014
Lv Zhenge1191bd2016-08-03 09:00:14 +08002015 /* register workqueue for _Qxx evaluations */
2016 result = acpi_ec_query_init();
2017 if (result)
Lv Zheng98529b92017-08-16 15:29:49 +08002018 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019
Lv Zheng98529b92017-08-16 15:29:49 +08002020 /* Drivers must be started after acpi_ec_query_init() */
Lv Zheng98529b92017-08-16 15:29:49 +08002021 dsdt_fail = acpi_bus_register_driver(&acpi_ec_driver);
Lv Zheng69b957c2017-08-17 10:21:12 +08002022 ecdt_fail = acpi_ec_ecdt_start();
Lv Zheng98529b92017-08-16 15:29:49 +08002023 return ecdt_fail && dsdt_fail ? -ENODEV : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024}
2025
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026/* EC driver currently not unloadable */
2027#if 0
Len Brown50526df2005-08-11 17:32:05 -04002028static void __exit acpi_ec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030
2031 acpi_bus_unregister_driver(&acpi_ec_driver);
Lv Zhenge1191bd2016-08-03 09:00:14 +08002032 acpi_ec_query_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033}
Alexey Starikovskiy78439322007-10-22 14:18:43 +04002034#endif /* 0 */