blob: 1b5853f384e268f7efd7928f13d929376094a9a5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Lv Zheng4a3f6b52014-06-15 08:42:19 +08002 * ec.c - ACPI Embedded Controller Driver (v2.2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Lv Zheng4a3f6b52014-06-15 08:42:19 +08004 * Copyright (C) 2001-2014 Intel Corporation
5 * Author: 2014 Lv Zheng <lv.zheng@intel.com>
6 * 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 *
25 * You should have received a copy of the GNU General Public License along
26 * with this program; if not, write to the Free Software Foundation, Inc.,
27 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
28 *
29 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
30 */
31
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040032/* Uncomment next line to get verbose printout */
Márton Némethd772b3b2008-01-23 22:34:09 -050033/* #define DEBUG */
Lan Tianyu16a26e82013-09-12 03:32:04 -040034#define pr_fmt(fmt) "ACPI : EC: " fmt
Márton Némethd772b3b2008-01-23 22:34:09 -050035
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/kernel.h>
37#include <linux/module.h>
38#include <linux/init.h>
39#include <linux/types.h>
40#include <linux/delay.h>
Dmitry Torokhov451566f2005-03-19 01:10:05 -050041#include <linux/interrupt.h>
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040042#include <linux/list.h>
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040043#include <linux/spinlock.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090044#include <linux/slab.h>
Lv Zheng8b484632013-12-03 08:49:16 +080045#include <linux/acpi.h>
Len Browneb27cae2009-07-06 23:40:19 -040046#include <linux/dmi.h>
Lv Zheng8b484632013-12-03 08:49:16 +080047#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Thomas Renninger1195a092010-07-16 13:11:31 +020049#include "internal.h"
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define ACPI_EC_CLASS "embedded_controller"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define ACPI_EC_DEVICE_NAME "Embedded Controller"
53#define ACPI_EC_FILE_INFO "info"
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040054
Denis M. Sadykov703959d2006-09-26 19:50:33 +040055/* EC status register */
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
57#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
Lv Zhengdd43de22014-06-15 08:42:42 +080058#define ACPI_EC_FLAG_CMD 0x08 /* Input buffer contains a command */
Dmitry Torokhov451566f2005-03-19 01:10:05 -050059#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
Alexey Starikovskiy43509332007-05-29 16:42:57 +040061
Denis M. Sadykov703959d2006-09-26 19:50:33 +040062/* EC commands */
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030063enum ec_command {
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +030064 ACPI_EC_COMMAND_READ = 0x80,
65 ACPI_EC_COMMAND_WRITE = 0x81,
66 ACPI_EC_BURST_ENABLE = 0x82,
67 ACPI_EC_BURST_DISABLE = 0x83,
68 ACPI_EC_COMMAND_QUERY = 0x84,
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030069};
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040070
Alexey Starikovskiy5c406412006-12-07 18:42:16 +030071#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
Denis M. Sadykov703959d2006-09-26 19:50:33 +040072#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +040073#define ACPI_EC_MSI_UDELAY 550 /* Wait 550us for MSI EC */
Kieran Clancyad332c82014-03-01 00:42:28 +103074#define ACPI_EC_CLEAR_MAX 100 /* Maximum number of events to query
75 * when trying to clear the EC */
Denis M. Sadykov703959d2006-09-26 19:50:33 +040076
Alexey Starikovskiy080e4122007-10-22 14:18:30 +040077enum {
Alexey Starikovskiy080e4122007-10-22 14:18:30 +040078 EC_FLAGS_QUERY_PENDING, /* Query is pending */
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040079 EC_FLAGS_GPE_STORM, /* GPE storm detected */
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +010080 EC_FLAGS_HANDLERS_INSTALLED, /* Handlers for GPE and
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040081 * OpReg are installed */
Rafael J. Wysockife955682010-04-09 01:40:38 +020082 EC_FLAGS_BLOCKED, /* Transactions are blocked */
Linus Torvalds1da177e2005-04-16 15:20:36 -070083};
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +040084
Lv Zhengf92fca02014-06-15 08:41:35 +080085#define ACPI_EC_COMMAND_POLL 0x01 /* Available for command byte */
86#define ACPI_EC_COMMAND_COMPLETE 0x02 /* Completed last byte */
87
Thomas Renninger7a18e962010-10-21 18:24:57 +020088/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
89static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
90module_param(ec_delay, uint, 0644);
91MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
92
Feng Tanga520d522012-09-28 15:22:00 +080093/*
94 * If the number of false interrupts per one transaction exceeds
95 * this threshold, will think there is a GPE storm happened and
96 * will disable the GPE for normal transaction.
97 */
98static unsigned int ec_storm_threshold __read_mostly = 8;
99module_param(ec_storm_threshold, uint, 0644);
100MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
101
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400102struct acpi_ec_query_handler {
103 struct list_head node;
104 acpi_ec_query_func func;
105 acpi_handle handle;
106 void *data;
107 u8 query_bit;
108};
109
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400110struct transaction {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400111 const u8 *wdata;
112 u8 *rdata;
113 unsigned short irq_count;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400114 u8 command;
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300115 u8 wi;
116 u8 ri;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400117 u8 wlen;
118 u8 rlen;
Lv Zhengf92fca02014-06-15 08:41:35 +0800119 u8 flags;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400120};
121
Thomas Renninger1195a092010-07-16 13:11:31 +0200122struct acpi_ec *boot_ec, *first_ec;
123EXPORT_SYMBOL(first_ec);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400124
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500125static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400126static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */
Alexey Starikovskiy478fa032009-10-02 20:21:40 +0400127static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */
Kieran Clancyad332c82014-03-01 00:42:28 +1030128static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
Lv Zheng79149002014-10-29 11:33:49 +0800129static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +0800132 * Transaction Management
133 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400135static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300137 u8 x = inb(ec->command_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800138
Lv Zhengdd43de22014-06-15 08:42:42 +0800139 pr_debug("EC_SC(R) = 0x%2.2x "
140 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d\n",
141 x,
142 !!(x & ACPI_EC_FLAG_SCI),
143 !!(x & ACPI_EC_FLAG_BURST),
144 !!(x & ACPI_EC_FLAG_CMD),
145 !!(x & ACPI_EC_FLAG_IBF),
146 !!(x & ACPI_EC_FLAG_OBF));
Márton Németh3ebe08a2007-11-21 03:23:26 +0300147 return x;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400150static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400151{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300152 u8 x = inb(ec->data_addr);
Lv Zheng7a73e602014-10-14 14:24:01 +0800153
Lv Zhengdd43de22014-06-15 08:42:42 +0800154 pr_debug("EC_DATA(R) = 0x%2.2x\n", x);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400155 return x;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400156}
157
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400158static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400159{
Lv Zhengdd43de22014-06-15 08:42:42 +0800160 pr_debug("EC_SC(W) = 0x%2.2x\n", command);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400161 outb(command, ec->command_addr);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400162}
163
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400164static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400165{
Lv Zhengdd43de22014-06-15 08:42:42 +0800166 pr_debug("EC_DATA(W) = 0x%2.2x\n", data);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400167 outb(data, ec->data_addr);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400168}
169
Lv Zhenge34c0e22014-10-14 14:23:49 +0800170#ifdef DEBUG
171static const char *acpi_ec_cmd_string(u8 cmd)
172{
173 switch (cmd) {
174 case 0x80:
175 return "RD_EC";
176 case 0x81:
177 return "WR_EC";
178 case 0x82:
179 return "BE_EC";
180 case 0x83:
181 return "BD_EC";
182 case 0x84:
183 return "QR_EC";
184 }
185 return "UNKNOWN";
186}
187#else
188#define acpi_ec_cmd_string(cmd) "UNDEF"
189#endif
190
Lv Zhengf92fca02014-06-15 08:41:35 +0800191static int ec_transaction_completed(struct acpi_ec *ec)
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400192{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400193 unsigned long flags;
194 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800195
Feng Tangf351d022012-10-23 01:29:27 +0200196 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengc0d65342014-06-15 08:42:07 +0800197 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400198 ret = 1;
Feng Tangf351d022012-10-23 01:29:27 +0200199 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400200 return ret;
201}
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400202
Lv Zhengc0d65342014-06-15 08:42:07 +0800203static bool advance_transaction(struct acpi_ec *ec)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400204{
Puneet Kumar36b15872013-11-15 11:41:29 -0800205 struct transaction *t;
Lv Zheng66b42b72014-06-15 08:41:17 +0800206 u8 status;
Lv Zhengc0d65342014-06-15 08:42:07 +0800207 bool wakeup = false;
Feng Tangb76b51b2012-10-23 01:29:38 +0200208
Lv Zhengc95f25b2014-10-14 14:23:38 +0800209 pr_debug("===== %s (%d) =====\n",
210 in_interrupt() ? "IRQ" : "TASK", smp_processor_id());
Lv Zheng66b42b72014-06-15 08:41:17 +0800211 status = acpi_ec_read_status(ec);
Puneet Kumar36b15872013-11-15 11:41:29 -0800212 t = ec->curr;
Feng Tangb76b51b2012-10-23 01:29:38 +0200213 if (!t)
Lv Zhengf92fca02014-06-15 08:41:35 +0800214 goto err;
215 if (t->flags & ACPI_EC_COMMAND_POLL) {
216 if (t->wlen > t->wi) {
217 if ((status & ACPI_EC_FLAG_IBF) == 0)
218 acpi_ec_write_data(ec, t->wdata[t->wi++]);
219 else
220 goto err;
221 } else if (t->rlen > t->ri) {
222 if ((status & ACPI_EC_FLAG_OBF) == 1) {
223 t->rdata[t->ri++] = acpi_ec_read_data(ec);
Lv Zhengc0d65342014-06-15 08:42:07 +0800224 if (t->rlen == t->ri) {
Lv Zhengf92fca02014-06-15 08:41:35 +0800225 t->flags |= ACPI_EC_COMMAND_COMPLETE;
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800226 if (t->command == ACPI_EC_COMMAND_QUERY)
Lv Zhenge34c0e22014-10-14 14:23:49 +0800227 pr_debug("***** Command(%s) hardware completion *****\n",
228 acpi_ec_cmd_string(t->command));
Lv Zhengc0d65342014-06-15 08:42:07 +0800229 wakeup = true;
230 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800231 } else
232 goto err;
233 } else if (t->wlen == t->wi &&
Lv Zhengc0d65342014-06-15 08:42:07 +0800234 (status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf92fca02014-06-15 08:41:35 +0800235 t->flags |= ACPI_EC_COMMAND_COMPLETE;
Lv Zhengc0d65342014-06-15 08:42:07 +0800236 wakeup = true;
237 }
238 return wakeup;
Lv Zhengf92fca02014-06-15 08:41:35 +0800239 } else {
Lv Zheng79149002014-10-29 11:33:49 +0800240 if (EC_FLAGS_QUERY_HANDSHAKE &&
241 !(status & ACPI_EC_FLAG_SCI) &&
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800242 (t->command == ACPI_EC_COMMAND_QUERY)) {
243 t->flags |= ACPI_EC_COMMAND_POLL;
244 t->rdata[t->ri++] = 0x00;
245 t->flags |= ACPI_EC_COMMAND_COMPLETE;
Lv Zhenge34c0e22014-10-14 14:23:49 +0800246 pr_debug("***** Command(%s) software completion *****\n",
247 acpi_ec_cmd_string(t->command));
Lv Zheng3afcf2e2014-08-21 14:41:13 +0800248 wakeup = true;
249 } else if ((status & ACPI_EC_FLAG_IBF) == 0) {
Lv Zhengf92fca02014-06-15 08:41:35 +0800250 acpi_ec_write_cmd(ec, t->command);
251 t->flags |= ACPI_EC_COMMAND_POLL;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400252 } else
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300253 goto err;
Lv Zhengc0d65342014-06-15 08:42:07 +0800254 return wakeup;
Lv Zhengf92fca02014-06-15 08:41:35 +0800255 }
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300256err:
Feng Tanga3cd8d22012-10-23 01:30:12 +0200257 /*
258 * If SCI bit is set, then don't think it's a false IRQ
259 * otherwise will take a not handled IRQ as a false one.
260 */
Lv Zhengf92fca02014-06-15 08:41:35 +0800261 if (!(status & ACPI_EC_FLAG_SCI)) {
262 if (in_interrupt() && t)
263 ++t->irq_count;
264 }
Lv Zhengc0d65342014-06-15 08:42:07 +0800265 return wakeup;
Lv Zhengf92fca02014-06-15 08:41:35 +0800266}
Feng Tanga3cd8d22012-10-23 01:30:12 +0200267
Lv Zhengf92fca02014-06-15 08:41:35 +0800268static void start_transaction(struct acpi_ec *ec)
269{
270 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
271 ec->curr->flags = 0;
Lv Zhengc0d65342014-06-15 08:42:07 +0800272 (void)advance_transaction(ec);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400273}
274
Kieran Clancy3eba5632014-04-30 00:21:20 +0930275static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400276
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300277static int ec_check_sci_sync(struct acpi_ec *ec, u8 state)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400278{
279 if (state & ACPI_EC_FLAG_SCI) {
280 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
Kieran Clancy3eba5632014-04-30 00:21:20 +0930281 return acpi_ec_sync_query(ec, NULL);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400282 }
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400283 return 0;
284}
285
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400286static int ec_poll(struct acpi_ec *ec)
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300287{
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400288 unsigned long flags;
Lan Tianyu28fe5c82013-05-06 03:23:40 +0000289 int repeat = 5; /* number of command restarts */
Lv Zheng7a73e602014-10-14 14:24:01 +0800290
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400291 while (repeat--) {
292 unsigned long delay = jiffies +
Thomas Renninger7a18e962010-10-21 18:24:57 +0200293 msecs_to_jiffies(ec_delay);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400294 do {
295 /* don't sleep with disabled interrupts */
296 if (EC_FLAGS_MSI || irqs_disabled()) {
297 udelay(ACPI_EC_MSI_UDELAY);
Lv Zhengf92fca02014-06-15 08:41:35 +0800298 if (ec_transaction_completed(ec))
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400299 return 0;
300 } else {
301 if (wait_event_timeout(ec->wait,
Lv Zhengf92fca02014-06-15 08:41:35 +0800302 ec_transaction_completed(ec),
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400303 msecs_to_jiffies(1)))
304 return 0;
305 }
Lv Zhengf92fca02014-06-15 08:41:35 +0800306 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengc0d65342014-06-15 08:42:07 +0800307 (void)advance_transaction(ec);
Lv Zhengf92fca02014-06-15 08:41:35 +0800308 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400309 } while (time_before(jiffies, delay));
Lan Tianyu16a26e82013-09-12 03:32:04 -0400310 pr_debug("controller reset, restart transaction\n");
Feng Tangf351d022012-10-23 01:29:27 +0200311 spin_lock_irqsave(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400312 start_transaction(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200313 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiyaf3fd142006-12-07 18:42:16 +0300314 }
Alexey Starikovskiyb77d81b2008-03-21 17:07:15 +0300315 return -ETIME;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500316}
317
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400318static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400319 struct transaction *t)
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400320{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400321 unsigned long tmp;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400322 int ret = 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800323
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500324 if (EC_FLAGS_MSI)
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400325 udelay(ACPI_EC_MSI_UDELAY);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400326 /* start transaction */
Feng Tangf351d022012-10-23 01:29:27 +0200327 spin_lock_irqsave(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400328 /* following two actions should be kept atomic */
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400329 ec->curr = t;
Lv Zhenge34c0e22014-10-14 14:23:49 +0800330 pr_debug("***** Command(%s) started *****\n",
331 acpi_ec_cmd_string(t->command));
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300332 start_transaction(ec);
Lv Zhengd3090b62014-10-14 14:23:55 +0800333 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
Lv Zheng558e4732014-08-21 14:41:26 +0800334 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
Lv Zhengd3090b62014-10-14 14:23:55 +0800335 pr_debug("***** Event stopped *****\n");
336 }
Lv Zhengdf9ff912014-10-29 11:33:43 +0800337 spin_unlock_irqrestore(&ec->lock, tmp);
338 ret = ec_poll(ec);
339 spin_lock_irqsave(&ec->lock, tmp);
Lv Zhenge34c0e22014-10-14 14:23:49 +0800340 pr_debug("***** Command(%s) stopped *****\n",
341 acpi_ec_cmd_string(t->command));
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400342 ec->curr = NULL;
Feng Tangf351d022012-10-23 01:29:27 +0200343 spin_unlock_irqrestore(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400344 return ret;
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400345}
346
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400347static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
Luming Yu45bea152005-07-23 04:08:00 -0400348{
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400349 int status;
Len Brown50526df2005-08-11 17:32:05 -0400350 u32 glk;
Lv Zheng7a73e602014-10-14 14:24:01 +0800351
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400352 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
Patrick Mocheld550d982006-06-27 00:41:40 -0400353 return -EINVAL;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400354 if (t->rdata)
355 memset(t->rdata, 0, t->rlen);
Feng Tangf351d022012-10-23 01:29:27 +0200356 mutex_lock(&ec->mutex);
Rafael J. Wysockife955682010-04-09 01:40:38 +0200357 if (test_bit(EC_FLAGS_BLOCKED, &ec->flags)) {
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100358 status = -EINVAL;
359 goto unlock;
360 }
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400361 if (ec->global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300363 if (ACPI_FAILURE(status)) {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400364 status = -ENODEV;
365 goto unlock;
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300366 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 }
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300368 /* disable GPE during transaction if storm is detected */
369 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
Rafael J. Wysocki37847302010-06-25 01:21:42 +0200370 /* It has to be disabled, so that it doesn't trigger. */
371 acpi_disable_gpe(NULL, ec->gpe);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300372 }
373
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400374 status = acpi_ec_transaction_unlocked(ec, t);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300375
376 /* check if we received SCI during transaction */
377 ec_check_sci_sync(ec, acpi_ec_read_status(ec));
378 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
Alexey Starikovskiy54070102009-12-30 15:53:10 +0300379 msleep(1);
Rafael J. Wysocki37847302010-06-25 01:21:42 +0200380 /* It is safe to enable the GPE outside of the transaction. */
381 acpi_enable_gpe(NULL, ec->gpe);
Feng Tanga520d522012-09-28 15:22:00 +0800382 } else if (t->irq_count > ec_storm_threshold) {
Lan Tianyu16a26e82013-09-12 03:32:04 -0400383 pr_info("GPE storm detected(%d GPEs), "
Feng Tangb76b51b2012-10-23 01:29:38 +0200384 "transactions will use polling mode\n",
385 t->irq_count);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300386 set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
387 }
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400388 if (ec->global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 acpi_release_global_lock(glk);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400390unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200391 mutex_unlock(&ec->mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400392 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
Roel Kluin8a383ef2008-12-09 20:45:30 +0100395static int acpi_ec_burst_enable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300396{
397 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400398 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
399 .wdata = NULL, .rdata = &d,
400 .wlen = 0, .rlen = 1};
401
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400402 return acpi_ec_transaction(ec, &t);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300403}
404
Roel Kluin8a383ef2008-12-09 20:45:30 +0100405static int acpi_ec_burst_disable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300406{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400407 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
408 .wdata = NULL, .rdata = NULL,
409 .wlen = 0, .rlen = 0};
410
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400411 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400412 acpi_ec_transaction(ec, &t) : 0;
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300413}
414
Lv Zheng7a73e602014-10-14 14:24:01 +0800415static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400416{
417 int result;
418 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400419 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
420 .wdata = &address, .rdata = &d,
421 .wlen = 1, .rlen = 1};
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400422
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400423 result = acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400424 *data = d;
425 return result;
426}
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400427
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400428static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
429{
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300430 u8 wdata[2] = { address, data };
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400431 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
432 .wdata = wdata, .rdata = NULL,
433 .wlen = 2, .rlen = 0};
434
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400435 return acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400436}
437
Feng Tangb76b51b2012-10-23 01:29:38 +0200438int ec_read(u8 addr, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 int err;
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400441 u8 temp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443 if (!first_ec)
444 return -ENODEV;
445
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300446 err = acpi_ec_read(first_ec, addr, &temp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
448 if (!err) {
449 *val = temp_data;
450 return 0;
Lv Zheng7a73e602014-10-14 14:24:01 +0800451 }
452 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454EXPORT_SYMBOL(ec_read);
455
Len Brown50526df2005-08-11 17:32:05 -0400456int ec_write(u8 addr, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 int err;
459
460 if (!first_ec)
461 return -ENODEV;
462
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300463 err = acpi_ec_write(first_ec, addr, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465 return err;
466}
467EXPORT_SYMBOL(ec_write);
468
Randy Dunlap616362d2006-10-27 01:47:34 -0400469int ec_transaction(u8 command,
Lv Zheng7a73e602014-10-14 14:24:01 +0800470 const u8 *wdata, unsigned wdata_len,
471 u8 *rdata, unsigned rdata_len)
Luming Yu45bea152005-07-23 04:08:00 -0400472{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400473 struct transaction t = {.command = command,
474 .wdata = wdata, .rdata = rdata,
475 .wlen = wdata_len, .rlen = rdata_len};
Lv Zheng7a73e602014-10-14 14:24:01 +0800476
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400477 if (!first_ec)
478 return -ENODEV;
479
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400480 return acpi_ec_transaction(first_ec, &t);
Luming Yu45bea152005-07-23 04:08:00 -0400481}
Lennart Poetteringab9e43c2006-10-03 22:49:00 -0400482EXPORT_SYMBOL(ec_transaction);
483
Seth Forshee3e2abc52012-01-18 13:44:08 -0600484/* Get the handle to the EC device */
485acpi_handle ec_get_handle(void)
486{
487 if (!first_ec)
488 return NULL;
489 return first_ec->handle;
490}
Seth Forshee3e2abc52012-01-18 13:44:08 -0600491EXPORT_SYMBOL(ec_get_handle);
492
Kieran Clancyad332c82014-03-01 00:42:28 +1030493/*
Kieran Clancy3eba5632014-04-30 00:21:20 +0930494 * Process _Q events that might have accumulated in the EC.
Kieran Clancyad332c82014-03-01 00:42:28 +1030495 * Run with locked ec mutex.
496 */
497static void acpi_ec_clear(struct acpi_ec *ec)
498{
499 int i, status;
500 u8 value = 0;
501
502 for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
Kieran Clancy3eba5632014-04-30 00:21:20 +0930503 status = acpi_ec_sync_query(ec, &value);
Kieran Clancyad332c82014-03-01 00:42:28 +1030504 if (status || !value)
505 break;
506 }
507
508 if (unlikely(i == ACPI_EC_CLEAR_MAX))
509 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
510 else
511 pr_info("%d stale EC events cleared\n", i);
512}
513
Rafael J. Wysockife955682010-04-09 01:40:38 +0200514void acpi_ec_block_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100515{
516 struct acpi_ec *ec = first_ec;
517
518 if (!ec)
519 return;
520
Feng Tangf351d022012-10-23 01:29:27 +0200521 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100522 /* Prevent transactions from being carried out */
Rafael J. Wysockife955682010-04-09 01:40:38 +0200523 set_bit(EC_FLAGS_BLOCKED, &ec->flags);
Feng Tangf351d022012-10-23 01:29:27 +0200524 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100525}
526
Rafael J. Wysockife955682010-04-09 01:40:38 +0200527void acpi_ec_unblock_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100528{
529 struct acpi_ec *ec = first_ec;
530
531 if (!ec)
532 return;
533
Feng Tangf351d022012-10-23 01:29:27 +0200534 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100535 /* Allow transactions to be carried out again */
Rafael J. Wysockife955682010-04-09 01:40:38 +0200536 clear_bit(EC_FLAGS_BLOCKED, &ec->flags);
Kieran Clancyad332c82014-03-01 00:42:28 +1030537
538 if (EC_FLAGS_CLEAR_ON_RESUME)
539 acpi_ec_clear(ec);
540
Feng Tangf351d022012-10-23 01:29:27 +0200541 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100542}
543
Rafael J. Wysockife955682010-04-09 01:40:38 +0200544void acpi_ec_unblock_transactions_early(void)
Rafael J. Wysockid5a64512010-04-09 01:39:40 +0200545{
546 /*
547 * Allow transactions to happen again (this function is called from
548 * atomic context during wakeup, so we don't need to acquire the mutex).
549 */
550 if (first_ec)
Rafael J. Wysockife955682010-04-09 01:40:38 +0200551 clear_bit(EC_FLAGS_BLOCKED, &first_ec->flags);
Rafael J. Wysockid5a64512010-04-09 01:39:40 +0200552}
553
Lv Zheng7a73e602014-10-14 14:24:01 +0800554static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 *data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400555{
556 int result;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300557 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400558 struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
559 .wdata = NULL, .rdata = &d,
560 .wlen = 0, .rlen = 1};
Lv Zheng7a73e602014-10-14 14:24:01 +0800561
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300562 if (!ec || !data)
563 return -EINVAL;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300564 /*
565 * Query the EC to find out which _Qxx method we need to evaluate.
566 * Note that successful completion of the query causes the ACPI_EC_SCI
567 * bit to be cleared (and thus clearing the interrupt source).
568 */
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300569 result = acpi_ec_transaction_unlocked(ec, &t);
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300570 if (result)
571 return result;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300572 if (!d)
573 return -ENODATA;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300574 *data = d;
575 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
577
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578/* --------------------------------------------------------------------------
579 Event Management
580 -------------------------------------------------------------------------- */
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400581int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
582 acpi_handle handle, acpi_ec_query_func func,
583 void *data)
584{
585 struct acpi_ec_query_handler *handler =
586 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +0800587
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400588 if (!handler)
589 return -ENOMEM;
590
591 handler->query_bit = query_bit;
592 handler->handle = handle;
593 handler->func = func;
594 handler->data = data;
Feng Tangf351d022012-10-23 01:29:27 +0200595 mutex_lock(&ec->mutex);
Alexey Starikovskiy30c08572007-09-26 19:43:22 +0400596 list_add(&handler->node, &ec->list);
Feng Tangf351d022012-10-23 01:29:27 +0200597 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400598 return 0;
599}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400600EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
601
602void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
603{
Adrian Bunk1544fdb2007-10-24 18:26:00 +0200604 struct acpi_ec_query_handler *handler, *tmp;
Lv Zheng7a73e602014-10-14 14:24:01 +0800605
Feng Tangf351d022012-10-23 01:29:27 +0200606 mutex_lock(&ec->mutex);
Adrian Bunk1544fdb2007-10-24 18:26:00 +0200607 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400608 if (query_bit == handler->query_bit) {
609 list_del(&handler->node);
610 kfree(handler);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400611 }
612 }
Feng Tangf351d022012-10-23 01:29:27 +0200613 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400614}
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400615EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300617static void acpi_ec_run(void *cxt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300619 struct acpi_ec_query_handler *handler = cxt;
Lv Zheng7a73e602014-10-14 14:24:01 +0800620
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300621 if (!handler)
Alexey Starikovskiye41334c2006-12-07 18:42:16 +0300622 return;
Lv Zhengd3090b62014-10-14 14:23:55 +0800623 pr_debug("##### Query(0x%02x) started #####\n", handler->query_bit);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300624 if (handler->func)
625 handler->func(handler->data);
626 else if (handler->handle)
627 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
Lv Zhengd3090b62014-10-14 14:23:55 +0800628 pr_debug("##### Query(0x%02x) stopped #####\n", handler->query_bit);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300629 kfree(handler);
630}
631
Kieran Clancy3eba5632014-04-30 00:21:20 +0930632static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300633{
634 u8 value = 0;
635 int status;
636 struct acpi_ec_query_handler *handler, *copy;
Kieran Clancy3eba5632014-04-30 00:21:20 +0930637
638 status = acpi_ec_query_unlocked(ec, &value);
639 if (data)
640 *data = value;
641 if (status)
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300642 return status;
Kieran Clancy3eba5632014-04-30 00:21:20 +0930643
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400644 list_for_each_entry(handler, &ec->list, node) {
645 if (value == handler->query_bit) {
646 /* have custom handler for this bit */
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300647 copy = kmalloc(sizeof(*handler), GFP_KERNEL);
648 if (!copy)
649 return -ENOMEM;
650 memcpy(copy, handler, sizeof(*copy));
Lv Zhengd3090b62014-10-14 14:23:55 +0800651 pr_debug("##### Query(0x%02x) scheduled #####\n",
652 handler->query_bit);
Alexey Starikovskiyf5347862009-12-30 15:53:03 +0300653 return acpi_os_execute((copy->func) ?
654 OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER,
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300655 acpi_ec_run, copy);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400656 }
657 }
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300658 return 0;
659}
660
661static void acpi_ec_gpe_query(void *ec_cxt)
662{
663 struct acpi_ec *ec = ec_cxt;
Lv Zheng7a73e602014-10-14 14:24:01 +0800664
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300665 if (!ec)
666 return;
Feng Tangf351d022012-10-23 01:29:27 +0200667 mutex_lock(&ec->mutex);
Kieran Clancy3eba5632014-04-30 00:21:20 +0930668 acpi_ec_sync_query(ec, NULL);
Feng Tangf351d022012-10-23 01:29:27 +0200669 mutex_unlock(&ec->mutex);
Luming Yu45bea152005-07-23 04:08:00 -0400670}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300672static int ec_check_sci(struct acpi_ec *ec, u8 state)
673{
674 if (state & ACPI_EC_FLAG_SCI) {
675 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
Lv Zhengd3090b62014-10-14 14:23:55 +0800676 pr_debug("***** Event started *****\n");
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300677 return acpi_os_execute(OSL_NOTIFY_HANDLER,
678 acpi_ec_gpe_query, ec);
679 }
680 }
681 return 0;
682}
683
Lin Ming8b6cd8a2010-12-13 13:38:46 +0800684static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
685 u32 gpe_number, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686{
Lv Zhengf92fca02014-06-15 08:41:35 +0800687 unsigned long flags;
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +0300688 struct acpi_ec *ec = data;
Lennart Poettering00eb43a2007-05-04 14:16:19 +0200689
Lv Zhengf92fca02014-06-15 08:41:35 +0800690 spin_lock_irqsave(&ec->lock, flags);
Lv Zhengc0d65342014-06-15 08:42:07 +0800691 if (advance_transaction(ec))
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400692 wake_up(&ec->wait);
Lv Zhengc0d65342014-06-15 08:42:07 +0800693 spin_unlock_irqrestore(&ec->lock, flags);
694 ec_check_sci(ec, acpi_ec_read_status(ec));
Lin Mingbba63a22010-12-13 13:39:17 +0800695 return ACPI_INTERRUPT_HANDLED | ACPI_REENABLE_GPE;
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300696}
697
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +0800699 * Address Space Management
700 * -------------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702static acpi_status
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +0400703acpi_ec_space_handler(u32 function, acpi_physical_address address,
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400704 u32 bits, u64 *value64,
Len Brown50526df2005-08-11 17:32:05 -0400705 void *handler_context, void *region_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +0300707 struct acpi_ec *ec = handler_context;
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400708 int result = 0, i, bytes = bits / 8;
709 u8 *value = (u8 *)value64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if ((address > 0xFF) || !value || !handler_context)
Patrick Mocheld550d982006-06-27 00:41:40 -0400712 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +0400714 if (function != ACPI_READ && function != ACPI_WRITE)
Patrick Mocheld550d982006-06-27 00:41:40 -0400715 return AE_BAD_PARAMETER;
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +0400716
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400717 if (EC_FLAGS_MSI || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +0400718 acpi_ec_burst_enable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +0300719
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400720 for (i = 0; i < bytes; ++i, ++address, ++value)
721 result = (function == ACPI_READ) ?
722 acpi_ec_read(ec, address, value) :
723 acpi_ec_write(ec, address, *value);
Alexey Starikovskiy3e71a872008-01-11 02:42:51 +0300724
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400725 if (EC_FLAGS_MSI || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +0400726 acpi_ec_burst_disable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +0300727
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 switch (result) {
729 case -EINVAL:
Patrick Mocheld550d982006-06-27 00:41:40 -0400730 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 case -ENODEV:
Patrick Mocheld550d982006-06-27 00:41:40 -0400732 return AE_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 case -ETIME:
Patrick Mocheld550d982006-06-27 00:41:40 -0400734 return AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 default:
Patrick Mocheld550d982006-06-27 00:41:40 -0400736 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740/* --------------------------------------------------------------------------
Lv Zheng7a73e602014-10-14 14:24:01 +0800741 * Driver Interface
742 * -------------------------------------------------------------------------- */
743
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300744static acpi_status
745ec_parse_io_ports(struct acpi_resource *resource, void *context);
746
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300747static struct acpi_ec *make_acpi_ec(void)
748{
749 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
Lv Zheng7a73e602014-10-14 14:24:01 +0800750
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300751 if (!ec)
752 return NULL;
Alexey Starikovskiy080e4122007-10-22 14:18:30 +0400753 ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
Feng Tangf351d022012-10-23 01:29:27 +0200754 mutex_init(&ec->mutex);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300755 init_waitqueue_head(&ec->wait);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400756 INIT_LIST_HEAD(&ec->list);
Feng Tangf351d022012-10-23 01:29:27 +0200757 spin_lock_init(&ec->lock);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300758 return ec;
759}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400761static acpi_status
Alexey Starikovskiyc019b192007-08-14 01:03:42 -0400762acpi_ec_register_query_methods(acpi_handle handle, u32 level,
763 void *context, void **return_value)
764{
Lin Ming0175d562008-12-16 16:46:12 +0800765 char node_name[5];
766 struct acpi_buffer buffer = { sizeof(node_name), node_name };
Alexey Starikovskiyc019b192007-08-14 01:03:42 -0400767 struct acpi_ec *ec = context;
768 int value = 0;
Lin Ming0175d562008-12-16 16:46:12 +0800769 acpi_status status;
770
771 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
772
Lv Zheng7a73e602014-10-14 14:24:01 +0800773 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
Alexey Starikovskiyc019b192007-08-14 01:03:42 -0400774 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
Alexey Starikovskiyc019b192007-08-14 01:03:42 -0400775 return AE_OK;
776}
777
778static acpi_status
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400779ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400780{
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400781 acpi_status status;
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -0500782 unsigned long long tmp = 0;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400783 struct acpi_ec *ec = context;
Alexey Starikovskiya5032bf2009-04-01 01:33:15 -0400784
785 /* clear addr values, ec_parse_io_ports depend on it */
786 ec->command_addr = ec->data_addr = 0;
787
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400788 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
789 ec_parse_io_ports, ec);
790 if (ACPI_FAILURE(status))
791 return status;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400792
793 /* Get GPE bit assignment (EC events). */
794 /* TODO: Add support for _GPE returning a package */
Matthew Wilcox27663c52008-10-10 02:22:59 -0400795 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400796 if (ACPI_FAILURE(status))
797 return status;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400798 ec->gpe = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400799 /* Use the global lock for all EC transactions? */
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -0500800 tmp = 0;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400801 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
802 ec->global_lock = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400803 ec->handle = handle;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400804 return AE_CTRL_TERMINATE;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400805}
806
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300807static int ec_install_handlers(struct acpi_ec *ec)
808{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300809 acpi_status status;
Lv Zheng7a73e602014-10-14 14:24:01 +0800810
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400811 if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
Alexey Starikovskiy4c611062007-09-05 19:56:38 -0400812 return 0;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300813 status = acpi_install_gpe_handler(NULL, ec->gpe,
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400814 ACPI_GPE_EDGE_TRIGGERED,
815 &acpi_ec_gpe_handler, ec);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300816 if (ACPI_FAILURE(status))
817 return -ENODEV;
Rafael J. Wysocki9630bdd2010-02-17 23:41:07 +0100818
Rafael J. Wysockia44061a2010-07-01 10:11:45 +0800819 acpi_enable_gpe(NULL, ec->gpe);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300820 status = acpi_install_address_space_handler(ec->handle,
821 ACPI_ADR_SPACE_EC,
822 &acpi_ec_space_handler,
Alexey Starikovskiy6d9e1122008-03-24 23:22:29 +0300823 NULL, ec);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300824 if (ACPI_FAILURE(status)) {
Zhao Yakui20edd742008-10-17 02:02:44 -0400825 if (status == AE_NOT_FOUND) {
826 /*
827 * Maybe OS fails in evaluating the _REG object.
828 * The AE_NOT_FOUND error will be ignored and OS
829 * continue to initialize EC.
830 */
Lan Tianyu16a26e82013-09-12 03:32:04 -0400831 pr_err("Fail in evaluating the _REG object"
Zhao Yakui20edd742008-10-17 02:02:44 -0400832 " of EC device. Broken bios is suspected.\n");
833 } else {
Lan Tianyu42b946b2013-12-12 18:08:52 +0800834 acpi_disable_gpe(NULL, ec->gpe);
Zhao Yakui20edd742008-10-17 02:02:44 -0400835 acpi_remove_gpe_handler(NULL, ec->gpe,
836 &acpi_ec_gpe_handler);
837 return -ENODEV;
838 }
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300839 }
840
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400841 set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300842 return 0;
843}
844
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845static void ec_remove_handlers(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846{
Lv Zheng1741acea2014-12-15 08:47:52 +0800847 if (!test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
848 return;
Rafael J. Wysockia44061a2010-07-01 10:11:45 +0800849 acpi_disable_gpe(NULL, ec->gpe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
851 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
Lan Tianyu16a26e82013-09-12 03:32:04 -0400852 pr_err("failed to remove space handler\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
854 &acpi_ec_gpe_handler)))
Lan Tianyu16a26e82013-09-12 03:32:04 -0400855 pr_err("failed to remove gpe handler\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
857}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859static int acpi_ec_add(struct acpi_device *device)
860{
861 struct acpi_ec *ec = NULL;
Bjorn Helgaasd02be042009-06-22 20:41:35 +0000862 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
865 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 /* Check for boot EC */
868 if (boot_ec &&
869 (boot_ec->handle == device->handle ||
870 boot_ec->handle == ACPI_ROOT_OBJECT)) {
871 ec = boot_ec;
872 boot_ec = NULL;
873 } else {
874 ec = make_acpi_ec();
875 if (!ec)
876 return -ENOMEM;
877 }
878 if (ec_parse_device(device->handle, 0, ec, NULL) !=
879 AE_CTRL_TERMINATE) {
880 kfree(ec);
881 return -EINVAL;
882 }
883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 /* Find and register all query methods */
885 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
Lin Ming22635762009-11-13 10:06:08 +0800886 acpi_ec_register_query_methods, NULL, ec, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888 if (!first_ec)
889 first_ec = ec;
890 device->driver_data = ec;
Thomas Renningerde4f1042010-07-29 22:08:44 +0200891
Andi Kleend6795fe32012-02-06 08:17:08 -0800892 ret = !!request_region(ec->data_addr, 1, "EC data");
893 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
894 ret = !!request_region(ec->command_addr, 1, "EC cmd");
895 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
Thomas Renningerde4f1042010-07-29 22:08:44 +0200896
Lan Tianyu16a26e82013-09-12 03:32:04 -0400897 pr_info("GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 ec->gpe, ec->command_addr, ec->data_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
Alexey Starikovskiy4c611062007-09-05 19:56:38 -0400900 ret = ec_install_handlers(ec);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300901
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400902 /* EC is fully operational, allow queries */
Alexey Starikovskiy080e4122007-10-22 14:18:30 +0400903 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
Kieran Clancyad332c82014-03-01 00:42:28 +1030904
905 /* Clear stale _Q events if hardware might require that */
906 if (EC_FLAGS_CLEAR_ON_RESUME) {
907 mutex_lock(&ec->mutex);
908 acpi_ec_clear(ec);
909 mutex_unlock(&ec->mutex);
910 }
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400911 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912}
913
Rafael J. Wysocki51fac832013-01-24 00:24:48 +0100914static int acpi_ec_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300916 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 struct acpi_ec_query_handler *handler, *tmp;
918
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400920 return -EINVAL;
Alexey Starikovskiyf9319f92007-08-24 08:10:11 +0400921
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 ec = acpi_driver_data(device);
Bjorn Helgaascf745ec2009-06-22 20:41:40 +0000923 ec_remove_handlers(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200924 mutex_lock(&ec->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
926 list_del(&handler->node);
927 kfree(handler);
928 }
Feng Tangf351d022012-10-23 01:29:27 +0200929 mutex_unlock(&ec->mutex);
Thomas Renningerde4f1042010-07-29 22:08:44 +0200930 release_region(ec->data_addr, 1);
931 release_region(ec->command_addr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 device->driver_data = NULL;
933 if (ec == first_ec)
934 first_ec = NULL;
935 kfree(ec);
Patrick Mocheld550d982006-06-27 00:41:40 -0400936 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937}
938
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939static acpi_status
940ec_parse_io_ports(struct acpi_resource *resource, void *context)
941{
942 struct acpi_ec *ec = context;
943
944 if (resource->type != ACPI_RESOURCE_TYPE_IO)
945 return AE_OK;
946
947 /*
948 * The first address region returned is the data port, and
949 * the second address region returned is the status/command
950 * port.
951 */
Thomas Renningerde4f1042010-07-29 22:08:44 +0200952 if (ec->data_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 ec->data_addr = resource->data.io.minimum;
Thomas Renningerde4f1042010-07-29 22:08:44 +0200954 else if (ec->command_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 ec->command_addr = resource->data.io.minimum;
956 else
957 return AE_CTRL_TERMINATE;
958
959 return AE_OK;
960}
961
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -0500962int __init acpi_boot_ec_enable(void)
963{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400964 if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -0500965 return 0;
966 if (!ec_install_handlers(boot_ec)) {
967 first_ec = boot_ec;
968 return 0;
969 }
970 return -EFAULT;
971}
972
Alexey Starikovskiy223883b2008-03-21 17:07:21 +0300973static const struct acpi_device_id ec_device_ids[] = {
974 {"PNP0C09", 0},
975 {"", 0},
976};
977
Alexey Starikovskiy478fa032009-10-02 20:21:40 +0400978/* Some BIOS do not survive early DSDT scan, skip it */
979static int ec_skip_dsdt_scan(const struct dmi_system_id *id)
980{
981 EC_FLAGS_SKIP_DSDT_SCAN = 1;
982 return 0;
983}
984
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400985/* ASUStek often supplies us with broken ECDT, validate it */
986static int ec_validate_ecdt(const struct dmi_system_id *id)
987{
988 EC_FLAGS_VALIDATE_ECDT = 1;
989 return 0;
990}
991
992/* MSI EC needs special treatment, enable it */
993static int ec_flag_msi(const struct dmi_system_id *id)
994{
Lan Tianyu16a26e82013-09-12 03:32:04 -0400995 pr_debug("Detected MSI hardware, enabling workarounds.\n");
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400996 EC_FLAGS_MSI = 1;
997 EC_FLAGS_VALIDATE_ECDT = 1;
998 return 0;
999}
1000
Feng Tang67bfa9b2012-09-28 15:22:01 +08001001/*
1002 * Clevo M720 notebook actually works ok with IRQ mode, if we lifted
1003 * the GPE storm threshold back to 20
1004 */
1005static int ec_enlarge_storm_threshold(const struct dmi_system_id *id)
1006{
1007 pr_debug("Setting the EC GPE storm threshold to 20\n");
1008 ec_storm_threshold = 20;
1009 return 0;
1010}
1011
Kieran Clancyad332c82014-03-01 00:42:28 +10301012/*
Lv Zheng79149002014-10-29 11:33:49 +08001013 * Acer EC firmware refuses to respond QR_EC when SCI_EVT is not set, for
1014 * which case, we complete the QR_EC without issuing it to the firmware.
1015 * https://bugzilla.kernel.org/show_bug.cgi?id=86211
1016 */
1017static int ec_flag_query_handshake(const struct dmi_system_id *id)
1018{
1019 pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1020 EC_FLAGS_QUERY_HANDSHAKE = 1;
1021 return 0;
1022}
1023
1024/*
Kieran Clancyad332c82014-03-01 00:42:28 +10301025 * On some hardware it is necessary to clear events accumulated by the EC during
1026 * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1027 * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1028 *
1029 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1030 *
1031 * Ideally, the EC should also be instructed NOT to accumulate events during
1032 * sleep (which Windows seems to do somehow), but the interface to control this
1033 * behaviour is not known at this time.
1034 *
1035 * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1036 * however it is very likely that other Samsung models are affected.
1037 *
1038 * On systems which don't accumulate _Q events during sleep, this extra check
1039 * should be harmless.
1040 */
1041static int ec_clear_on_resume(const struct dmi_system_id *id)
1042{
1043 pr_debug("Detected system needing EC poll on resume.\n");
1044 EC_FLAGS_CLEAR_ON_RESUME = 1;
1045 return 0;
1046}
1047
Sachin Kamat6cef7492013-08-07 17:16:55 +05301048static struct dmi_system_id ec_dmi_table[] __initdata = {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001049 {
Alexey Starikovskiy478fa032009-10-02 20:21:40 +04001050 ec_skip_dsdt_scan, "Compal JFL92", {
1051 DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
1052 DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL},
1053 {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001054 ec_flag_msi, "MSI hardware", {
Alexey Starikovskiy55b313f2009-12-22 02:42:52 -05001055 DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL},
1056 {
1057 ec_flag_msi, "MSI hardware", {
1058 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL},
1059 {
1060 ec_flag_msi, "MSI hardware", {
1061 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL},
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001062 {
Alexey Starikovskiya5dc4f82010-12-09 17:07:54 -05001063 ec_flag_msi, "MSI hardware", {
1064 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
1065 {
Zhang Rui534bc4e2011-04-26 16:30:02 +08001066 ec_flag_msi, "Quanta hardware", {
1067 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1068 DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
1069 {
1070 ec_flag_msi, "Quanta hardware", {
1071 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1072 DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
1073 {
Lan Tianyu777cb382014-08-29 10:50:08 +08001074 ec_flag_msi, "Clevo W350etq", {
1075 DMI_MATCH(DMI_SYS_VENDOR, "CLEVO CO."),
1076 DMI_MATCH(DMI_PRODUCT_NAME, "W35_37ET"),}, NULL},
1077 {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001078 ec_validate_ecdt, "ASUS hardware", {
1079 DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
Peter Collingbourneaf986d12011-04-24 22:09:32 +01001080 {
1081 ec_validate_ecdt, "ASUS hardware", {
1082 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
Feng Tang67bfa9b2012-09-28 15:22:01 +08001083 {
1084 ec_enlarge_storm_threshold, "CLEVO hardware", {
1085 DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
1086 DMI_MATCH(DMI_PRODUCT_NAME, "M720T/M730T"),}, NULL},
Lan Tianyueff9a4b2013-06-05 02:27:51 +00001087 {
1088 ec_skip_dsdt_scan, "HP Folio 13", {
1089 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1090 DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL},
Lan Tianyu524f42f2013-08-26 10:19:18 +08001091 {
1092 ec_validate_ecdt, "ASUS hardware", {
1093 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."),
1094 DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL},
Kieran Clancyad332c82014-03-01 00:42:28 +10301095 {
1096 ec_clear_on_resume, "Samsung hardware", {
1097 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
Lv Zheng79149002014-10-29 11:33:49 +08001098 {
1099 ec_flag_query_handshake, "Acer hardware", {
1100 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), }, NULL},
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001101 {},
1102};
1103
Len Brown50526df2005-08-11 17:32:05 -04001104int __init acpi_ec_ecdt_probe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001106 acpi_status status;
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001107 struct acpi_ec *saved_ec = NULL;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001108 struct acpi_table_ecdt *ecdt_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109
Alexey Starikovskiyd66d9692007-03-07 22:28:00 +03001110 boot_ec = make_acpi_ec();
1111 if (!boot_ec)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001112 return -ENOMEM;
1113 /*
1114 * Generate a boot ec context
1115 */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001116 dmi_check_system(ec_dmi_table);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001117 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1118 (struct acpi_table_header **)&ecdt_ptr);
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001119 if (ACPI_SUCCESS(status)) {
Lan Tianyu16a26e82013-09-12 03:32:04 -04001120 pr_info("EC description table is found, configuring boot EC\n");
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001121 boot_ec->command_addr = ecdt_ptr->control.address;
1122 boot_ec->data_addr = ecdt_ptr->data.address;
1123 boot_ec->gpe = ecdt_ptr->gpe;
Len Brown4af8e102008-03-11 00:27:16 -04001124 boot_ec->handle = ACPI_ROOT_OBJECT;
Lv Zheng7a73e602014-10-14 14:24:01 +08001125 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id,
1126 &boot_ec->handle);
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001127 /* Don't trust ECDT, which comes from ASUSTek */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001128 if (!EC_FLAGS_VALIDATE_ECDT)
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001129 goto install;
Julia Lawalld6bd5352010-05-15 23:16:21 +02001130 saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001131 if (!saved_ec)
1132 return -ENOMEM;
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001133 /* fall through */
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001134 }
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001135
Colin Ian Kinged4b1972014-07-03 00:35:09 +01001136 if (EC_FLAGS_SKIP_DSDT_SCAN) {
1137 kfree(saved_ec);
Alexey Starikovskiy478fa032009-10-02 20:21:40 +04001138 return -ENODEV;
Colin Ian Kinged4b1972014-07-03 00:35:09 +01001139 }
Alexey Starikovskiy478fa032009-10-02 20:21:40 +04001140
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001141 /* This workaround is needed only on some broken machines,
1142 * which require early EC, but fail to provide ECDT */
Lan Tianyu16a26e82013-09-12 03:32:04 -04001143 pr_debug("Look up EC in DSDT\n");
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001144 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
1145 boot_ec, NULL);
1146 /* Check that acpi_get_devices actually find something */
1147 if (ACPI_FAILURE(status) || !boot_ec->handle)
1148 goto error;
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001149 if (saved_ec) {
1150 /* try to find good ECDT from ASUSTek */
1151 if (saved_ec->command_addr != boot_ec->command_addr ||
1152 saved_ec->data_addr != boot_ec->data_addr ||
1153 saved_ec->gpe != boot_ec->gpe ||
1154 saved_ec->handle != boot_ec->handle)
Lan Tianyu16a26e82013-09-12 03:32:04 -04001155 pr_info("ASUSTek keeps feeding us with broken "
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001156 "ECDT tables, which are very hard to workaround. "
1157 "Trying to use DSDT EC info instead. Please send "
1158 "output of acpidump to linux-acpi@vger.kernel.org\n");
1159 kfree(saved_ec);
1160 saved_ec = NULL;
1161 } else {
1162 /* We really need to limit this workaround, the only ASUS,
1163 * which needs it, has fake EC._INI method, so use it as flag.
1164 * Keep boot_ec struct as it will be needed soon.
1165 */
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001166 if (!dmi_name_in_vendors("ASUS") ||
Jiang Liu952c63e2013-06-29 00:24:38 +08001167 !acpi_has_method(boot_ec->handle, "_INI"))
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001168 return -ENODEV;
1169 }
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001170install:
1171 if (!ec_install_handlers(boot_ec)) {
Alexey Starikovskiyd0338792007-03-07 22:28:00 +03001172 first_ec = boot_ec;
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001173 return 0;
Alexey Starikovskiyd0338792007-03-07 22:28:00 +03001174 }
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001175error:
Alexey Starikovskiyd66d9692007-03-07 22:28:00 +03001176 kfree(boot_ec);
Colin Ian Kinged4b1972014-07-03 00:35:09 +01001177 kfree(saved_ec);
Alexey Starikovskiyd66d9692007-03-07 22:28:00 +03001178 boot_ec = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 return -ENODEV;
1180}
1181
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001182static struct acpi_driver acpi_ec_driver = {
1183 .name = "ec",
1184 .class = ACPI_EC_CLASS,
1185 .ids = ec_device_ids,
1186 .ops = {
1187 .add = acpi_ec_add,
1188 .remove = acpi_ec_remove,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001189 },
1190};
1191
Bjorn Helgaasa5f820f2009-03-24 16:49:48 -06001192int __init acpi_ec_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
Len Brown50526df2005-08-11 17:32:05 -04001194 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 /* Now register the driver for the EC */
1197 result = acpi_bus_register_driver(&acpi_ec_driver);
Thomas Renninger49c6c5f2010-07-16 13:11:34 +02001198 if (result < 0)
Patrick Mocheld550d982006-06-27 00:41:40 -04001199 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200
Patrick Mocheld550d982006-06-27 00:41:40 -04001201 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202}
1203
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204/* EC driver currently not unloadable */
1205#if 0
Len Brown50526df2005-08-11 17:32:05 -04001206static void __exit acpi_ec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
1209 acpi_bus_unregister_driver(&acpi_ec_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210}
Alexey Starikovskiy78439322007-10-22 14:18:43 +04001211#endif /* 0 */