blob: b4fd026c8229c847e1a74c6507804dbfc84e8dfc [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 */
Lan Tianyu16a26e82013-09-12 03:32:04 -040030#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 Zheng750f628b2016-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 Zhengd30283052016-08-03 16:01:50 +0800150static bool ec_freeze_events __read_mostly = true;
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
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400154struct acpi_ec_query_handler {
155 struct list_head node;
156 acpi_ec_query_func func;
157 acpi_handle handle;
158 void *data;
159 u8 query_bit;
Lv Zheng01305d42015-01-14 19:28:28 +0800160 struct kref kref;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400161};
162
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400163struct transaction {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400164 const u8 *wdata;
165 u8 *rdata;
166 unsigned short irq_count;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400167 u8 command;
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300168 u8 wi;
169 u8 ri;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400170 u8 wlen;
171 u8 rlen;
Lv Zhengf92fca02014-06-15 08:41:35 +0800172 u8 flags;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400173};
174
Lv Zheng02b771b2015-08-12 11:12:02 +0800175struct acpi_ec_query {
176 struct transaction transaction;
177 struct work_struct work;
178 struct acpi_ec_query_handler *handler;
179};
180
Lv Zheng550b3aac2015-01-14 19:28:53 +0800181static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800182static void advance_transaction(struct acpi_ec *ec);
Lv Zheng02b771b2015-08-12 11:12:02 +0800183static void acpi_ec_event_handler(struct work_struct *work);
184static void acpi_ec_event_processor(struct work_struct *work);
Lv Zheng74443bb2015-01-14 19:28:47 +0800185
Thomas Renninger1195a092010-07-16 13:11:31 +0200186struct acpi_ec *boot_ec, *first_ec;
187EXPORT_SYMBOL(first_ec);
Lv Zheng72c77b72016-09-07 16:50:08 +0800188static bool boot_ec_is_ecdt = false;
Lv Zhenge1191bd2016-08-03 09:00:14 +0800189static struct workqueue_struct *ec_query_wq;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400190
Lv Zheng79149002014-10-29 11:33:49 +0800191static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
Lv Zheng59f0aa92016-03-24 10:42:53 +0800192static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194/* --------------------------------------------------------------------------
Lv Zheng3535a3c2015-02-27 14:48:15 +0800195 * Logging/Debugging
196 * -------------------------------------------------------------------------- */
197
198/*
199 * Splitters used by the developers to track the boundary of the EC
200 * handling processes.
201 */
202#ifdef DEBUG
203#define EC_DBG_SEP " "
204#define EC_DBG_DRV "+++++"
205#define EC_DBG_STM "====="
206#define EC_DBG_REQ "*****"
207#define EC_DBG_EVT "#####"
208#else
209#define EC_DBG_SEP ""
210#define EC_DBG_DRV
211#define EC_DBG_STM
212#define EC_DBG_REQ
213#define EC_DBG_EVT
214#endif
215
216#define ec_log_raw(fmt, ...) \
217 pr_info(fmt "\n", ##__VA_ARGS__)
218#define ec_dbg_raw(fmt, ...) \
219 pr_debug(fmt "\n", ##__VA_ARGS__)
220#define ec_log(filter, fmt, ...) \
221 ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
222#define ec_dbg(filter, fmt, ...) \
223 ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
224
225#define ec_log_drv(fmt, ...) \
226 ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
227#define ec_dbg_drv(fmt, ...) \
228 ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
229#define ec_dbg_stm(fmt, ...) \
230 ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
231#define ec_dbg_req(fmt, ...) \
232 ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
233#define ec_dbg_evt(fmt, ...) \
234 ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
Lv Zheng770970f2015-02-27 14:48:24 +0800235#define ec_dbg_ref(ec, fmt, ...) \
236 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
Lv Zheng3535a3c2015-02-27 14:48:15 +0800237
238/* --------------------------------------------------------------------------
Lv Zhengad479e72015-02-06 08:57:52 +0800239 * Device Flags
240 * -------------------------------------------------------------------------- */
241
242static bool acpi_ec_started(struct acpi_ec *ec)
243{
244 return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
245 !test_bit(EC_FLAGS_STOPPED, &ec->flags);
246}
247
Lv Zheng750f628b2016-08-03 16:01:24 +0800248static bool acpi_ec_event_enabled(struct acpi_ec *ec)
249{
250 /*
251 * There is an OSPM early stage logic. During the early stages
252 * (boot/resume), OSPMs shouldn't enable the event handling, only
253 * the EC transactions are allowed to be performed.
254 */
255 if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
256 return false;
257 /*
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800258 * However, disabling the event handling is experimental for late
259 * stage (suspend), and is controlled by the boot parameter of
260 * "ec_freeze_events":
261 * 1. true: The EC event handling is disabled before entering
262 * the noirq stage.
263 * 2. false: The EC event handling is automatically disabled as
264 * soon as the EC driver is stopped.
Lv Zheng750f628b2016-08-03 16:01:24 +0800265 */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800266 if (ec_freeze_events)
267 return acpi_ec_started(ec);
268 else
269 return test_bit(EC_FLAGS_STARTED, &ec->flags);
Lv Zheng750f628b2016-08-03 16:01:24 +0800270}
271
Lv Zheng9887d222015-02-06 08:57:59 +0800272static bool acpi_ec_flushed(struct acpi_ec *ec)
273{
274 return ec->reference_count == 1;
275}
276
Lv Zhengad479e72015-02-06 08:57:52 +0800277/* --------------------------------------------------------------------------
Lv Zhengca37bfd2015-02-05 16:27:22 +0800278 * EC Registers
Lv Zheng7a73e602014-10-14 14:24:01 +0800279 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400281static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300283 u8 x = inb(ec->command_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800284
Lv Zheng3535a3c2015-02-27 14:48:15 +0800285 ec_dbg_raw("EC_SC(R) = 0x%2.2x "
286 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
287 x,
288 !!(x & ACPI_EC_FLAG_SCI),
289 !!(x & ACPI_EC_FLAG_BURST),
290 !!(x & ACPI_EC_FLAG_CMD),
291 !!(x & ACPI_EC_FLAG_IBF),
292 !!(x & ACPI_EC_FLAG_OBF));
Márton Németh3ebe08a2007-11-21 03:23:26 +0300293 return x;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400296static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400297{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300298 u8 x = inb(ec->data_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800299
Lv Zhengd8d031a2015-05-15 14:16:42 +0800300 ec->timestamp = jiffies;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800301 ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400302 return x;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400303}
304
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400305static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400306{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800307 ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400308 outb(command, ec->command_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800309 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400310}
311
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400312static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400313{
Lv Zheng3535a3c2015-02-27 14:48:15 +0800314 ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400315 outb(data, ec->data_addr);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800316 ec->timestamp = jiffies;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400317}
318
Lv Zheng4625d752017-06-14 13:59:18 +0800319#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
Lv Zhenge34c0e22014-10-14 14:23:49 +0800320static const char *acpi_ec_cmd_string(u8 cmd)
321{
322 switch (cmd) {
323 case 0x80:
324 return "RD_EC";
325 case 0x81:
326 return "WR_EC";
327 case 0x82:
328 return "BE_EC";
329 case 0x83:
330 return "BD_EC";
331 case 0x84:
332 return "QR_EC";
333 }
334 return "UNKNOWN";
335}
336#else
337#define acpi_ec_cmd_string(cmd) "UNDEF"
338#endif
339
Lv Zhengca37bfd2015-02-05 16:27:22 +0800340/* --------------------------------------------------------------------------
341 * GPE Registers
342 * -------------------------------------------------------------------------- */
343
344static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
345{
346 acpi_event_status gpe_status = 0;
347
348 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
Lv Zheng7c0b2592015-05-15 14:16:17 +0800349 return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
Lv Zhengca37bfd2015-02-05 16:27:22 +0800350}
351
352static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
353{
354 if (open)
355 acpi_enable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800356 else {
357 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800358 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800359 }
Lv Zhengca37bfd2015-02-05 16:27:22 +0800360 if (acpi_ec_is_gpe_raised(ec)) {
361 /*
362 * On some platforms, EN=1 writes cannot trigger GPE. So
363 * software need to manually trigger a pseudo GPE event on
364 * EN=1 writes.
365 */
Lv Zheng3535a3c2015-02-27 14:48:15 +0800366 ec_dbg_raw("Polling quirk");
Lv Zhengca37bfd2015-02-05 16:27:22 +0800367 advance_transaction(ec);
368 }
369}
370
371static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
372{
373 if (close)
374 acpi_disable_gpe(NULL, ec->gpe);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800375 else {
376 BUG_ON(ec->reference_count < 1);
Lv Zhengca37bfd2015-02-05 16:27:22 +0800377 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800378 }
Lv Zhengca37bfd2015-02-05 16:27:22 +0800379}
380
381static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
382{
383 /*
384 * GPE STS is a W1C register, which means:
385 * 1. Software can clear it without worrying about clearing other
386 * GPEs' STS bits when the hardware sets them in parallel.
387 * 2. As long as software can ensure only clearing it when it is
388 * set, hardware won't set it in parallel.
389 * So software can clear GPE in any contexts.
390 * Warning: do not move the check into advance_transaction() as the
391 * EC commands will be sent without GPE raised.
392 */
393 if (!acpi_ec_is_gpe_raised(ec))
394 return;
395 acpi_clear_gpe(NULL, ec->gpe);
396}
397
398/* --------------------------------------------------------------------------
399 * Transaction Management
400 * -------------------------------------------------------------------------- */
401
Lv Zheng9887d222015-02-06 08:57:59 +0800402static void acpi_ec_submit_request(struct acpi_ec *ec)
403{
404 ec->reference_count++;
Lv Zheng0e1affe2016-03-24 10:42:47 +0800405 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
406 ec->reference_count == 1)
Lv Zheng9887d222015-02-06 08:57:59 +0800407 acpi_ec_enable_gpe(ec, true);
408}
409
410static void acpi_ec_complete_request(struct acpi_ec *ec)
411{
412 bool flushed = false;
413
414 ec->reference_count--;
Lv Zheng0e1affe2016-03-24 10:42:47 +0800415 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
416 ec->reference_count == 0)
Lv Zheng9887d222015-02-06 08:57:59 +0800417 acpi_ec_disable_gpe(ec, true);
418 flushed = acpi_ec_flushed(ec);
419 if (flushed)
420 wake_up(&ec->wait);
421}
422
Lv Zhenge1d4d902015-02-06 08:58:05 +0800423static void acpi_ec_set_storm(struct acpi_ec *ec, u8 flag)
424{
425 if (!test_bit(flag, &ec->flags)) {
426 acpi_ec_disable_gpe(ec, false);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800427 ec_dbg_drv("Polling enabled");
Lv Zhenge1d4d902015-02-06 08:58:05 +0800428 set_bit(flag, &ec->flags);
429 }
430}
431
432static void acpi_ec_clear_storm(struct acpi_ec *ec, u8 flag)
433{
434 if (test_bit(flag, &ec->flags)) {
435 clear_bit(flag, &ec->flags);
436 acpi_ec_enable_gpe(ec, false);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800437 ec_dbg_drv("Polling disabled");
Lv Zhenge1d4d902015-02-06 08:58:05 +0800438 }
439}
440
Lv Zheng9887d222015-02-06 08:57:59 +0800441/*
442 * acpi_ec_submit_flushable_request() - Increase the reference count unless
443 * the flush operation is not in
444 * progress
445 * @ec: the EC device
446 *
447 * This function must be used before taking a new action that should hold
448 * the reference count. If this function returns false, then the action
449 * must be discarded or it will prevent the flush operation from being
450 * completed.
451 */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100452static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
Lv Zheng9887d222015-02-06 08:57:59 +0800453{
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100454 if (!acpi_ec_started(ec))
455 return false;
Lv Zheng9887d222015-02-06 08:57:59 +0800456 acpi_ec_submit_request(ec);
457 return true;
458}
459
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100460static void acpi_ec_submit_query(struct acpi_ec *ec)
Lv Zheng74443bb2015-01-14 19:28:47 +0800461{
Lv Zheng1ab69f22017-06-14 13:59:09 +0800462 acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM);
463 if (!acpi_ec_event_enabled(ec))
464 return;
465 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
Lv Zheng9d8993b2015-06-11 13:21:32 +0800466 ec_dbg_evt("Command(%s) submitted/blocked",
467 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
468 ec->nr_pending_queries++;
Lv Zheng74443bb2015-01-14 19:28:47 +0800469 schedule_work(&ec->work);
Lv Zhengf252cb02015-02-06 08:58:10 +0800470 }
Lv Zhengf252cb02015-02-06 08:58:10 +0800471}
472
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100473static void acpi_ec_complete_query(struct acpi_ec *ec)
Lv Zhengf252cb02015-02-06 08:58:10 +0800474{
Lv Zheng1ab69f22017-06-14 13:59:09 +0800475 if (test_and_clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
Lv Zheng9d8993b2015-06-11 13:21:32 +0800476 ec_dbg_evt("Command(%s) unblocked",
477 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zheng1ab69f22017-06-14 13:59:09 +0800478 acpi_ec_clear_storm(ec, EC_FLAGS_COMMAND_STORM);
Lv Zheng74443bb2015-01-14 19:28:47 +0800479}
480
Lv Zheng750f628b2016-08-03 16:01:24 +0800481static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
482{
483 if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
484 ec_log_drv("event unblocked");
Lv Zhenge923e8e2016-08-03 16:01:30 +0800485 if (!test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
486 advance_transaction(ec);
Lv Zheng750f628b2016-08-03 16:01:24 +0800487}
488
489static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
490{
491 if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
492 ec_log_drv("event blocked");
493}
494
Lv Zheng750f628b2016-08-03 16:01:24 +0800495static void acpi_ec_enable_event(struct acpi_ec *ec)
496{
497 unsigned long flags;
498
499 spin_lock_irqsave(&ec->lock, flags);
500 if (acpi_ec_started(ec))
501 __acpi_ec_enable_event(ec);
502 spin_unlock_irqrestore(&ec->lock, flags);
Lv Zheng750f628b2016-08-03 16:01:24 +0800503}
504
Eric Biggerseab05ec2016-10-05 10:33:16 -0700505#ifdef CONFIG_PM_SLEEP
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800506static bool acpi_ec_query_flushed(struct acpi_ec *ec)
507{
508 bool flushed;
509 unsigned long flags;
510
511 spin_lock_irqsave(&ec->lock, flags);
512 flushed = !ec->nr_pending_queries;
513 spin_unlock_irqrestore(&ec->lock, flags);
514 return flushed;
515}
516
517static void __acpi_ec_flush_event(struct acpi_ec *ec)
518{
519 /*
520 * When ec_freeze_events is true, we need to flush events in
521 * the proper position before entering the noirq stage.
522 */
523 wait_event(ec->wait, acpi_ec_query_flushed(ec));
524 if (ec_query_wq)
525 flush_workqueue(ec_query_wq);
526}
527
528static void acpi_ec_disable_event(struct acpi_ec *ec)
529{
530 unsigned long flags;
531
532 spin_lock_irqsave(&ec->lock, flags);
533 __acpi_ec_disable_event(ec);
534 spin_unlock_irqrestore(&ec->lock, flags);
535 __acpi_ec_flush_event(ec);
536}
Eric Biggerseab05ec2016-10-05 10:33:16 -0700537#endif /* CONFIG_PM_SLEEP */
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800538
Lv Zheng1d68d262015-06-11 13:21:38 +0800539static bool acpi_ec_guard_event(struct acpi_ec *ec)
540{
Lv Zheng61197542015-09-24 14:54:54 +0800541 bool guarded = true;
542 unsigned long flags;
543
544 spin_lock_irqsave(&ec->lock, flags);
545 /*
546 * If firmware SCI_EVT clearing timing is "event", we actually
547 * don't know when the SCI_EVT will be cleared by firmware after
548 * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
549 * acceptable period.
550 *
551 * The guarding period begins when EC_FLAGS_QUERY_PENDING is
552 * flagged, which means SCI_EVT check has just been performed.
553 * But if the current transaction is ACPI_EC_COMMAND_QUERY, the
554 * guarding should have already been performed (via
555 * EC_FLAGS_QUERY_GUARDING) and should not be applied so that the
556 * ACPI_EC_COMMAND_QUERY transaction can be transitioned into
557 * ACPI_EC_COMMAND_POLL state immediately.
558 */
Lv Zheng1d68d262015-06-11 13:21:38 +0800559 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
560 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY ||
561 !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
562 (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
Lv Zheng61197542015-09-24 14:54:54 +0800563 guarded = false;
564 spin_unlock_irqrestore(&ec->lock, flags);
565 return guarded;
Lv Zheng1d68d262015-06-11 13:21:38 +0800566}
567
Lv Zhengd8d031a2015-05-15 14:16:42 +0800568static int ec_transaction_polled(struct acpi_ec *ec)
569{
570 unsigned long flags;
571 int ret = 0;
572
573 spin_lock_irqsave(&ec->lock, flags);
574 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
575 ret = 1;
576 spin_unlock_irqrestore(&ec->lock, flags);
577 return ret;
578}
579
Lv Zhengf92fca02014-06-15 08:41:35 +0800580static int ec_transaction_completed(struct acpi_ec *ec)
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400581{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400582 unsigned long flags;
583 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800584
Feng Tangf351d022012-10-23 01:29:27 +0200585 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengc0d65342014-06-15 08:42:07 +0800586 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400587 ret = 1;
Feng Tangf351d022012-10-23 01:29:27 +0200588 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400589 return ret;
590}
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400591
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800592static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
593{
594 ec->curr->flags |= flag;
595 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
Lv Zheng1d68d262015-06-11 13:21:38 +0800596 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS &&
597 flag == ACPI_EC_COMMAND_POLL)
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800598 acpi_ec_complete_query(ec);
Lv Zheng1d68d262015-06-11 13:21:38 +0800599 if (ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY &&
600 flag == ACPI_EC_COMMAND_COMPLETE)
601 acpi_ec_complete_query(ec);
602 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
603 flag == ACPI_EC_COMMAND_COMPLETE)
604 set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800605 }
606}
607
Lv Zheng0c788082015-01-14 19:28:22 +0800608static void advance_transaction(struct acpi_ec *ec)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400609{
Puneet Kumar36b15872013-11-15 11:41:29 -0800610 struct transaction *t;
Lv Zheng66b42b72014-06-15 08:41:17 +0800611 u8 status;
Lv Zhengc0d65342014-06-15 08:42:07 +0800612 bool wakeup = false;
Feng Tangb76b51b2012-10-23 01:29:38 +0200613
Lv Zheng3535a3c2015-02-27 14:48:15 +0800614 ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
615 smp_processor_id());
Lv Zhengca37bfd2015-02-05 16:27:22 +0800616 /*
617 * By always clearing STS before handling all indications, we can
618 * ensure a hardware STS 0->1 change after this clearing can always
619 * trigger a GPE interrupt.
620 */
621 acpi_ec_clear_gpe(ec);
Lv Zheng66b42b72014-06-15 08:41:17 +0800622 status = acpi_ec_read_status(ec);
Puneet Kumar36b15872013-11-15 11:41:29 -0800623 t = ec->curr;
Lv Zheng1d68d262015-06-11 13:21:38 +0800624 /*
625 * Another IRQ or a guarded polling mode advancement is detected,
626 * the next QR_EC submission is then allowed.
627 */
628 if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
629 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
Lv Zheng66db3832015-06-11 13:21:51 +0800630 (!ec->nr_pending_queries ||
631 test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
Lv Zheng1d68d262015-06-11 13:21:38 +0800632 clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
633 acpi_ec_complete_query(ec);
634 }
635 }
Feng Tangb76b51b2012-10-23 01:29:38 +0200636 if (!t)
Lv Zhengf92fca02014-06-15 08:41:35 +0800637 goto err;
638 if (t->flags & ACPI_EC_COMMAND_POLL) {
639 if (t->wlen > t->wi) {
640 if ((status & ACPI_EC_FLAG_IBF) == 0)
641 acpi_ec_write_data(ec, t->wdata[t->wi++]);
642 else
643 goto err;
644 } else if (t->rlen > t->ri) {
645 if ((status & ACPI_EC_FLAG_OBF) == 1) {
646 t->rdata[t->ri++] = acpi_ec_read_data(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +0800647 if (t->rlen == t->ri) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800648 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800649 if (t->command == ACPI_EC_COMMAND_QUERY)
Lv Zheng9d8993b2015-06-11 13:21:32 +0800650 ec_dbg_evt("Command(%s) completed by hardware",
651 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zhengc0d65342014-06-15 08:42:07 +0800652 wakeup = true;
653 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800654 } else
655 goto err;
656 } else if (t->wlen == t->wi &&
Lv Zhengc0d65342014-06-15 08:42:07 +0800657 (status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800658 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zhengc0d65342014-06-15 08:42:07 +0800659 wakeup = true;
660 }
Lv Zheng0c788082015-01-14 19:28:22 +0800661 goto out;
Lv Zhengf92fca02014-06-15 08:41:35 +0800662 } else {
Lv Zheng79149002014-10-29 11:33:49 +0800663 if (EC_FLAGS_QUERY_HANDSHAKE &&
664 !(status & ACPI_EC_FLAG_SCI) &&
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800665 (t->command == ACPI_EC_COMMAND_QUERY)) {
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800666 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800667 t->rdata[t->ri++] = 0x00;
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800668 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
Lv Zheng9d8993b2015-06-11 13:21:32 +0800669 ec_dbg_evt("Command(%s) completed by software",
670 acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800671 wakeup = true;
672 } else if ((status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf92fca02014-06-15 08:41:35 +0800673 acpi_ec_write_cmd(ec, t->command);
Lv Zhengf8b8eb72015-06-11 13:21:23 +0800674 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400675 } else
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300676 goto err;
Lv Zheng0c788082015-01-14 19:28:22 +0800677 goto out;
Lv Zhengf92fca02014-06-15 08:41:35 +0800678 }
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300679err:
Feng Tanga3cd8d22012-10-23 01:30:12 +0200680 /*
681 * If SCI bit is set, then don't think it's a false IRQ
682 * otherwise will take a not handled IRQ as a false one.
683 */
Lv Zhengf92fca02014-06-15 08:41:35 +0800684 if (!(status & ACPI_EC_FLAG_SCI)) {
Lv Zhenge1d4d902015-02-06 08:58:05 +0800685 if (in_interrupt() && t) {
686 if (t->irq_count < ec_storm_threshold)
687 ++t->irq_count;
688 /* Allow triggering on 0 threshold */
689 if (t->irq_count == ec_storm_threshold)
690 acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM);
691 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800692 }
Lv Zheng0c788082015-01-14 19:28:22 +0800693out:
Lv Zheng74443bb2015-01-14 19:28:47 +0800694 if (status & ACPI_EC_FLAG_SCI)
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100695 acpi_ec_submit_query(ec);
Lv Zheng0c788082015-01-14 19:28:22 +0800696 if (wakeup && in_interrupt())
697 wake_up(&ec->wait);
Lv Zhengf92fca02014-06-15 08:41:35 +0800698}
Feng Tanga3cd8d22012-10-23 01:30:12 +0200699
Lv Zhengf92fca02014-06-15 08:41:35 +0800700static void start_transaction(struct acpi_ec *ec)
701{
702 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
703 ec->curr->flags = 0;
Lv Zhengd8d031a2015-05-15 14:16:42 +0800704}
705
706static int ec_guard(struct acpi_ec *ec)
707{
Lv Zhengc3a696b2017-01-20 16:42:48 +0800708 unsigned long guard = usecs_to_jiffies(ec->polling_guard);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800709 unsigned long timeout = ec->timestamp + guard;
710
Lv Zheng61197542015-09-24 14:54:54 +0800711 /* Ensure guarding period before polling EC status */
Lv Zhengd8d031a2015-05-15 14:16:42 +0800712 do {
Lv Zhengc3a696b2017-01-20 16:42:48 +0800713 if (ec->busy_polling) {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800714 /* Perform busy polling */
715 if (ec_transaction_completed(ec))
716 return 0;
717 udelay(jiffies_to_usecs(guard));
718 } else {
719 /*
720 * Perform wait polling
Lv Zheng61197542015-09-24 14:54:54 +0800721 * 1. Wait the transaction to be completed by the
722 * GPE handler after the transaction enters
723 * ACPI_EC_COMMAND_POLL state.
724 * 2. A special guarding logic is also required
725 * for event clearing mode "event" before the
726 * transaction enters ACPI_EC_COMMAND_POLL
727 * state.
Lv Zhengd8d031a2015-05-15 14:16:42 +0800728 */
Lv Zheng1d68d262015-06-11 13:21:38 +0800729 if (!ec_transaction_polled(ec) &&
730 !acpi_ec_guard_event(ec))
Lv Zhengd8d031a2015-05-15 14:16:42 +0800731 break;
732 if (wait_event_timeout(ec->wait,
733 ec_transaction_completed(ec),
734 guard))
735 return 0;
736 }
Lv Zhengd8d031a2015-05-15 14:16:42 +0800737 } while (time_before(jiffies, timeout));
738 return -ETIME;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400739}
740
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400741static int ec_poll(struct acpi_ec *ec)
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300742{
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400743 unsigned long flags;
Lan Tianyu28fe5c82013-05-06 03:23:40 +0000744 int repeat = 5; /* number of command restarts */
Lv Zheng7a73e602014-10-14 14:24:01 +0800745
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400746 while (repeat--) {
747 unsigned long delay = jiffies +
Thomas Renninger7a18e962010-10-21 18:24:57 +0200748 msecs_to_jiffies(ec_delay);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400749 do {
Lv Zhengd8d031a2015-05-15 14:16:42 +0800750 if (!ec_guard(ec))
751 return 0;
Lv Zhengf92fca02014-06-15 08:41:35 +0800752 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800753 advance_transaction(ec);
Lv Zhengf92fca02014-06-15 08:41:35 +0800754 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400755 } while (time_before(jiffies, delay));
Lan Tianyu16a26e82013-09-12 03:32:04 -0400756 pr_debug("controller reset, restart transaction\n");
Feng Tangf351d022012-10-23 01:29:27 +0200757 spin_lock_irqsave(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400758 start_transaction(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200759 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiyaf3fd142006-12-07 18:42:16 +0300760 }
Alexey Starikovskiyb77d81b2008-03-21 17:07:15 +0300761 return -ETIME;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500762}
763
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400764static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400765 struct transaction *t)
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400766{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400767 unsigned long tmp;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400768 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800769
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400770 /* start transaction */
Feng Tangf351d022012-10-23 01:29:27 +0200771 spin_lock_irqsave(&ec->lock, tmp);
Lv Zheng9887d222015-02-06 08:57:59 +0800772 /* Enable GPE for command processing (IBF=0/OBF=1) */
Rafael J. Wysocki37d11392015-02-11 17:35:05 +0100773 if (!acpi_ec_submit_flushable_request(ec)) {
Lv Zhengad479e72015-02-06 08:57:52 +0800774 ret = -EINVAL;
775 goto unlock;
776 }
Lv Zheng770970f2015-02-27 14:48:24 +0800777 ec_dbg_ref(ec, "Increase command");
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400778 /* following two actions should be kept atomic */
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400779 ec->curr = t;
Lv Zheng3535a3c2015-02-27 14:48:15 +0800780 ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300781 start_transaction(ec);
Lv Zhengdf9ff912014-10-29 11:33:43 +0800782 spin_unlock_irqrestore(&ec->lock, tmp);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800783
Lv Zhengdf9ff912014-10-29 11:33:43 +0800784 ret = ec_poll(ec);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800785
Lv Zhengdf9ff912014-10-29 11:33:43 +0800786 spin_lock_irqsave(&ec->lock, tmp);
Lv Zhenge1d4d902015-02-06 08:58:05 +0800787 if (t->irq_count == ec_storm_threshold)
788 acpi_ec_clear_storm(ec, EC_FLAGS_COMMAND_STORM);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800789 ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400790 ec->curr = NULL;
Lv Zheng9887d222015-02-06 08:57:59 +0800791 /* Disable GPE for command processing (IBF=0/OBF=1) */
792 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800793 ec_dbg_ref(ec, "Decrease command");
Lv Zhengad479e72015-02-06 08:57:52 +0800794unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200795 spin_unlock_irqrestore(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400796 return ret;
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400797}
798
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400799static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
Luming Yu45bea152005-07-23 04:08:00 -0400800{
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400801 int status;
Len Brown50526df2005-08-11 17:32:05 -0400802 u32 glk;
Lv Zheng7a73e602014-10-14 14:24:01 +0800803
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400804 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
Patrick Mocheld550d982006-06-27 00:41:40 -0400805 return -EINVAL;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400806 if (t->rdata)
807 memset(t->rdata, 0, t->rlen);
Lv Zhengd8d031a2015-05-15 14:16:42 +0800808
Feng Tangf351d022012-10-23 01:29:27 +0200809 mutex_lock(&ec->mutex);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400810 if (ec->global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300812 if (ACPI_FAILURE(status)) {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400813 status = -ENODEV;
814 goto unlock;
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300815 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 }
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300817
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400818 status = acpi_ec_transaction_unlocked(ec, t);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300819
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400820 if (ec->global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 acpi_release_global_lock(glk);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400822unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200823 mutex_unlock(&ec->mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400824 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
826
Roel Kluin8a383ef2008-12-09 20:45:30 +0100827static int acpi_ec_burst_enable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300828{
829 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400830 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
831 .wdata = NULL, .rdata = &d,
832 .wlen = 0, .rlen = 1};
833
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400834 return acpi_ec_transaction(ec, &t);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300835}
836
Roel Kluin8a383ef2008-12-09 20:45:30 +0100837static int acpi_ec_burst_disable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300838{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400839 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
840 .wdata = NULL, .rdata = NULL,
841 .wlen = 0, .rlen = 0};
842
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400843 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400844 acpi_ec_transaction(ec, &t) : 0;
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300845}
846
Lv Zheng7a73e602014-10-14 14:24:01 +0800847static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400848{
849 int result;
850 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400851 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
852 .wdata = &address, .rdata = &d,
853 .wlen = 1, .rlen = 1};
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400854
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400855 result = acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400856 *data = d;
857 return result;
858}
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400859
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400860static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
861{
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300862 u8 wdata[2] = { address, data };
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400863 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
864 .wdata = wdata, .rdata = NULL,
865 .wlen = 2, .rlen = 0};
866
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400867 return acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400868}
869
Feng Tangb76b51b2012-10-23 01:29:38 +0200870int ec_read(u8 addr, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 int err;
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400873 u8 temp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
875 if (!first_ec)
876 return -ENODEV;
877
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300878 err = acpi_ec_read(first_ec, addr, &temp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
880 if (!err) {
881 *val = temp_data;
882 return 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800883 }
884 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885}
886EXPORT_SYMBOL(ec_read);
887
Len Brown50526df2005-08-11 17:32:05 -0400888int ec_write(u8 addr, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 int err;
891
892 if (!first_ec)
893 return -ENODEV;
894
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300895 err = acpi_ec_write(first_ec, addr, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
897 return err;
898}
899EXPORT_SYMBOL(ec_write);
900
Randy Dunlap616362d2006-10-27 01:47:34 -0400901int ec_transaction(u8 command,
Lv Zheng7a73e602014-10-14 14:24:01 +0800902 const u8 *wdata, unsigned wdata_len,
903 u8 *rdata, unsigned rdata_len)
Luming Yu45bea152005-07-23 04:08:00 -0400904{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400905 struct transaction t = {.command = command,
906 .wdata = wdata, .rdata = rdata,
907 .wlen = wdata_len, .rlen = rdata_len};
Lv Zheng7a73e602014-10-14 14:24:01 +0800908
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400909 if (!first_ec)
910 return -ENODEV;
911
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400912 return acpi_ec_transaction(first_ec, &t);
Luming Yu45bea152005-07-23 04:08:00 -0400913}
Lennart Poetteringab9e43c2006-10-03 22:49:00 -0400914EXPORT_SYMBOL(ec_transaction);
915
Seth Forshee3e2abc52012-01-18 13:44:08 -0600916/* Get the handle to the EC device */
917acpi_handle ec_get_handle(void)
918{
919 if (!first_ec)
920 return NULL;
921 return first_ec->handle;
922}
Seth Forshee3e2abc52012-01-18 13:44:08 -0600923EXPORT_SYMBOL(ec_get_handle);
924
Lv Zhengad479e72015-02-06 08:57:52 +0800925static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
926{
927 unsigned long flags;
928
929 spin_lock_irqsave(&ec->lock, flags);
930 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800931 ec_dbg_drv("Starting EC");
Lv Zheng9887d222015-02-06 08:57:59 +0800932 /* Enable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800933 if (!resuming) {
Lv Zheng9887d222015-02-06 08:57:59 +0800934 acpi_ec_submit_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800935 ec_dbg_ref(ec, "Increase driver");
Lv Zhengc2b46d62016-08-03 16:01:36 +0800936 }
Lv Zheng3535a3c2015-02-27 14:48:15 +0800937 ec_log_drv("EC started");
Lv Zhengad479e72015-02-06 08:57:52 +0800938 }
939 spin_unlock_irqrestore(&ec->lock, flags);
940}
941
Lv Zheng9887d222015-02-06 08:57:59 +0800942static bool acpi_ec_stopped(struct acpi_ec *ec)
943{
944 unsigned long flags;
945 bool flushed;
946
947 spin_lock_irqsave(&ec->lock, flags);
948 flushed = acpi_ec_flushed(ec);
949 spin_unlock_irqrestore(&ec->lock, flags);
950 return flushed;
951}
952
Lv Zhengad479e72015-02-06 08:57:52 +0800953static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
954{
955 unsigned long flags;
956
957 spin_lock_irqsave(&ec->lock, flags);
958 if (acpi_ec_started(ec)) {
Lv Zheng3535a3c2015-02-27 14:48:15 +0800959 ec_dbg_drv("Stopping EC");
Lv Zhengad479e72015-02-06 08:57:52 +0800960 set_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng9887d222015-02-06 08:57:59 +0800961 spin_unlock_irqrestore(&ec->lock, flags);
962 wait_event(ec->wait, acpi_ec_stopped(ec));
963 spin_lock_irqsave(&ec->lock, flags);
964 /* Disable GPE for event processing (SCI_EVT=1) */
Lv Zheng770970f2015-02-27 14:48:24 +0800965 if (!suspending) {
Lv Zheng9887d222015-02-06 08:57:59 +0800966 acpi_ec_complete_request(ec);
Lv Zheng770970f2015-02-27 14:48:24 +0800967 ec_dbg_ref(ec, "Decrease driver");
Lv Zheng39a2a2a2016-08-03 16:01:43 +0800968 } else if (!ec_freeze_events)
Lv Zheng750f628b2016-08-03 16:01:24 +0800969 __acpi_ec_disable_event(ec);
Lv Zhengad479e72015-02-06 08:57:52 +0800970 clear_bit(EC_FLAGS_STARTED, &ec->flags);
971 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
Lv Zheng3535a3c2015-02-27 14:48:15 +0800972 ec_log_drv("EC stopped");
Lv Zhengad479e72015-02-06 08:57:52 +0800973 }
974 spin_unlock_irqrestore(&ec->lock, flags);
975}
976
Lv Zhengc3a696b2017-01-20 16:42:48 +0800977static void acpi_ec_enter_noirq(struct acpi_ec *ec)
978{
979 unsigned long flags;
980
981 spin_lock_irqsave(&ec->lock, flags);
982 ec->busy_polling = true;
983 ec->polling_guard = 0;
984 ec_log_drv("interrupt blocked");
985 spin_unlock_irqrestore(&ec->lock, flags);
986}
987
988static void acpi_ec_leave_noirq(struct acpi_ec *ec)
989{
990 unsigned long flags;
991
992 spin_lock_irqsave(&ec->lock, flags);
993 ec->busy_polling = ec_busy_polling;
994 ec->polling_guard = ec_polling_guard;
995 ec_log_drv("interrupt unblocked");
996 spin_unlock_irqrestore(&ec->lock, flags);
997}
998
Rafael J. Wysockife955682010-04-09 01:40:38 +0200999void acpi_ec_block_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001000{
1001 struct acpi_ec *ec = first_ec;
1002
1003 if (!ec)
1004 return;
1005
Feng Tangf351d022012-10-23 01:29:27 +02001006 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001007 /* Prevent transactions from being carried out */
Lv Zhengad479e72015-02-06 08:57:52 +08001008 acpi_ec_stop(ec, true);
Feng Tangf351d022012-10-23 01:29:27 +02001009 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001010}
1011
Rafael J. Wysockife955682010-04-09 01:40:38 +02001012void acpi_ec_unblock_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +01001013{
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001014 /*
1015 * Allow transactions to happen again (this function is called from
1016 * atomic context during wakeup, so we don't need to acquire the mutex).
1017 */
1018 if (first_ec)
Lv Zhengad479e72015-02-06 08:57:52 +08001019 acpi_ec_start(first_ec, true);
Rafael J. Wysockid5a64512010-04-09 01:39:40 +02001020}
1021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022/* --------------------------------------------------------------------------
1023 Event Management
1024 -------------------------------------------------------------------------- */
Lv Zheng01305d42015-01-14 19:28:28 +08001025static struct acpi_ec_query_handler *
1026acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler)
1027{
1028 if (handler)
1029 kref_get(&handler->kref);
1030 return handler;
1031}
1032
Lv Zheng0700c042015-09-24 14:54:48 +08001033static struct acpi_ec_query_handler *
1034acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1035{
1036 struct acpi_ec_query_handler *handler;
1037 bool found = false;
1038
1039 mutex_lock(&ec->mutex);
1040 list_for_each_entry(handler, &ec->list, node) {
1041 if (value == handler->query_bit) {
1042 found = true;
1043 break;
1044 }
1045 }
1046 mutex_unlock(&ec->mutex);
1047 return found ? acpi_ec_get_query_handler(handler) : NULL;
1048}
1049
Lv Zheng01305d42015-01-14 19:28:28 +08001050static void acpi_ec_query_handler_release(struct kref *kref)
1051{
1052 struct acpi_ec_query_handler *handler =
1053 container_of(kref, struct acpi_ec_query_handler, kref);
1054
1055 kfree(handler);
1056}
1057
1058static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1059{
1060 kref_put(&handler->kref, acpi_ec_query_handler_release);
1061}
1062
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001063int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1064 acpi_handle handle, acpi_ec_query_func func,
1065 void *data)
1066{
1067 struct acpi_ec_query_handler *handler =
1068 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001069
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001070 if (!handler)
1071 return -ENOMEM;
1072
1073 handler->query_bit = query_bit;
1074 handler->handle = handle;
1075 handler->func = func;
1076 handler->data = data;
Feng Tangf351d022012-10-23 01:29:27 +02001077 mutex_lock(&ec->mutex);
Lv Zheng01305d42015-01-14 19:28:28 +08001078 kref_init(&handler->kref);
Alexey Starikovskiy30c08572007-09-26 19:43:22 +04001079 list_add(&handler->node, &ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001080 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001081 return 0;
1082}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001083EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1084
Lv Zheng0700c042015-09-24 14:54:48 +08001085static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1086 bool remove_all, u8 query_bit)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001087{
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001088 struct acpi_ec_query_handler *handler, *tmp;
Lv Zheng01305d42015-01-14 19:28:28 +08001089 LIST_HEAD(free_list);
Lv Zheng7a73e602014-10-14 14:24:01 +08001090
Feng Tangf351d022012-10-23 01:29:27 +02001091 mutex_lock(&ec->mutex);
Adrian Bunk1544fdb2007-10-24 18:26:00 +02001092 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
Lv Zheng0700c042015-09-24 14:54:48 +08001093 if (remove_all || query_bit == handler->query_bit) {
Lv Zheng01305d42015-01-14 19:28:28 +08001094 list_del_init(&handler->node);
1095 list_add(&handler->node, &free_list);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001096 }
1097 }
Feng Tangf351d022012-10-23 01:29:27 +02001098 mutex_unlock(&ec->mutex);
Chris Bainbridge6b5eab52015-04-22 00:25:36 +01001099 list_for_each_entry_safe(handler, tmp, &free_list, node)
Lv Zheng01305d42015-01-14 19:28:28 +08001100 acpi_ec_put_query_handler(handler);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001101}
Lv Zheng0700c042015-09-24 14:54:48 +08001102
1103void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1104{
1105 acpi_ec_remove_query_handlers(ec, false, query_bit);
1106}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001107EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
Lv Zheng02b771b2015-08-12 11:12:02 +08001109static struct acpi_ec_query *acpi_ec_create_query(u8 *pval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110{
Lv Zheng02b771b2015-08-12 11:12:02 +08001111 struct acpi_ec_query *q;
1112 struct transaction *t;
Lv Zheng7a73e602014-10-14 14:24:01 +08001113
Lv Zheng02b771b2015-08-12 11:12:02 +08001114 q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1115 if (!q)
1116 return NULL;
1117 INIT_WORK(&q->work, acpi_ec_event_processor);
1118 t = &q->transaction;
1119 t->command = ACPI_EC_COMMAND_QUERY;
1120 t->rdata = pval;
1121 t->rlen = 1;
1122 return q;
1123}
1124
1125static void acpi_ec_delete_query(struct acpi_ec_query *q)
1126{
1127 if (q) {
1128 if (q->handler)
1129 acpi_ec_put_query_handler(q->handler);
1130 kfree(q);
1131 }
1132}
1133
1134static void acpi_ec_event_processor(struct work_struct *work)
1135{
1136 struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1137 struct acpi_ec_query_handler *handler = q->handler;
1138
Lv Zheng3535a3c2015-02-27 14:48:15 +08001139 ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001140 if (handler->func)
1141 handler->func(handler->data);
1142 else if (handler->handle)
1143 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
Lv Zheng3535a3c2015-02-27 14:48:15 +08001144 ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
Lv Zheng02b771b2015-08-12 11:12:02 +08001145 acpi_ec_delete_query(q);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001146}
1147
Lv Zheng550b3aac2015-01-14 19:28:53 +08001148static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001149{
1150 u8 value = 0;
Lv Zhengc2cf5762015-01-14 19:28:33 +08001151 int result;
Lv Zheng02b771b2015-08-12 11:12:02 +08001152 struct acpi_ec_query *q;
1153
1154 q = acpi_ec_create_query(&value);
1155 if (!q)
1156 return -ENOMEM;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301157
Lv Zheng550b3aac2015-01-14 19:28:53 +08001158 /*
1159 * Query the EC to find out which _Qxx method we need to evaluate.
1160 * Note that successful completion of the query causes the ACPI_EC_SCI
1161 * bit to be cleared (and thus clearing the interrupt source).
1162 */
Lv Zheng02b771b2015-08-12 11:12:02 +08001163 result = acpi_ec_transaction(ec, &q->transaction);
Lv Zheng550b3aac2015-01-14 19:28:53 +08001164 if (!value)
Lv Zheng02b771b2015-08-12 11:12:02 +08001165 result = -ENODATA;
1166 if (result)
1167 goto err_exit;
Kieran Clancy3eba5632014-04-30 00:21:20 +09301168
Lv Zheng0700c042015-09-24 14:54:48 +08001169 q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1170 if (!q->handler) {
1171 result = -ENODATA;
1172 goto err_exit;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001173 }
Lv Zheng0700c042015-09-24 14:54:48 +08001174
1175 /*
1176 * It is reported that _Qxx are evaluated in a parallel way on
1177 * Windows:
1178 * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1179 *
1180 * Put this log entry before schedule_work() in order to make
1181 * it appearing before any other log entries occurred during the
1182 * work queue execution.
1183 */
1184 ec_dbg_evt("Query(0x%02x) scheduled", value);
Lv Zhenge1191bd2016-08-03 09:00:14 +08001185 if (!queue_work(ec_query_wq, &q->work)) {
Lv Zheng0700c042015-09-24 14:54:48 +08001186 ec_dbg_evt("Query(0x%02x) overlapped", value);
1187 result = -EBUSY;
1188 }
Lv Zheng02b771b2015-08-12 11:12:02 +08001189
1190err_exit:
Markus Elfring4981c2b2015-11-15 22:42:27 +01001191 if (result)
Lv Zheng02b771b2015-08-12 11:12:02 +08001192 acpi_ec_delete_query(q);
1193 if (data)
1194 *data = value;
Lv Zhengc2cf5762015-01-14 19:28:33 +08001195 return result;
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001196}
1197
Lv Zheng1d68d262015-06-11 13:21:38 +08001198static void acpi_ec_check_event(struct acpi_ec *ec)
1199{
1200 unsigned long flags;
1201
1202 if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1203 if (ec_guard(ec)) {
1204 spin_lock_irqsave(&ec->lock, flags);
1205 /*
1206 * Take care of the SCI_EVT unless no one else is
1207 * taking care of it.
1208 */
1209 if (!ec->curr)
1210 advance_transaction(ec);
1211 spin_unlock_irqrestore(&ec->lock, flags);
1212 }
1213 }
1214}
1215
Lv Zheng9d8993b2015-06-11 13:21:32 +08001216static void acpi_ec_event_handler(struct work_struct *work)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +03001217{
Lv Zheng9d8993b2015-06-11 13:21:32 +08001218 unsigned long flags;
Lv Zheng74443bb2015-01-14 19:28:47 +08001219 struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
Lv Zheng7a73e602014-10-14 14:24:01 +08001220
Lv Zheng9d8993b2015-06-11 13:21:32 +08001221 ec_dbg_evt("Event started");
1222
1223 spin_lock_irqsave(&ec->lock, flags);
1224 while (ec->nr_pending_queries) {
1225 spin_unlock_irqrestore(&ec->lock, flags);
1226 (void)acpi_ec_query(ec, NULL);
1227 spin_lock_irqsave(&ec->lock, flags);
1228 ec->nr_pending_queries--;
Lv Zheng66db3832015-06-11 13:21:51 +08001229 /*
1230 * Before exit, make sure that this work item can be
1231 * scheduled again. There might be QR_EC failures, leaving
1232 * EC_FLAGS_QUERY_PENDING uncleared and preventing this work
1233 * item from being scheduled again.
1234 */
1235 if (!ec->nr_pending_queries) {
1236 if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
1237 ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY)
1238 acpi_ec_complete_query(ec);
1239 }
Lv Zheng9d8993b2015-06-11 13:21:32 +08001240 }
1241 spin_unlock_irqrestore(&ec->lock, flags);
1242
1243 ec_dbg_evt("Event stopped");
Lv Zheng1d68d262015-06-11 13:21:38 +08001244
1245 acpi_ec_check_event(ec);
Luming Yu45bea152005-07-23 04:08:00 -04001246}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
Lin Ming8b6cd8a2010-12-13 13:38:46 +08001248static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1249 u32 gpe_number, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250{
Lv Zhengf92fca02014-06-15 08:41:35 +08001251 unsigned long flags;
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +03001252 struct acpi_ec *ec = data;
Lennart Poettering00eb43a2007-05-04 14:16:19 +02001253
Lv Zhengf92fca02014-06-15 08:41:35 +08001254 spin_lock_irqsave(&ec->lock, flags);
Lv Zheng0c788082015-01-14 19:28:22 +08001255 advance_transaction(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +08001256 spin_unlock_irqrestore(&ec->lock, flags);
Lv Zhengca37bfd2015-02-05 16:27:22 +08001257 return ACPI_INTERRUPT_HANDLED;
Alexey Starikovskiy845625c2008-03-21 17:07:03 +03001258}
1259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001261 * Address Space Management
1262 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
1264static acpi_status
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001265acpi_ec_space_handler(u32 function, acpi_physical_address address,
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001266 u32 bits, u64 *value64,
Len Brown50526df2005-08-11 17:32:05 -04001267 void *handler_context, void *region_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268{
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +03001269 struct acpi_ec *ec = handler_context;
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001270 int result = 0, i, bytes = bits / 8;
1271 u8 *value = (u8 *)value64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 if ((address > 0xFF) || !value || !handler_context)
Patrick Mocheld550d982006-06-27 00:41:40 -04001274 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001276 if (function != ACPI_READ && function != ACPI_WRITE)
Patrick Mocheld550d982006-06-27 00:41:40 -04001277 return AE_BAD_PARAMETER;
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +04001278
Lv Zhengc3a696b2017-01-20 16:42:48 +08001279 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001280 acpi_ec_burst_enable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001281
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -04001282 for (i = 0; i < bytes; ++i, ++address, ++value)
1283 result = (function == ACPI_READ) ?
1284 acpi_ec_read(ec, address, value) :
1285 acpi_ec_write(ec, address, *value);
Alexey Starikovskiy3e71a872008-01-11 02:42:51 +03001286
Lv Zhengc3a696b2017-01-20 16:42:48 +08001287 if (ec->busy_polling || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +04001288 acpi_ec_burst_disable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +03001289
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 switch (result) {
1291 case -EINVAL:
Patrick Mocheld550d982006-06-27 00:41:40 -04001292 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 case -ENODEV:
Patrick Mocheld550d982006-06-27 00:41:40 -04001294 return AE_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 case -ETIME:
Patrick Mocheld550d982006-06-27 00:41:40 -04001296 return AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 default:
Patrick Mocheld550d982006-06-27 00:41:40 -04001298 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300}
1301
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +08001303 * Driver Interface
1304 * -------------------------------------------------------------------------- */
1305
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001306static acpi_status
1307ec_parse_io_ports(struct acpi_resource *resource, void *context);
1308
Lv Zheng72c77b72016-09-07 16:50:08 +08001309static void acpi_ec_free(struct acpi_ec *ec)
1310{
1311 if (first_ec == ec)
1312 first_ec = NULL;
1313 if (boot_ec == ec)
1314 boot_ec = NULL;
1315 kfree(ec);
1316}
1317
1318static struct acpi_ec *acpi_ec_alloc(void)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001319{
1320 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +08001321
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001322 if (!ec)
1323 return NULL;
Feng Tangf351d022012-10-23 01:29:27 +02001324 mutex_init(&ec->mutex);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001325 init_waitqueue_head(&ec->wait);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001326 INIT_LIST_HEAD(&ec->list);
Feng Tangf351d022012-10-23 01:29:27 +02001327 spin_lock_init(&ec->lock);
Lv Zheng9d8993b2015-06-11 13:21:32 +08001328 INIT_WORK(&ec->work, acpi_ec_event_handler);
Lv Zhengd8d031a2015-05-15 14:16:42 +08001329 ec->timestamp = jiffies;
Lv Zhengc3a696b2017-01-20 16:42:48 +08001330 ec->busy_polling = true;
1331 ec->polling_guard = 0;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001332 return ec;
1333}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001335static acpi_status
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001336acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1337 void *context, void **return_value)
1338{
Lin Ming0175d562008-12-16 16:46:12 +08001339 char node_name[5];
1340 struct acpi_buffer buffer = { sizeof(node_name), node_name };
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001341 struct acpi_ec *ec = context;
1342 int value = 0;
Lin Ming0175d562008-12-16 16:46:12 +08001343 acpi_status status;
1344
1345 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1346
Lv Zheng7a73e602014-10-14 14:24:01 +08001347 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001348 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
Alexey Starikovskiyc019b192007-08-14 01:03:42 -04001349 return AE_OK;
1350}
1351
1352static acpi_status
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001353ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001354{
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001355 acpi_status status;
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001356 unsigned long long tmp = 0;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001357 struct acpi_ec *ec = context;
Alexey Starikovskiya5032bf2009-04-01 01:33:15 -04001358
1359 /* clear addr values, ec_parse_io_ports depend on it */
1360 ec->command_addr = ec->data_addr = 0;
1361
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001362 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1363 ec_parse_io_ports, ec);
1364 if (ACPI_FAILURE(status))
1365 return status;
Lv Zhengae56c9f2017-06-15 09:41:35 +08001366 if (ec->data_addr == 0 || ec->command_addr == 0)
1367 return AE_OK;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001368
1369 /* Get GPE bit assignment (EC events). */
1370 /* TODO: Add support for _GPE returning a package */
Matthew Wilcox27663c52008-10-10 02:22:59 -04001371 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001372 if (ACPI_FAILURE(status))
1373 return status;
Matthew Wilcox27663c52008-10-10 02:22:59 -04001374 ec->gpe = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001375 /* Use the global lock for all EC transactions? */
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -05001376 tmp = 0;
Matthew Wilcox27663c52008-10-10 02:22:59 -04001377 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1378 ec->global_lock = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001379 ec->handle = handle;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001380 return AE_CTRL_TERMINATE;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001381}
1382
Lv Zheng72c77b72016-09-07 16:50:08 +08001383/*
1384 * Note: This function returns an error code only when the address space
1385 * handler is not installed, which means "not able to handle
1386 * transactions".
1387 */
Lv Zheng2a570842016-09-07 16:50:21 +08001388static int ec_install_handlers(struct acpi_ec *ec, bool handle_events)
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001389{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001390 acpi_status status;
Lv Zheng7a73e602014-10-14 14:24:01 +08001391
Lv Zhengad479e72015-02-06 08:57:52 +08001392 acpi_ec_start(ec, false);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001393
1394 if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
Lv Zhengc3a696b2017-01-20 16:42:48 +08001395 acpi_ec_enter_noirq(ec);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001396 status = acpi_install_address_space_handler(ec->handle,
1397 ACPI_ADR_SPACE_EC,
1398 &acpi_ec_space_handler,
1399 NULL, ec);
1400 if (ACPI_FAILURE(status)) {
1401 if (status == AE_NOT_FOUND) {
1402 /*
1403 * Maybe OS fails in evaluating the _REG
1404 * object. The AE_NOT_FOUND error will be
1405 * ignored and OS * continue to initialize
1406 * EC.
1407 */
1408 pr_err("Fail in evaluating the _REG object"
1409 " of EC device. Broken bios is suspected.\n");
1410 } else {
1411 acpi_ec_stop(ec, false);
1412 return -ENODEV;
1413 }
1414 }
1415 set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1416 }
1417
Lv Zheng2a570842016-09-07 16:50:21 +08001418 if (!handle_events)
1419 return 0;
1420
1421 if (!test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
1422 /* Find and register all query methods */
1423 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1424 acpi_ec_register_query_methods,
1425 NULL, ec, NULL);
1426 set_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1427 }
Lv Zheng0e1affe2016-03-24 10:42:47 +08001428 if (!test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1429 status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1430 ACPI_GPE_EDGE_TRIGGERED,
1431 &acpi_ec_gpe_handler, ec);
1432 /* This is not fatal as we can poll EC events */
1433 if (ACPI_SUCCESS(status)) {
1434 set_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
Lv Zhengc3a696b2017-01-20 16:42:48 +08001435 acpi_ec_leave_noirq(ec);
Lv Zheng0e1affe2016-03-24 10:42:47 +08001436 if (test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1437 ec->reference_count >= 1)
1438 acpi_ec_enable_gpe(ec, true);
Lv Zheng2a570842016-09-07 16:50:21 +08001439
1440 /* EC is fully operational, allow queries */
1441 acpi_ec_enable_event(ec);
Zhao Yakui20edd742008-10-17 02:02:44 -04001442 }
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001443 }
1444
1445 return 0;
1446}
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448static void ec_remove_handlers(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449{
Lv Zheng0e1affe2016-03-24 10:42:47 +08001450 if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1451 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1452 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1453 pr_err("failed to remove space handler\n");
1454 clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1455 }
1456
Lv Zhengfa5b4a52016-07-08 09:25:05 +08001457 /*
1458 * Stops handling the EC transactions after removing the operation
1459 * region handler. This is required because _REG(DISCONNECT)
1460 * invoked during the removal can result in new EC transactions.
1461 *
1462 * Flushes the EC requests and thus disables the GPE before
1463 * removing the GPE handler. This is required by the current ACPICA
1464 * GPE core. ACPICA GPE core will automatically disable a GPE when
1465 * it is indicated but there is no way to handle it. So the drivers
1466 * must disable the GPEs prior to removing the GPE handlers.
1467 */
1468 acpi_ec_stop(ec, false);
1469
Lv Zheng0e1affe2016-03-24 10:42:47 +08001470 if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1471 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1472 &acpi_ec_gpe_handler)))
1473 pr_err("failed to remove gpe handler\n");
1474 clear_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
1475 }
Lv Zheng2a570842016-09-07 16:50:21 +08001476 if (test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
1477 acpi_ec_remove_query_handlers(ec, true, 0);
1478 clear_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1479 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
Lv Zheng2a570842016-09-07 16:50:21 +08001482static int acpi_ec_setup(struct acpi_ec *ec, bool handle_events)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483{
Lv Zheng72c77b72016-09-07 16:50:08 +08001484 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
Lv Zheng2a570842016-09-07 16:50:21 +08001486 ret = ec_install_handlers(ec, handle_events);
Lv Zheng72c77b72016-09-07 16:50:08 +08001487 if (ret)
1488 return ret;
1489
1490 /* First EC capable of handling transactions */
1491 if (!first_ec) {
1492 first_ec = ec;
1493 acpi_handle_info(first_ec->handle, "Used as first EC\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 }
Lv Zheng72c77b72016-09-07 16:50:08 +08001495
1496 acpi_handle_info(ec->handle,
1497 "GPE=0x%lx, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n",
1498 ec->gpe, ec->command_addr, ec->data_addr);
1499 return ret;
1500}
1501
Lv Zheng2a570842016-09-07 16:50:21 +08001502static int acpi_config_boot_ec(struct acpi_ec *ec, acpi_handle handle,
1503 bool handle_events, bool is_ecdt)
Lv Zheng72c77b72016-09-07 16:50:08 +08001504{
1505 int ret;
1506
Lv Zheng2a570842016-09-07 16:50:21 +08001507 /*
1508 * Changing the ACPI handle results in a re-configuration of the
1509 * boot EC. And if it happens after the namespace initialization,
1510 * it causes _REG evaluations.
1511 */
1512 if (boot_ec && boot_ec->handle != handle)
Lv Zheng72c77b72016-09-07 16:50:08 +08001513 ec_remove_handlers(boot_ec);
1514
1515 /* Unset old boot EC */
1516 if (boot_ec != ec)
1517 acpi_ec_free(boot_ec);
1518
Lv Zheng2a570842016-09-07 16:50:21 +08001519 /*
1520 * ECDT device creation is split into acpi_ec_ecdt_probe() and
1521 * acpi_ec_ecdt_start(). This function takes care of completing the
1522 * ECDT parsing logic as the handle update should be performed
1523 * between the installation/uninstallation of the handlers.
1524 */
1525 if (ec->handle != handle)
1526 ec->handle = handle;
1527
1528 ret = acpi_ec_setup(ec, handle_events);
Lv Zheng72c77b72016-09-07 16:50:08 +08001529 if (ret)
1530 return ret;
1531
1532 /* Set new boot EC */
1533 if (!boot_ec) {
1534 boot_ec = ec;
1535 boot_ec_is_ecdt = is_ecdt;
Lv Zheng72c77b72016-09-07 16:50:08 +08001536 }
Lv Zheng2a570842016-09-07 16:50:21 +08001537
1538 acpi_handle_info(boot_ec->handle,
1539 "Used as boot %s EC to handle transactions%s\n",
1540 is_ecdt ? "ECDT" : "DSDT",
1541 handle_events ? " and events" : "");
Lv Zheng72c77b72016-09-07 16:50:08 +08001542 return ret;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001543}
1544
Lv Zheng97cb1592016-09-07 16:50:27 +08001545static bool acpi_ec_ecdt_get_handle(acpi_handle *phandle)
1546{
1547 struct acpi_table_ecdt *ecdt_ptr;
1548 acpi_status status;
1549 acpi_handle handle;
1550
1551 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1552 (struct acpi_table_header **)&ecdt_ptr);
1553 if (ACPI_FAILURE(status))
1554 return false;
1555
1556 status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1557 if (ACPI_FAILURE(status))
1558 return false;
1559
1560 *phandle = handle;
1561 return true;
1562}
1563
1564static bool acpi_is_boot_ec(struct acpi_ec *ec)
1565{
1566 if (!boot_ec)
1567 return false;
1568 if (ec->handle == boot_ec->handle &&
1569 ec->gpe == boot_ec->gpe &&
1570 ec->command_addr == boot_ec->command_addr &&
1571 ec->data_addr == boot_ec->data_addr)
1572 return true;
1573 return false;
1574}
1575
Lv Zhengfd6231e2016-06-21 17:42:05 +08001576static int acpi_ec_add(struct acpi_device *device)
1577{
1578 struct acpi_ec *ec = NULL;
1579 int ret;
1580
1581 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1582 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1583
1584 ec = acpi_ec_alloc();
1585 if (!ec)
1586 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 if (ec_parse_device(device->handle, 0, ec, NULL) !=
1588 AE_CTRL_TERMINATE) {
Lv Zheng46922d22016-09-07 16:50:14 +08001589 ret = -EINVAL;
1590 goto err_alloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 }
1592
Lv Zheng97cb1592016-09-07 16:50:27 +08001593 if (acpi_is_boot_ec(ec)) {
1594 boot_ec_is_ecdt = false;
1595 acpi_handle_debug(ec->handle, "duplicated.\n");
1596 acpi_ec_free(ec);
1597 ec = boot_ec;
1598 ret = acpi_config_boot_ec(ec, ec->handle, true, false);
1599 } else
1600 ret = acpi_ec_setup(ec, true);
Lv Zheng46922d22016-09-07 16:50:14 +08001601 if (ret)
1602 goto err_query;
1603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 device->driver_data = ec;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001605
Andi Kleend6795fe32012-02-06 08:17:08 -08001606 ret = !!request_region(ec->data_addr, 1, "EC data");
1607 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1608 ret = !!request_region(ec->command_addr, 1, "EC cmd");
1609 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001610
Lan Tianyu1c832b32015-04-01 09:47:18 +08001611 /* Reprobe devices depending on the EC */
1612 acpi_walk_dep_device_list(ec->handle);
Lv Zheng97cb1592016-09-07 16:50:27 +08001613 acpi_handle_debug(ec->handle, "enumerated.\n");
Lv Zheng46922d22016-09-07 16:50:14 +08001614 return 0;
1615
1616err_query:
Lv Zheng97cb1592016-09-07 16:50:27 +08001617 if (ec != boot_ec)
1618 acpi_ec_remove_query_handlers(ec, true, 0);
Lv Zheng46922d22016-09-07 16:50:14 +08001619err_alloc:
Lv Zheng97cb1592016-09-07 16:50:27 +08001620 if (ec != boot_ec)
1621 acpi_ec_free(ec);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +04001622 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623}
1624
Rafael J. Wysocki51fac832013-01-24 00:24:48 +01001625static int acpi_ec_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001627 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001630 return -EINVAL;
Alexey Starikovskiyf9319f92007-08-24 08:10:11 +04001631
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 ec = acpi_driver_data(device);
Thomas Renningerde4f1042010-07-29 22:08:44 +02001633 release_region(ec->data_addr, 1);
1634 release_region(ec->command_addr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 device->driver_data = NULL;
Lv Zheng97cb1592016-09-07 16:50:27 +08001636 if (ec != boot_ec) {
1637 ec_remove_handlers(ec);
1638 acpi_ec_free(ec);
1639 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001640 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641}
1642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643static acpi_status
1644ec_parse_io_ports(struct acpi_resource *resource, void *context)
1645{
1646 struct acpi_ec *ec = context;
1647
1648 if (resource->type != ACPI_RESOURCE_TYPE_IO)
1649 return AE_OK;
1650
1651 /*
1652 * The first address region returned is the data port, and
1653 * the second address region returned is the status/command
1654 * port.
1655 */
Thomas Renningerde4f1042010-07-29 22:08:44 +02001656 if (ec->data_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 ec->data_addr = resource->data.io.minimum;
Thomas Renningerde4f1042010-07-29 22:08:44 +02001658 else if (ec->command_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 ec->command_addr = resource->data.io.minimum;
1660 else
1661 return AE_CTRL_TERMINATE;
1662
1663 return AE_OK;
1664}
1665
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001666static const struct acpi_device_id ec_device_ids[] = {
1667 {"PNP0C09", 0},
1668 {"", 0},
1669};
1670
1671int __init acpi_ec_dsdt_probe(void)
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001672{
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001673 acpi_status status;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001674 struct acpi_ec *ec;
1675 int ret;
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001676
Lv Zhengfd6231e2016-06-21 17:42:05 +08001677 ec = acpi_ec_alloc();
1678 if (!ec)
1679 return -ENOMEM;
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001680 /*
Lv Zheng2a570842016-09-07 16:50:21 +08001681 * At this point, the namespace is initialized, so start to find
1682 * the namespace objects.
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001683 */
Lv Zhengdcf15cb2016-06-03 10:26:12 +08001684 status = acpi_get_devices(ec_device_ids[0].id,
Lv Zhengfd6231e2016-06-21 17:42:05 +08001685 ec_parse_device, ec, NULL);
1686 if (ACPI_FAILURE(status) || !ec->handle) {
1687 ret = -ENODEV;
1688 goto error;
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001689 }
Lv Zheng2a570842016-09-07 16:50:21 +08001690 /*
1691 * When the DSDT EC is available, always re-configure boot EC to
1692 * have _REG evaluated. _REG can only be evaluated after the
1693 * namespace initialization.
1694 * At this point, the GPE is not fully initialized, so do not to
1695 * handle the events.
1696 */
1697 ret = acpi_config_boot_ec(ec, ec->handle, false, false);
Lv Zhengfd6231e2016-06-21 17:42:05 +08001698error:
1699 if (ret)
Lv Zheng72c77b72016-09-07 16:50:08 +08001700 acpi_ec_free(ec);
Lv Zhengfd6231e2016-06-21 17:42:05 +08001701 return ret;
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -05001702}
1703
Lv Zheng2a570842016-09-07 16:50:21 +08001704/*
1705 * If the DSDT EC is not functioning, we still need to prepare a fully
1706 * functioning ECDT EC first in order to handle the events.
1707 * https://bugzilla.kernel.org/show_bug.cgi?id=115021
1708 */
1709int __init acpi_ec_ecdt_start(void)
1710{
Lv Zheng2a570842016-09-07 16:50:21 +08001711 acpi_handle handle;
1712
1713 if (!boot_ec)
1714 return -ENODEV;
1715 /*
1716 * The DSDT EC should have already been started in
1717 * acpi_ec_add().
1718 */
1719 if (!boot_ec_is_ecdt)
1720 return -ENODEV;
1721
Lv Zheng2a570842016-09-07 16:50:21 +08001722 /*
1723 * At this point, the namespace and the GPE is initialized, so
1724 * start to find the namespace objects and handle the events.
1725 */
Lv Zheng97cb1592016-09-07 16:50:27 +08001726 if (!acpi_ec_ecdt_get_handle(&handle))
Lv Zheng2a570842016-09-07 16:50:21 +08001727 return -ENODEV;
1728 return acpi_config_boot_ec(boot_ec, handle, true, true);
1729}
1730
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001731#if 0
Feng Tang67bfa9b2012-09-28 15:22:01 +08001732/*
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001733 * Some EC firmware variations refuses to respond QR_EC when SCI_EVT is not
1734 * set, for which case, we complete the QR_EC without issuing it to the
1735 * firmware.
1736 * https://bugzilla.kernel.org/show_bug.cgi?id=82611
1737 * https://bugzilla.kernel.org/show_bug.cgi?id=97381
Lv Zheng79149002014-10-29 11:33:49 +08001738 */
1739static int ec_flag_query_handshake(const struct dmi_system_id *id)
1740{
1741 pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1742 EC_FLAGS_QUERY_HANDSHAKE = 1;
1743 return 0;
1744}
Lv Zheng3cb02ae2015-06-11 13:21:45 +08001745#endif
Lv Zheng79149002014-10-29 11:33:49 +08001746
1747/*
Lv Zhengbc539562016-06-21 17:42:12 +08001748 * Some ECDTs contain wrong register addresses.
1749 * MSI MS-171F
1750 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1751 */
Lv Zheng59f0aa92016-03-24 10:42:53 +08001752static int ec_correct_ecdt(const struct dmi_system_id *id)
1753{
1754 pr_debug("Detected system needing ECDT address correction.\n");
1755 EC_FLAGS_CORRECT_ECDT = 1;
1756 return 0;
1757}
1758
Sachin Kamat6cef7492013-08-07 17:16:55 +05301759static struct dmi_system_id ec_dmi_table[] __initdata = {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001760 {
Lv Zheng59f0aa92016-03-24 10:42:53 +08001761 ec_correct_ecdt, "MSI MS-171F", {
Lv Zheng3174abc2015-05-15 14:37:11 +08001762 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1763 DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001764 {},
1765};
1766
Len Brown50526df2005-08-11 17:32:05 -04001767int __init acpi_ec_ecdt_probe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768{
Lv Zhengfd6231e2016-06-21 17:42:05 +08001769 int ret;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001770 acpi_status status;
1771 struct acpi_table_ecdt *ecdt_ptr;
Lv Zhengfd6231e2016-06-21 17:42:05 +08001772 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773
Lv Zhengfd6231e2016-06-21 17:42:05 +08001774 ec = acpi_ec_alloc();
1775 if (!ec)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001776 return -ENOMEM;
1777 /*
1778 * Generate a boot ec context
1779 */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001780 dmi_check_system(ec_dmi_table);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001781 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1782 (struct acpi_table_header **)&ecdt_ptr);
Lv Zheng59f0aa92016-03-24 10:42:53 +08001783 if (ACPI_FAILURE(status)) {
1784 ret = -ENODEV;
1785 goto error;
1786 }
1787
1788 if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1789 /*
1790 * Asus X50GL:
1791 * https://bugzilla.kernel.org/show_bug.cgi?id=11880
1792 */
1793 ret = -ENODEV;
1794 goto error;
1795 }
1796
Lv Zheng59f0aa92016-03-24 10:42:53 +08001797 if (EC_FLAGS_CORRECT_ECDT) {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001798 ec->command_addr = ecdt_ptr->data.address;
1799 ec->data_addr = ecdt_ptr->control.address;
Lv Zheng59f0aa92016-03-24 10:42:53 +08001800 } else {
Lv Zhengfd6231e2016-06-21 17:42:05 +08001801 ec->command_addr = ecdt_ptr->control.address;
1802 ec->data_addr = ecdt_ptr->data.address;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001803 }
Lv Zhengfd6231e2016-06-21 17:42:05 +08001804 ec->gpe = ecdt_ptr->gpe;
Lv Zheng2a570842016-09-07 16:50:21 +08001805
1806 /*
1807 * At this point, the namespace is not initialized, so do not find
1808 * the namespace objects, or handle the events.
1809 */
1810 ret = acpi_config_boot_ec(ec, ACPI_ROOT_OBJECT, false, true);
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001811error:
Lv Zhengfd6231e2016-06-21 17:42:05 +08001812 if (ret)
Lv Zheng72c77b72016-09-07 16:50:08 +08001813 acpi_ec_free(ec);
Lv Zheng59f0aa92016-03-24 10:42:53 +08001814 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815}
1816
Lv Zhengdf45db62016-08-03 09:07:58 +08001817#ifdef CONFIG_PM_SLEEP
Lv Zhengdf45db62016-08-03 09:07:58 +08001818static int acpi_ec_suspend_noirq(struct device *dev)
1819{
1820 struct acpi_ec *ec =
1821 acpi_driver_data(to_acpi_device(dev));
1822
1823 acpi_ec_enter_noirq(ec);
1824 return 0;
1825}
1826
1827static int acpi_ec_resume_noirq(struct device *dev)
1828{
1829 struct acpi_ec *ec =
1830 acpi_driver_data(to_acpi_device(dev));
1831
1832 acpi_ec_leave_noirq(ec);
1833 return 0;
1834}
Lv Zhengc2b46d62016-08-03 16:01:36 +08001835
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001836static int acpi_ec_suspend(struct device *dev)
1837{
1838 struct acpi_ec *ec =
1839 acpi_driver_data(to_acpi_device(dev));
1840
1841 if (ec_freeze_events)
1842 acpi_ec_disable_event(ec);
1843 return 0;
1844}
1845
Lv Zhengc2b46d62016-08-03 16:01:36 +08001846static int acpi_ec_resume(struct device *dev)
1847{
1848 struct acpi_ec *ec =
1849 acpi_driver_data(to_acpi_device(dev));
1850
1851 acpi_ec_enable_event(ec);
1852 return 0;
1853}
Lv Zhengdf45db62016-08-03 09:07:58 +08001854#endif
1855
1856static const struct dev_pm_ops acpi_ec_pm = {
1857 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
Lv Zheng39a2a2a2016-08-03 16:01:43 +08001858 SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
Lv Zhengdf45db62016-08-03 09:07:58 +08001859};
1860
Lv Zheng1d68d262015-06-11 13:21:38 +08001861static int param_set_event_clearing(const char *val, struct kernel_param *kp)
1862{
1863 int result = 0;
1864
1865 if (!strncmp(val, "status", sizeof("status") - 1)) {
1866 ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1867 pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
1868 } else if (!strncmp(val, "query", sizeof("query") - 1)) {
1869 ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
1870 pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
1871 } else if (!strncmp(val, "event", sizeof("event") - 1)) {
1872 ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
1873 pr_info("Assuming SCI_EVT clearing on event reads\n");
1874 } else
1875 result = -EINVAL;
1876 return result;
1877}
1878
1879static int param_get_event_clearing(char *buffer, struct kernel_param *kp)
1880{
1881 switch (ec_event_clearing) {
1882 case ACPI_EC_EVT_TIMING_STATUS:
1883 return sprintf(buffer, "status");
1884 case ACPI_EC_EVT_TIMING_QUERY:
1885 return sprintf(buffer, "query");
1886 case ACPI_EC_EVT_TIMING_EVENT:
1887 return sprintf(buffer, "event");
1888 default:
1889 return sprintf(buffer, "invalid");
1890 }
1891 return 0;
1892}
1893
1894module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
1895 NULL, 0644);
1896MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
1897
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001898static struct acpi_driver acpi_ec_driver = {
1899 .name = "ec",
1900 .class = ACPI_EC_CLASS,
1901 .ids = ec_device_ids,
1902 .ops = {
1903 .add = acpi_ec_add,
1904 .remove = acpi_ec_remove,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001905 },
Lv Zhengdf45db62016-08-03 09:07:58 +08001906 .drv.pm = &acpi_ec_pm,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001907};
1908
Lv Zhenge1191bd2016-08-03 09:00:14 +08001909static inline int acpi_ec_query_init(void)
1910{
1911 if (!ec_query_wq) {
1912 ec_query_wq = alloc_workqueue("kec_query", 0,
1913 ec_max_queries);
1914 if (!ec_query_wq)
1915 return -ENODEV;
1916 }
1917 return 0;
1918}
1919
1920static inline void acpi_ec_query_exit(void)
1921{
1922 if (ec_query_wq) {
1923 destroy_workqueue(ec_query_wq);
1924 ec_query_wq = NULL;
1925 }
1926}
1927
Bjorn Helgaasa5f820f2009-03-24 16:49:48 -06001928int __init acpi_ec_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929{
Lv Zhenge1191bd2016-08-03 09:00:14 +08001930 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931
Lv Zhenge1191bd2016-08-03 09:00:14 +08001932 /* register workqueue for _Qxx evaluations */
1933 result = acpi_ec_query_init();
1934 if (result)
1935 goto err_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 /* Now register the driver for the EC */
1937 result = acpi_bus_register_driver(&acpi_ec_driver);
Lv Zhenge1191bd2016-08-03 09:00:14 +08001938 if (result)
1939 goto err_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
Lv Zhenge1191bd2016-08-03 09:00:14 +08001941err_exit:
1942 if (result)
1943 acpi_ec_query_exit();
Patrick Mocheld550d982006-06-27 00:41:40 -04001944 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945}
1946
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947/* EC driver currently not unloadable */
1948#if 0
Len Brown50526df2005-08-11 17:32:05 -04001949static void __exit acpi_ec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951
1952 acpi_bus_unregister_driver(&acpi_ec_driver);
Lv Zhenge1191bd2016-08-03 09:00:14 +08001953 acpi_ec_query_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954}
Alexey Starikovskiy78439322007-10-22 14:18:43 +04001955#endif /* 0 */