blob: 80403c1a89f8969919c868e0fb3238e056adb581 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +04002 * ec.c - ACPI Embedded Controller Driver (v2.1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +04004 * Copyright (C) 2006-2008 Alexey Starikovskiy <astarikovskiy@suse.de>
Alexey Starikovskiy01f22462007-03-07 22:28:00 +03005 * Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
7 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
8 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
9 *
10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or (at
15 * your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License along
23 * with this program; if not, write to the Free Software Foundation, Inc.,
24 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25 *
26 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27 */
28
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040029/* Uncomment next line to get verbose printout */
Márton Némethd772b3b2008-01-23 22:34:09 -050030/* #define DEBUG */
31
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <asm/io.h>
42#include <acpi/acpi_bus.h>
43#include <acpi/acpi_drivers.h>
Len Browneb27cae2009-07-06 23:40:19 -040044#include <linux/dmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Thomas Renninger1195a092010-07-16 13:11:31 +020046#include "internal.h"
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#define ACPI_EC_CLASS "embedded_controller"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define ACPI_EC_DEVICE_NAME "Embedded Controller"
50#define ACPI_EC_FILE_INFO "info"
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040051
Thomas Renninger1195a092010-07-16 13:11:31 +020052#undef PREFIX
Alexey Starikovskiyaf3fd142006-12-07 18:42:16 +030053#define PREFIX "ACPI: EC: "
Alexey Starikovskiy43509332007-05-29 16:42:57 +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 */
Dmitry Torokhov451566f2005-03-19 01:10:05 -050058#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
Alexey Starikovskiy43509332007-05-29 16:42:57 +040060
Denis M. Sadykov703959d2006-09-26 19:50:33 +040061/* EC commands */
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030062enum ec_command {
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +030063 ACPI_EC_COMMAND_READ = 0x80,
64 ACPI_EC_COMMAND_WRITE = 0x81,
65 ACPI_EC_BURST_ENABLE = 0x82,
66 ACPI_EC_BURST_DISABLE = 0x83,
67 ACPI_EC_COMMAND_QUERY = 0x84,
Alexey Starikovskiy3261ff42006-12-07 18:42:17 +030068};
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040069
Alexey Starikovskiy5c406412006-12-07 18:42:16 +030070#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
Denis M. Sadykov703959d2006-09-26 19:50:33 +040071#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +040072#define ACPI_EC_MSI_UDELAY 550 /* Wait 550us for MSI EC */
Denis M. Sadykov703959d2006-09-26 19:50:33 +040073
Alexey Starikovskiy080e4122007-10-22 14:18:30 +040074enum {
Alexey Starikovskiy080e4122007-10-22 14:18:30 +040075 EC_FLAGS_QUERY_PENDING, /* Query is pending */
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040076 EC_FLAGS_GPE_STORM, /* GPE storm detected */
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +010077 EC_FLAGS_HANDLERS_INSTALLED, /* Handlers for GPE and
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +040078 * OpReg are installed */
Rafael J. Wysockife955682010-04-09 01:40:38 +020079 EC_FLAGS_BLOCKED, /* Transactions are blocked */
Linus Torvalds1da177e2005-04-16 15:20:36 -070080};
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +040081
Thomas Renninger7a18e962010-10-21 18:24:57 +020082/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
83static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
84module_param(ec_delay, uint, 0644);
85MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
86
Feng Tanga520d522012-09-28 15:22:00 +080087/*
88 * If the number of false interrupts per one transaction exceeds
89 * this threshold, will think there is a GPE storm happened and
90 * will disable the GPE for normal transaction.
91 */
92static unsigned int ec_storm_threshold __read_mostly = 8;
93module_param(ec_storm_threshold, uint, 0644);
94MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
95
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +040096/* If we find an EC via the ECDT, we need to keep a ptr to its context */
Alexey Starikovskiyd0338792007-03-07 22:28:00 +030097/* External interfaces use first EC only, so remember */
Alexey Starikovskiy837012e2007-05-29 16:43:02 +040098typedef int (*acpi_ec_query_func) (void *data);
99
100struct acpi_ec_query_handler {
101 struct list_head node;
102 acpi_ec_query_func func;
103 acpi_handle handle;
104 void *data;
105 u8 query_bit;
106};
107
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400108struct transaction {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400109 const u8 *wdata;
110 u8 *rdata;
111 unsigned short irq_count;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400112 u8 command;
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300113 u8 wi;
114 u8 ri;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400115 u8 wlen;
116 u8 rlen;
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300117 bool done;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400118};
119
Thomas Renninger1195a092010-07-16 13:11:31 +0200120struct acpi_ec *boot_ec, *first_ec;
121EXPORT_SYMBOL(first_ec);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400122
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500123static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400124static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */
Alexey Starikovskiy478fa032009-10-02 20:21:40 +0400125static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127/* --------------------------------------------------------------------------
128 Transaction Management
129 -------------------------------------------------------------------------- */
130
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400131static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300133 u8 x = inb(ec->command_addr);
Márton Németh86dae012008-01-23 22:33:06 -0500134 pr_debug(PREFIX "---> status = 0x%2.2x\n", x);
Márton Németh3ebe08a2007-11-21 03:23:26 +0300135 return x;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400138static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400139{
Márton Németh3ebe08a2007-11-21 03:23:26 +0300140 u8 x = inb(ec->data_addr);
Márton Németh86dae012008-01-23 22:33:06 -0500141 pr_debug(PREFIX "---> data = 0x%2.2x\n", x);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400142 return x;
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400143}
144
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400145static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400146{
Márton Németh86dae012008-01-23 22:33:06 -0500147 pr_debug(PREFIX "<--- command = 0x%2.2x\n", command);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400148 outb(command, ec->command_addr);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400149}
150
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400151static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400152{
Márton Németh86dae012008-01-23 22:33:06 -0500153 pr_debug(PREFIX "<--- data = 0x%2.2x\n", data);
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400154 outb(data, ec->data_addr);
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400155}
156
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400157static int ec_transaction_done(struct acpi_ec *ec)
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400158{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400159 unsigned long flags;
160 int ret = 0;
Feng Tangf351d022012-10-23 01:29:27 +0200161 spin_lock_irqsave(&ec->lock, flags);
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300162 if (!ec->curr || ec->curr->done)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400163 ret = 1;
Feng Tangf351d022012-10-23 01:29:27 +0200164 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400165 return ret;
166}
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400167
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300168static void start_transaction(struct acpi_ec *ec)
169{
170 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
171 ec->curr->done = false;
172 acpi_ec_write_cmd(ec, ec->curr->command);
173}
174
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400175static void advance_transaction(struct acpi_ec *ec, u8 status)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400176{
177 unsigned long flags;
Feng Tangb76b51b2012-10-23 01:29:38 +0200178 struct transaction *t = ec->curr;
179
Feng Tangf351d022012-10-23 01:29:27 +0200180 spin_lock_irqsave(&ec->lock, flags);
Feng Tangb76b51b2012-10-23 01:29:38 +0200181 if (!t)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400182 goto unlock;
Feng Tangb76b51b2012-10-23 01:29:38 +0200183 if (t->wlen > t->wi) {
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300184 if ((status & ACPI_EC_FLAG_IBF) == 0)
185 acpi_ec_write_data(ec,
Feng Tangb76b51b2012-10-23 01:29:38 +0200186 t->wdata[t->wi++]);
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300187 else
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300188 goto err;
Feng Tangb76b51b2012-10-23 01:29:38 +0200189 } else if (t->rlen > t->ri) {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400190 if ((status & ACPI_EC_FLAG_OBF) == 1) {
Feng Tangb76b51b2012-10-23 01:29:38 +0200191 t->rdata[t->ri++] = acpi_ec_read_data(ec);
192 if (t->rlen == t->ri)
193 t->done = true;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400194 } else
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300195 goto err;
Feng Tangb76b51b2012-10-23 01:29:38 +0200196 } else if (t->wlen == t->wi &&
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300197 (status & ACPI_EC_FLAG_IBF) == 0)
Feng Tangb76b51b2012-10-23 01:29:38 +0200198 t->done = true;
Alexey Starikovskiydd15f8c2008-11-08 21:42:30 +0300199 goto unlock;
200err:
Feng Tanga3cd8d22012-10-23 01:30:12 +0200201 /*
202 * If SCI bit is set, then don't think it's a false IRQ
203 * otherwise will take a not handled IRQ as a false one.
204 */
205 if (in_interrupt() && !(status & ACPI_EC_FLAG_SCI))
Feng Tangb76b51b2012-10-23 01:29:38 +0200206 ++t->irq_count;
Feng Tanga3cd8d22012-10-23 01:30:12 +0200207
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400208unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200209 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400210}
211
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300212static int acpi_ec_sync_query(struct acpi_ec *ec);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400213
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300214static int ec_check_sci_sync(struct acpi_ec *ec, u8 state)
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400215{
216 if (state & ACPI_EC_FLAG_SCI) {
217 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300218 return acpi_ec_sync_query(ec);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400219 }
Denis M. Sadykov7c6db5e2006-09-26 19:50:33 +0400220 return 0;
221}
222
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400223static int ec_poll(struct acpi_ec *ec)
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300224{
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400225 unsigned long flags;
Lan Tianyu28fe5c82013-05-06 03:23:40 +0000226 int repeat = 5; /* number of command restarts */
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400227 while (repeat--) {
228 unsigned long delay = jiffies +
Thomas Renninger7a18e962010-10-21 18:24:57 +0200229 msecs_to_jiffies(ec_delay);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400230 do {
231 /* don't sleep with disabled interrupts */
232 if (EC_FLAGS_MSI || irqs_disabled()) {
233 udelay(ACPI_EC_MSI_UDELAY);
234 if (ec_transaction_done(ec))
235 return 0;
236 } else {
237 if (wait_event_timeout(ec->wait,
238 ec_transaction_done(ec),
239 msecs_to_jiffies(1)))
240 return 0;
241 }
242 advance_transaction(ec, acpi_ec_read_status(ec));
243 } while (time_before(jiffies, delay));
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400244 pr_debug(PREFIX "controller reset, restart transaction\n");
Feng Tangf351d022012-10-23 01:29:27 +0200245 spin_lock_irqsave(&ec->lock, flags);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400246 start_transaction(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200247 spin_unlock_irqrestore(&ec->lock, flags);
Alexey Starikovskiyaf3fd142006-12-07 18:42:16 +0300248 }
Alexey Starikovskiyb77d81b2008-03-21 17:07:15 +0300249 return -ETIME;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500250}
251
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400252static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400253 struct transaction *t)
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400254{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400255 unsigned long tmp;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400256 int ret = 0;
Alexey Starikovskiy5423a0c2009-02-21 12:18:13 -0500257 if (EC_FLAGS_MSI)
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400258 udelay(ACPI_EC_MSI_UDELAY);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400259 /* start transaction */
Feng Tangf351d022012-10-23 01:29:27 +0200260 spin_lock_irqsave(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400261 /* following two actions should be kept atomic */
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400262 ec->curr = t;
Alexey Starikovskiya2f93ae2008-11-12 01:40:19 +0300263 start_transaction(ec);
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400264 if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
Alexey Starikovskiy080e4122007-10-22 14:18:30 +0400265 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
Feng Tangf351d022012-10-23 01:29:27 +0200266 spin_unlock_irqrestore(&ec->lock, tmp);
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400267 ret = ec_poll(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200268 spin_lock_irqsave(&ec->lock, tmp);
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400269 ec->curr = NULL;
Feng Tangf351d022012-10-23 01:29:27 +0200270 spin_unlock_irqrestore(&ec->lock, tmp);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400271 return ret;
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400272}
273
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400274static int ec_check_ibf0(struct acpi_ec *ec)
275{
276 u8 status = acpi_ec_read_status(ec);
277 return (status & ACPI_EC_FLAG_IBF) == 0;
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400278}
279
Alexey Starikovskiyc0ff1772008-10-16 02:02:33 +0400280static int ec_wait_ibf0(struct acpi_ec *ec)
281{
Thomas Renninger7a18e962010-10-21 18:24:57 +0200282 unsigned long delay = jiffies + msecs_to_jiffies(ec_delay);
Alexey Starikovskiyc0ff1772008-10-16 02:02:33 +0400283 /* interrupt wait manually if GPE mode is not active */
Alexey Starikovskiyc0ff1772008-10-16 02:02:33 +0400284 while (time_before(jiffies, delay))
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400285 if (wait_event_timeout(ec->wait, ec_check_ibf0(ec),
286 msecs_to_jiffies(1)))
Alexey Starikovskiyc0ff1772008-10-16 02:02:33 +0400287 return 0;
288 return -ETIME;
289}
290
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400291static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
Luming Yu45bea152005-07-23 04:08:00 -0400292{
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400293 int status;
Len Brown50526df2005-08-11 17:32:05 -0400294 u32 glk;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400295 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
Patrick Mocheld550d982006-06-27 00:41:40 -0400296 return -EINVAL;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400297 if (t->rdata)
298 memset(t->rdata, 0, t->rlen);
Feng Tangf351d022012-10-23 01:29:27 +0200299 mutex_lock(&ec->mutex);
Rafael J. Wysockife955682010-04-09 01:40:38 +0200300 if (test_bit(EC_FLAGS_BLOCKED, &ec->flags)) {
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100301 status = -EINVAL;
302 goto unlock;
303 }
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400304 if (ec->global_lock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300306 if (ACPI_FAILURE(status)) {
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400307 status = -ENODEV;
308 goto unlock;
Alexey Starikovskiyc24e9122007-02-15 23:16:18 +0300309 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 }
Alexey Starikovskiyc0ff1772008-10-16 02:02:33 +0400311 if (ec_wait_ibf0(ec)) {
Márton Németh3ebe08a2007-11-21 03:23:26 +0300312 pr_err(PREFIX "input buffer is not empty, "
313 "aborting transaction\n");
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400314 status = -ETIME;
Dmitry Torokhov451566f2005-03-19 01:10:05 -0500315 goto end;
Luming Yu716e0842005-08-10 01:40:00 -0400316 }
Feng Tangb76b51b2012-10-23 01:29:38 +0200317 pr_debug(PREFIX "transaction start (cmd=0x%02x, addr=0x%02x)\n",
318 t->command, t->wdata ? t->wdata[0] : 0);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300319 /* disable GPE during transaction if storm is detected */
320 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
Rafael J. Wysocki37847302010-06-25 01:21:42 +0200321 /* It has to be disabled, so that it doesn't trigger. */
322 acpi_disable_gpe(NULL, ec->gpe);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300323 }
324
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400325 status = acpi_ec_transaction_unlocked(ec, t);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300326
327 /* check if we received SCI during transaction */
328 ec_check_sci_sync(ec, acpi_ec_read_status(ec));
329 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
Alexey Starikovskiy54070102009-12-30 15:53:10 +0300330 msleep(1);
Rafael J. Wysocki37847302010-06-25 01:21:42 +0200331 /* It is safe to enable the GPE outside of the transaction. */
332 acpi_enable_gpe(NULL, ec->gpe);
Feng Tanga520d522012-09-28 15:22:00 +0800333 } else if (t->irq_count > ec_storm_threshold) {
Feng Tangb76b51b2012-10-23 01:29:38 +0200334 pr_info(PREFIX "GPE storm detected(%d GPEs), "
335 "transactions will use polling mode\n",
336 t->irq_count);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300337 set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
338 }
Alexey Starikovskiy54070102009-12-30 15:53:10 +0300339 pr_debug(PREFIX "transaction end\n");
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400340end:
Denis M. Sadykov703959d2006-09-26 19:50:33 +0400341 if (ec->global_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 acpi_release_global_lock(glk);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400343unlock:
Feng Tangf351d022012-10-23 01:29:27 +0200344 mutex_unlock(&ec->mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400345 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346}
347
Roel Kluin8a383ef2008-12-09 20:45:30 +0100348static int acpi_ec_burst_enable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300349{
350 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400351 struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
352 .wdata = NULL, .rdata = &d,
353 .wlen = 0, .rlen = 1};
354
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400355 return acpi_ec_transaction(ec, &t);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300356}
357
Roel Kluin8a383ef2008-12-09 20:45:30 +0100358static int acpi_ec_burst_disable(struct acpi_ec *ec)
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300359{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400360 struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
361 .wdata = NULL, .rdata = NULL,
362 .wlen = 0, .rlen = 0};
363
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400364 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400365 acpi_ec_transaction(ec, &t) : 0;
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300366}
367
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300368static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400369{
370 int result;
371 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400372 struct transaction t = {.command = ACPI_EC_COMMAND_READ,
373 .wdata = &address, .rdata = &d,
374 .wlen = 1, .rlen = 1};
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400375
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400376 result = acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400377 *data = d;
378 return result;
379}
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400380
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400381static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
382{
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300383 u8 wdata[2] = { address, data };
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400384 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
385 .wdata = wdata, .rdata = NULL,
386 .wlen = 2, .rlen = 0};
387
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400388 return acpi_ec_transaction(ec, &t);
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400389}
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391/*
392 * Externally callable EC access functions. For now, assume 1 EC only
393 */
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300394int ec_burst_enable(void)
395{
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300396 if (!first_ec)
397 return -ENODEV;
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300398 return acpi_ec_burst_enable(first_ec);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300399}
400
401EXPORT_SYMBOL(ec_burst_enable);
402
403int ec_burst_disable(void)
404{
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300405 if (!first_ec)
406 return -ENODEV;
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300407 return acpi_ec_burst_disable(first_ec);
Alexey Starikovskiyc45aac42007-03-07 22:28:00 +0300408}
409
410EXPORT_SYMBOL(ec_burst_disable);
411
Feng Tangb76b51b2012-10-23 01:29:38 +0200412int ec_read(u8 addr, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 int err;
Denis M. Sadykov6ffb2212006-09-26 19:50:33 +0400415 u8 temp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417 if (!first_ec)
418 return -ENODEV;
419
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300420 err = acpi_ec_read(first_ec, addr, &temp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
422 if (!err) {
423 *val = temp_data;
424 return 0;
Len Brown50526df2005-08-11 17:32:05 -0400425 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 return err;
427}
Len Brown50526df2005-08-11 17:32:05 -0400428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429EXPORT_SYMBOL(ec_read);
430
Len Brown50526df2005-08-11 17:32:05 -0400431int ec_write(u8 addr, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 int err;
434
435 if (!first_ec)
436 return -ENODEV;
437
Alexey Starikovskiyd0338792007-03-07 22:28:00 +0300438 err = acpi_ec_write(first_ec, addr, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440 return err;
441}
Len Brown50526df2005-08-11 17:32:05 -0400442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443EXPORT_SYMBOL(ec_write);
444
Randy Dunlap616362d2006-10-27 01:47:34 -0400445int ec_transaction(u8 command,
Alexey Starikovskiy9e197212007-03-07 18:29:35 -0500446 const u8 * wdata, unsigned wdata_len,
Thomas Renninger1cb7b1e2011-03-31 13:36:38 +0200447 u8 * rdata, unsigned rdata_len)
Luming Yu45bea152005-07-23 04:08:00 -0400448{
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400449 struct transaction t = {.command = command,
450 .wdata = wdata, .rdata = rdata,
451 .wlen = wdata_len, .rlen = rdata_len};
Lennart Poetteringd7a76e42006-09-05 12:12:24 -0400452 if (!first_ec)
453 return -ENODEV;
454
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400455 return acpi_ec_transaction(first_ec, &t);
Luming Yu45bea152005-07-23 04:08:00 -0400456}
Luming Yu45bea152005-07-23 04:08:00 -0400457
Lennart Poetteringab9e43c2006-10-03 22:49:00 -0400458EXPORT_SYMBOL(ec_transaction);
459
Seth Forshee3e2abc52012-01-18 13:44:08 -0600460/* Get the handle to the EC device */
461acpi_handle ec_get_handle(void)
462{
463 if (!first_ec)
464 return NULL;
465 return first_ec->handle;
466}
467
468EXPORT_SYMBOL(ec_get_handle);
469
Rafael J. Wysockife955682010-04-09 01:40:38 +0200470void acpi_ec_block_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100471{
472 struct acpi_ec *ec = first_ec;
473
474 if (!ec)
475 return;
476
Feng Tangf351d022012-10-23 01:29:27 +0200477 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100478 /* Prevent transactions from being carried out */
Rafael J. Wysockife955682010-04-09 01:40:38 +0200479 set_bit(EC_FLAGS_BLOCKED, &ec->flags);
Feng Tangf351d022012-10-23 01:29:27 +0200480 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100481}
482
Rafael J. Wysockife955682010-04-09 01:40:38 +0200483void acpi_ec_unblock_transactions(void)
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100484{
485 struct acpi_ec *ec = first_ec;
486
487 if (!ec)
488 return;
489
Feng Tangf351d022012-10-23 01:29:27 +0200490 mutex_lock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100491 /* Allow transactions to be carried out again */
Rafael J. Wysockife955682010-04-09 01:40:38 +0200492 clear_bit(EC_FLAGS_BLOCKED, &ec->flags);
Feng Tangf351d022012-10-23 01:29:27 +0200493 mutex_unlock(&ec->mutex);
Rafael J. Wysockif6bb13a2010-03-04 01:52:58 +0100494}
495
Rafael J. Wysockife955682010-04-09 01:40:38 +0200496void acpi_ec_unblock_transactions_early(void)
Rafael J. Wysockid5a64512010-04-09 01:39:40 +0200497{
498 /*
499 * Allow transactions to happen again (this function is called from
500 * atomic context during wakeup, so we don't need to acquire the mutex).
501 */
502 if (first_ec)
Rafael J. Wysockife955682010-04-09 01:40:38 +0200503 clear_bit(EC_FLAGS_BLOCKED, &first_ec->flags);
Rafael J. Wysockid5a64512010-04-09 01:39:40 +0200504}
505
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300506static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 * data)
Denis M. Sadykov3576cf62006-09-26 19:50:33 +0400507{
508 int result;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300509 u8 d;
Alexey Starikovskiy84632002008-09-26 00:54:28 +0400510 struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
511 .wdata = NULL, .rdata = &d,
512 .wlen = 0, .rlen = 1};
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300513 if (!ec || !data)
514 return -EINVAL;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300515 /*
516 * Query the EC to find out which _Qxx method we need to evaluate.
517 * Note that successful completion of the query causes the ACPI_EC_SCI
518 * bit to be cleared (and thus clearing the interrupt source).
519 */
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300520 result = acpi_ec_transaction_unlocked(ec, &t);
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300521 if (result)
522 return result;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300523 if (!d)
524 return -ENODATA;
Alexey Starikovskiy6ccedb12006-12-07 18:42:17 +0300525 *data = d;
526 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527}
528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529/* --------------------------------------------------------------------------
530 Event Management
531 -------------------------------------------------------------------------- */
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400532int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
533 acpi_handle handle, acpi_ec_query_func func,
534 void *data)
535{
536 struct acpi_ec_query_handler *handler =
537 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
538 if (!handler)
539 return -ENOMEM;
540
541 handler->query_bit = query_bit;
542 handler->handle = handle;
543 handler->func = func;
544 handler->data = data;
Feng Tangf351d022012-10-23 01:29:27 +0200545 mutex_lock(&ec->mutex);
Alexey Starikovskiy30c08572007-09-26 19:43:22 +0400546 list_add(&handler->node, &ec->list);
Feng Tangf351d022012-10-23 01:29:27 +0200547 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400548 return 0;
549}
550
551EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
552
553void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
554{
Adrian Bunk1544fdb2007-10-24 18:26:00 +0200555 struct acpi_ec_query_handler *handler, *tmp;
Feng Tangf351d022012-10-23 01:29:27 +0200556 mutex_lock(&ec->mutex);
Adrian Bunk1544fdb2007-10-24 18:26:00 +0200557 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400558 if (query_bit == handler->query_bit) {
559 list_del(&handler->node);
560 kfree(handler);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400561 }
562 }
Feng Tangf351d022012-10-23 01:29:27 +0200563 mutex_unlock(&ec->mutex);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400564}
565
566EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300568static void acpi_ec_run(void *cxt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300570 struct acpi_ec_query_handler *handler = cxt;
571 if (!handler)
Alexey Starikovskiye41334c2006-12-07 18:42:16 +0300572 return;
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300573 pr_debug(PREFIX "start query execution\n");
574 if (handler->func)
575 handler->func(handler->data);
576 else if (handler->handle)
577 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
578 pr_debug(PREFIX "stop query execution\n");
579 kfree(handler);
580}
581
582static int acpi_ec_sync_query(struct acpi_ec *ec)
583{
584 u8 value = 0;
585 int status;
586 struct acpi_ec_query_handler *handler, *copy;
587 if ((status = acpi_ec_query_unlocked(ec, &value)))
588 return status;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400589 list_for_each_entry(handler, &ec->list, node) {
590 if (value == handler->query_bit) {
591 /* have custom handler for this bit */
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300592 copy = kmalloc(sizeof(*handler), GFP_KERNEL);
593 if (!copy)
594 return -ENOMEM;
595 memcpy(copy, handler, sizeof(*copy));
596 pr_debug(PREFIX "push query execution (0x%2x) on queue\n", value);
Alexey Starikovskiyf5347862009-12-30 15:53:03 +0300597 return acpi_os_execute((copy->func) ?
598 OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER,
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300599 acpi_ec_run, copy);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400600 }
601 }
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300602 return 0;
603}
604
605static void acpi_ec_gpe_query(void *ec_cxt)
606{
607 struct acpi_ec *ec = ec_cxt;
608 if (!ec)
609 return;
Feng Tangf351d022012-10-23 01:29:27 +0200610 mutex_lock(&ec->mutex);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300611 acpi_ec_sync_query(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200612 mutex_unlock(&ec->mutex);
Luming Yu45bea152005-07-23 04:08:00 -0400613}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300615static int ec_check_sci(struct acpi_ec *ec, u8 state)
616{
617 if (state & ACPI_EC_FLAG_SCI) {
618 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
619 pr_debug(PREFIX "push gpe query to the queue\n");
620 return acpi_os_execute(OSL_NOTIFY_HANDLER,
621 acpi_ec_gpe_query, ec);
622 }
623 }
624 return 0;
625}
626
Lin Ming8b6cd8a2010-12-13 13:38:46 +0800627static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
628 u32 gpe_number, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +0300630 struct acpi_ec *ec = data;
Feng Tangb76b51b2012-10-23 01:29:38 +0200631 u8 status = acpi_ec_read_status(ec);
Lennart Poettering00eb43a2007-05-04 14:16:19 +0200632
Feng Tangb76b51b2012-10-23 01:29:38 +0200633 pr_debug(PREFIX "~~~> interrupt, status:0x%02x\n", status);
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400634
Feng Tangb76b51b2012-10-23 01:29:38 +0200635 advance_transaction(ec, status);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300636 if (ec_transaction_done(ec) &&
637 (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) {
Alexey Starikovskiy2a84cb92009-08-30 03:06:14 +0400638 wake_up(&ec->wait);
Alexey Starikovskiya62e8f12009-12-24 11:34:16 +0300639 ec_check_sci(ec, acpi_ec_read_status(ec));
640 }
Lin Mingbba63a22010-12-13 13:39:17 +0800641 return ACPI_INTERRUPT_HANDLED | ACPI_REENABLE_GPE;
Alexey Starikovskiy845625c2008-03-21 17:07:03 +0300642}
643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644/* --------------------------------------------------------------------------
645 Address Space Management
646 -------------------------------------------------------------------------- */
647
648static acpi_status
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +0400649acpi_ec_space_handler(u32 function, acpi_physical_address address,
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400650 u32 bits, u64 *value64,
Len Brown50526df2005-08-11 17:32:05 -0400651 void *handler_context, void *region_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
Alexey Starikovskiy3d02b902007-03-07 22:28:00 +0300653 struct acpi_ec *ec = handler_context;
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400654 int result = 0, i, bytes = bits / 8;
655 u8 *value = (u8 *)value64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if ((address > 0xFF) || !value || !handler_context)
Patrick Mocheld550d982006-06-27 00:41:40 -0400658 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +0400660 if (function != ACPI_READ && function != ACPI_WRITE)
Patrick Mocheld550d982006-06-27 00:41:40 -0400661 return AE_BAD_PARAMETER;
Alexey Starikovskiy5b7734b2007-05-29 16:42:52 +0400662
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400663 if (EC_FLAGS_MSI || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +0400664 acpi_ec_burst_enable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +0300665
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400666 for (i = 0; i < bytes; ++i, ++address, ++value)
667 result = (function == ACPI_READ) ?
668 acpi_ec_read(ec, address, value) :
669 acpi_ec_write(ec, address, *value);
Alexey Starikovskiy3e71a872008-01-11 02:42:51 +0300670
Alexey Starikovskiydadf28a2010-03-17 13:14:13 -0400671 if (EC_FLAGS_MSI || bits > 8)
Alexey Starikovskiy6a63b06f2009-08-28 23:29:44 +0400672 acpi_ec_burst_disable(ec);
Alexey Starikovskiyb3b233c2008-01-11 02:42:57 +0300673
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 switch (result) {
675 case -EINVAL:
Patrick Mocheld550d982006-06-27 00:41:40 -0400676 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 break;
678 case -ENODEV:
Patrick Mocheld550d982006-06-27 00:41:40 -0400679 return AE_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 break;
681 case -ETIME:
Patrick Mocheld550d982006-06-27 00:41:40 -0400682 return AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 break;
684 default:
Patrick Mocheld550d982006-06-27 00:41:40 -0400685 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}
688
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689/* --------------------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 Driver Interface
691 -------------------------------------------------------------------------- */
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300692static acpi_status
693ec_parse_io_ports(struct acpi_resource *resource, void *context);
694
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300695static struct acpi_ec *make_acpi_ec(void)
696{
697 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
698 if (!ec)
699 return NULL;
Alexey Starikovskiy080e4122007-10-22 14:18:30 +0400700 ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
Feng Tangf351d022012-10-23 01:29:27 +0200701 mutex_init(&ec->mutex);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300702 init_waitqueue_head(&ec->wait);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400703 INIT_LIST_HEAD(&ec->list);
Feng Tangf351d022012-10-23 01:29:27 +0200704 spin_lock_init(&ec->lock);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300705 return ec;
706}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400708static acpi_status
Alexey Starikovskiyc019b192007-08-14 01:03:42 -0400709acpi_ec_register_query_methods(acpi_handle handle, u32 level,
710 void *context, void **return_value)
711{
Lin Ming0175d562008-12-16 16:46:12 +0800712 char node_name[5];
713 struct acpi_buffer buffer = { sizeof(node_name), node_name };
Alexey Starikovskiyc019b192007-08-14 01:03:42 -0400714 struct acpi_ec *ec = context;
715 int value = 0;
Lin Ming0175d562008-12-16 16:46:12 +0800716 acpi_status status;
717
718 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
719
720 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1) {
Alexey Starikovskiyc019b192007-08-14 01:03:42 -0400721 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
722 }
723 return AE_OK;
724}
725
726static acpi_status
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400727ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400728{
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400729 acpi_status status;
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -0500730 unsigned long long tmp = 0;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400731
732 struct acpi_ec *ec = context;
Alexey Starikovskiya5032bf2009-04-01 01:33:15 -0400733
734 /* clear addr values, ec_parse_io_ports depend on it */
735 ec->command_addr = ec->data_addr = 0;
736
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400737 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
738 ec_parse_io_ports, ec);
739 if (ACPI_FAILURE(status))
740 return status;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400741
742 /* Get GPE bit assignment (EC events). */
743 /* TODO: Add support for _GPE returning a package */
Matthew Wilcox27663c52008-10-10 02:22:59 -0400744 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400745 if (ACPI_FAILURE(status))
746 return status;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400747 ec->gpe = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400748 /* Use the global lock for all EC transactions? */
Alexey Starikovskiyd21cf3c2008-11-03 14:26:40 -0500749 tmp = 0;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400750 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
751 ec->global_lock = tmp;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400752 ec->handle = handle;
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -0400753 return AE_CTRL_TERMINATE;
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400754}
755
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300756static int ec_install_handlers(struct acpi_ec *ec)
757{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300758 acpi_status status;
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400759 if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
Alexey Starikovskiy4c611062007-09-05 19:56:38 -0400760 return 0;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300761 status = acpi_install_gpe_handler(NULL, ec->gpe,
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400762 ACPI_GPE_EDGE_TRIGGERED,
763 &acpi_ec_gpe_handler, ec);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300764 if (ACPI_FAILURE(status))
765 return -ENODEV;
Rafael J. Wysocki9630bdd2010-02-17 23:41:07 +0100766
Rafael J. Wysockia44061a2010-07-01 10:11:45 +0800767 acpi_enable_gpe(NULL, ec->gpe);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300768 status = acpi_install_address_space_handler(ec->handle,
769 ACPI_ADR_SPACE_EC,
770 &acpi_ec_space_handler,
Alexey Starikovskiy6d9e1122008-03-24 23:22:29 +0300771 NULL, ec);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300772 if (ACPI_FAILURE(status)) {
Zhao Yakui20edd742008-10-17 02:02:44 -0400773 if (status == AE_NOT_FOUND) {
774 /*
775 * Maybe OS fails in evaluating the _REG object.
776 * The AE_NOT_FOUND error will be ignored and OS
777 * continue to initialize EC.
778 */
779 printk(KERN_ERR "Fail in evaluating the _REG object"
780 " of EC device. Broken bios is suspected.\n");
781 } else {
782 acpi_remove_gpe_handler(NULL, ec->gpe,
783 &acpi_ec_gpe_handler);
Rafael J. Wysockia44061a2010-07-01 10:11:45 +0800784 acpi_disable_gpe(NULL, ec->gpe);
Zhao Yakui20edd742008-10-17 02:02:44 -0400785 return -ENODEV;
786 }
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300787 }
788
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400789 set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
Alexey Starikovskiye8284322007-03-07 22:28:00 +0300790 return 0;
791}
792
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793static void ec_remove_handlers(struct acpi_ec *ec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
Rafael J. Wysockia44061a2010-07-01 10:11:45 +0800795 acpi_disable_gpe(NULL, ec->gpe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
797 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
798 pr_err(PREFIX "failed to remove space handler\n");
799 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
800 &acpi_ec_gpe_handler)))
801 pr_err(PREFIX "failed to remove gpe handler\n");
802 clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
803}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805static int acpi_ec_add(struct acpi_device *device)
806{
807 struct acpi_ec *ec = NULL;
Bjorn Helgaasd02be042009-06-22 20:41:35 +0000808 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
811 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 /* Check for boot EC */
814 if (boot_ec &&
815 (boot_ec->handle == device->handle ||
816 boot_ec->handle == ACPI_ROOT_OBJECT)) {
817 ec = boot_ec;
818 boot_ec = NULL;
819 } else {
820 ec = make_acpi_ec();
821 if (!ec)
822 return -ENOMEM;
823 }
824 if (ec_parse_device(device->handle, 0, ec, NULL) !=
825 AE_CTRL_TERMINATE) {
826 kfree(ec);
827 return -EINVAL;
828 }
829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 /* Find and register all query methods */
831 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
Lin Ming22635762009-11-13 10:06:08 +0800832 acpi_ec_register_query_methods, NULL, ec, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 if (!first_ec)
835 first_ec = ec;
836 device->driver_data = ec;
Thomas Renningerde4f1042010-07-29 22:08:44 +0200837
Andi Kleend6795fe32012-02-06 08:17:08 -0800838 ret = !!request_region(ec->data_addr, 1, "EC data");
839 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
840 ret = !!request_region(ec->command_addr, 1, "EC cmd");
841 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
Thomas Renningerde4f1042010-07-29 22:08:44 +0200842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
844 ec->gpe, ec->command_addr, ec->data_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
Alexey Starikovskiy4c611062007-09-05 19:56:38 -0400846 ret = ec_install_handlers(ec);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300847
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400848 /* EC is fully operational, allow queries */
Alexey Starikovskiy080e4122007-10-22 14:18:30 +0400849 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
Alexey Starikovskiy837012e2007-05-29 16:43:02 +0400850 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851}
852
Rafael J. Wysocki51fac832013-01-24 00:24:48 +0100853static int acpi_ec_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300855 struct acpi_ec *ec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 struct acpi_ec_query_handler *handler, *tmp;
857
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400859 return -EINVAL;
Alexey Starikovskiyf9319f92007-08-24 08:10:11 +0400860
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 ec = acpi_driver_data(device);
Bjorn Helgaascf745ec2009-06-22 20:41:40 +0000862 ec_remove_handlers(ec);
Feng Tangf351d022012-10-23 01:29:27 +0200863 mutex_lock(&ec->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
865 list_del(&handler->node);
866 kfree(handler);
867 }
Feng Tangf351d022012-10-23 01:29:27 +0200868 mutex_unlock(&ec->mutex);
Thomas Renningerde4f1042010-07-29 22:08:44 +0200869 release_region(ec->data_addr, 1);
870 release_region(ec->command_addr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 device->driver_data = NULL;
872 if (ec == first_ec)
873 first_ec = NULL;
874 kfree(ec);
Patrick Mocheld550d982006-06-27 00:41:40 -0400875 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876}
877
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878static acpi_status
879ec_parse_io_ports(struct acpi_resource *resource, void *context)
880{
881 struct acpi_ec *ec = context;
882
883 if (resource->type != ACPI_RESOURCE_TYPE_IO)
884 return AE_OK;
885
886 /*
887 * The first address region returned is the data port, and
888 * the second address region returned is the status/command
889 * port.
890 */
Thomas Renningerde4f1042010-07-29 22:08:44 +0200891 if (ec->data_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 ec->data_addr = resource->data.io.minimum;
Thomas Renningerde4f1042010-07-29 22:08:44 +0200893 else if (ec->command_addr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 ec->command_addr = resource->data.io.minimum;
895 else
896 return AE_CTRL_TERMINATE;
897
898 return AE_OK;
899}
900
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -0500901int __init acpi_boot_ec_enable(void)
902{
Alexey Starikovskiy7c6db4e2008-09-25 21:00:31 +0400903 if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
Alexey Starikovskiyc04209a2008-01-01 14:12:55 -0500904 return 0;
905 if (!ec_install_handlers(boot_ec)) {
906 first_ec = boot_ec;
907 return 0;
908 }
909 return -EFAULT;
910}
911
Alexey Starikovskiy223883b2008-03-21 17:07:21 +0300912static const struct acpi_device_id ec_device_ids[] = {
913 {"PNP0C09", 0},
914 {"", 0},
915};
916
Alexey Starikovskiy478fa032009-10-02 20:21:40 +0400917/* Some BIOS do not survive early DSDT scan, skip it */
918static int ec_skip_dsdt_scan(const struct dmi_system_id *id)
919{
920 EC_FLAGS_SKIP_DSDT_SCAN = 1;
921 return 0;
922}
923
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400924/* ASUStek often supplies us with broken ECDT, validate it */
925static int ec_validate_ecdt(const struct dmi_system_id *id)
926{
927 EC_FLAGS_VALIDATE_ECDT = 1;
928 return 0;
929}
930
931/* MSI EC needs special treatment, enable it */
932static int ec_flag_msi(const struct dmi_system_id *id)
933{
Alexey Starikovskiy55b313f2009-12-22 02:42:52 -0500934 printk(KERN_DEBUG PREFIX "Detected MSI hardware, enabling workarounds.\n");
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400935 EC_FLAGS_MSI = 1;
936 EC_FLAGS_VALIDATE_ECDT = 1;
937 return 0;
938}
939
Feng Tang67bfa9b2012-09-28 15:22:01 +0800940/*
941 * Clevo M720 notebook actually works ok with IRQ mode, if we lifted
942 * the GPE storm threshold back to 20
943 */
944static int ec_enlarge_storm_threshold(const struct dmi_system_id *id)
945{
946 pr_debug("Setting the EC GPE storm threshold to 20\n");
947 ec_storm_threshold = 20;
948 return 0;
949}
950
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400951static struct dmi_system_id __initdata ec_dmi_table[] = {
952 {
Alexey Starikovskiy478fa032009-10-02 20:21:40 +0400953 ec_skip_dsdt_scan, "Compal JFL92", {
954 DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
955 DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL},
956 {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400957 ec_flag_msi, "MSI hardware", {
Alexey Starikovskiy55b313f2009-12-22 02:42:52 -0500958 DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL},
959 {
960 ec_flag_msi, "MSI hardware", {
961 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL},
962 {
963 ec_flag_msi, "MSI hardware", {
964 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL},
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400965 {
Alexey Starikovskiya5dc4f82010-12-09 17:07:54 -0500966 ec_flag_msi, "MSI hardware", {
967 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
968 {
Zhang Rui534bc4e2011-04-26 16:30:02 +0800969 ec_flag_msi, "Quanta hardware", {
970 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
971 DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
972 {
973 ec_flag_msi, "Quanta hardware", {
974 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
975 DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
976 {
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400977 ec_validate_ecdt, "ASUS hardware", {
978 DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
Peter Collingbourneaf986d12011-04-24 22:09:32 +0100979 {
980 ec_validate_ecdt, "ASUS hardware", {
981 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
Feng Tang67bfa9b2012-09-28 15:22:01 +0800982 {
983 ec_enlarge_storm_threshold, "CLEVO hardware", {
984 DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
985 DMI_MATCH(DMI_PRODUCT_NAME, "M720T/M730T"),}, NULL},
Lan Tianyueff9a4b2013-06-05 02:27:51 +0000986 {
987 ec_skip_dsdt_scan, "HP Folio 13", {
988 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
989 DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL},
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +0400990 {},
991};
992
Len Brown50526df2005-08-11 17:32:05 -0400993int __init acpi_ec_ecdt_probe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994{
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300995 acpi_status status;
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +0300996 struct acpi_ec *saved_ec = NULL;
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +0300997 struct acpi_table_ecdt *ecdt_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Alexey Starikovskiyd66d9692007-03-07 22:28:00 +0300999 boot_ec = make_acpi_ec();
1000 if (!boot_ec)
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001001 return -ENOMEM;
1002 /*
1003 * Generate a boot ec context
1004 */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001005 dmi_check_system(ec_dmi_table);
Alexey Starikovskiyc0900c32007-03-07 22:28:00 +03001006 status = acpi_get_table(ACPI_SIG_ECDT, 1,
1007 (struct acpi_table_header **)&ecdt_ptr);
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001008 if (ACPI_SUCCESS(status)) {
Márton Németh3ebe08a2007-11-21 03:23:26 +03001009 pr_info(PREFIX "EC description table is found, configuring boot EC\n");
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001010 boot_ec->command_addr = ecdt_ptr->control.address;
1011 boot_ec->data_addr = ecdt_ptr->data.address;
1012 boot_ec->gpe = ecdt_ptr->gpe;
Len Brown4af8e102008-03-11 00:27:16 -04001013 boot_ec->handle = ACPI_ROOT_OBJECT;
Alexey Starikovskiyce52ddf2008-03-24 23:22:36 +03001014 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle);
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001015 /* Don't trust ECDT, which comes from ASUSTek */
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001016 if (!EC_FLAGS_VALIDATE_ECDT)
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001017 goto install;
Julia Lawalld6bd5352010-05-15 23:16:21 +02001018 saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001019 if (!saved_ec)
1020 return -ENOMEM;
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001021 /* fall through */
Alexey Starikovskiycd8c93a2007-08-03 17:52:48 -04001022 }
Alexey Starikovskiy0adf3c72009-10-02 20:21:33 +04001023
Alexey Starikovskiy478fa032009-10-02 20:21:40 +04001024 if (EC_FLAGS_SKIP_DSDT_SCAN)
1025 return -ENODEV;
1026
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001027 /* This workaround is needed only on some broken machines,
1028 * which require early EC, but fail to provide ECDT */
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001029 printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n");
1030 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
1031 boot_ec, NULL);
1032 /* Check that acpi_get_devices actually find something */
1033 if (ACPI_FAILURE(status) || !boot_ec->handle)
1034 goto error;
Alexey Starikovskiyc6cb0e82009-01-14 02:57:53 +03001035 if (saved_ec) {
1036 /* try to find good ECDT from ASUSTek */
1037 if (saved_ec->command_addr != boot_ec->command_addr ||
1038 saved_ec->data_addr != boot_ec->data_addr ||
1039 saved_ec->gpe != boot_ec->gpe ||
1040 saved_ec->handle != boot_ec->handle)
1041 pr_info(PREFIX "ASUSTek keeps feeding us with broken "
1042 "ECDT tables, which are very hard to workaround. "
1043 "Trying to use DSDT EC info instead. Please send "
1044 "output of acpidump to linux-acpi@vger.kernel.org\n");
1045 kfree(saved_ec);
1046 saved_ec = NULL;
1047 } else {
1048 /* We really need to limit this workaround, the only ASUS,
1049 * which needs it, has fake EC._INI method, so use it as flag.
1050 * Keep boot_ec struct as it will be needed soon.
1051 */
1052 acpi_handle dummy;
1053 if (!dmi_name_in_vendors("ASUS") ||
1054 ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI",
1055 &dummy)))
1056 return -ENODEV;
1057 }
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001058install:
1059 if (!ec_install_handlers(boot_ec)) {
Alexey Starikovskiyd0338792007-03-07 22:28:00 +03001060 first_ec = boot_ec;
Alexey Starikovskiye8284322007-03-07 22:28:00 +03001061 return 0;
Alexey Starikovskiyd0338792007-03-07 22:28:00 +03001062 }
Alexey Starikovskiyc5279de2008-11-26 17:11:53 -05001063error:
Alexey Starikovskiyd66d9692007-03-07 22:28:00 +03001064 kfree(boot_ec);
1065 boot_ec = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 return -ENODEV;
1067}
1068
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001069static struct acpi_driver acpi_ec_driver = {
1070 .name = "ec",
1071 .class = ACPI_EC_CLASS,
1072 .ids = ec_device_ids,
1073 .ops = {
1074 .add = acpi_ec_add,
1075 .remove = acpi_ec_remove,
Alexey Starikovskiy223883b2008-03-21 17:07:21 +03001076 },
1077};
1078
Bjorn Helgaasa5f820f2009-03-24 16:49:48 -06001079int __init acpi_ec_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080{
Len Brown50526df2005-08-11 17:32:05 -04001081 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 /* Now register the driver for the EC */
1084 result = acpi_bus_register_driver(&acpi_ec_driver);
Thomas Renninger49c6c5f2010-07-16 13:11:34 +02001085 if (result < 0)
Patrick Mocheld550d982006-06-27 00:41:40 -04001086 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
Patrick Mocheld550d982006-06-27 00:41:40 -04001088 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089}
1090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091/* EC driver currently not unloadable */
1092#if 0
Len Brown50526df2005-08-11 17:32:05 -04001093static void __exit acpi_ec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
1096 acpi_bus_unregister_driver(&acpi_ec_driver);
Patrick Mocheld550d982006-06-27 00:41:40 -04001097 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098}
Alexey Starikovskiy78439322007-10-22 14:18:43 +04001099#endif /* 0 */