2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2008-09-25 11:00:31 -06:00
|
|
|
* ec.c - ACPI Embedded Controller Driver (v2.1)
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-09-25 11:00:31 -06:00
|
|
|
* Copyright (C) 2006-2008 Alexey Starikovskiy <astarikovskiy@suse.de>
|
2007-03-07 12:28:00 -07:00
|
|
|
* Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
|
|
|
|
* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
|
|
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
|
|
* your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*/
|
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
/* Uncomment next line to get verbose printout */
|
2008-01-23 20:34:09 -07:00
|
|
|
/* #define DEBUG */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2005-03-18 23:10:05 -07:00
|
|
|
#include <linux/interrupt.h>
|
2007-05-29 06:43:02 -06:00
|
|
|
#include <linux/list.h>
|
2008-09-25 11:00:31 -06:00
|
|
|
#include <linux/spinlock.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/io.h>
|
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
|
|
|
|
|
|
|
#define ACPI_EC_CLASS "embedded_controller"
|
|
|
|
#define ACPI_EC_DEVICE_NAME "Embedded Controller"
|
|
|
|
#define ACPI_EC_FILE_INFO "info"
|
2007-05-29 06:43:02 -06:00
|
|
|
|
2006-12-07 08:42:16 -07:00
|
|
|
#undef PREFIX
|
|
|
|
#define PREFIX "ACPI: EC: "
|
2007-05-29 06:42:57 -06:00
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
/* EC status register */
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
|
|
|
|
#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
|
2005-03-18 23:10:05 -07:00
|
|
|
#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
|
2007-05-29 06:42:57 -06:00
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
/* EC commands */
|
2006-12-07 08:42:17 -07:00
|
|
|
enum ec_command {
|
2006-12-07 08:42:17 -07:00
|
|
|
ACPI_EC_COMMAND_READ = 0x80,
|
|
|
|
ACPI_EC_COMMAND_WRITE = 0x81,
|
|
|
|
ACPI_EC_BURST_ENABLE = 0x82,
|
|
|
|
ACPI_EC_BURST_DISABLE = 0x83,
|
|
|
|
ACPI_EC_COMMAND_QUERY = 0x84,
|
2006-12-07 08:42:17 -07:00
|
|
|
};
|
2007-05-29 06:43:02 -06:00
|
|
|
|
2006-12-07 08:42:16 -07:00
|
|
|
#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
|
2006-09-26 09:50:33 -06:00
|
|
|
#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
|
2008-03-21 08:06:57 -06:00
|
|
|
#define ACPI_EC_UDELAY 100 /* Wait 100us before polling EC again */
|
2006-09-26 09:50:33 -06:00
|
|
|
|
2008-11-09 09:01:06 -07:00
|
|
|
#define ACPI_EC_STORM_THRESHOLD 8 /* number of false interrupts
|
2008-09-25 11:00:31 -06:00
|
|
|
per one transaction */
|
|
|
|
|
2007-10-22 04:18:30 -06:00
|
|
|
enum {
|
|
|
|
EC_FLAGS_QUERY_PENDING, /* Query is pending */
|
2008-09-25 11:00:31 -06:00
|
|
|
EC_FLAGS_GPE_MODE, /* Expect GPE to be sent
|
|
|
|
* for status change */
|
2008-03-21 08:07:15 -06:00
|
|
|
EC_FLAGS_NO_GPE, /* Don't use GPE mode */
|
2008-09-25 11:00:31 -06:00
|
|
|
EC_FLAGS_GPE_STORM, /* GPE storm detected */
|
|
|
|
EC_FLAGS_HANDLERS_INSTALLED /* Handlers for GPE and
|
|
|
|
* OpReg are installed */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2006-09-26 09:50:33 -06:00
|
|
|
|
|
|
|
/* If we find an EC via the ECDT, we need to keep a ptr to its context */
|
2007-03-07 12:28:00 -07:00
|
|
|
/* External interfaces use first EC only, so remember */
|
2007-05-29 06:43:02 -06:00
|
|
|
typedef int (*acpi_ec_query_func) (void *data);
|
|
|
|
|
|
|
|
struct acpi_ec_query_handler {
|
|
|
|
struct list_head node;
|
|
|
|
acpi_ec_query_func func;
|
|
|
|
acpi_handle handle;
|
|
|
|
void *data;
|
|
|
|
u8 query_bit;
|
|
|
|
};
|
|
|
|
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction {
|
2008-09-25 11:00:31 -06:00
|
|
|
const u8 *wdata;
|
|
|
|
u8 *rdata;
|
|
|
|
unsigned short irq_count;
|
2008-09-25 14:54:28 -06:00
|
|
|
u8 command;
|
2008-11-11 15:40:19 -07:00
|
|
|
u8 wi;
|
|
|
|
u8 ri;
|
2008-09-25 11:00:31 -06:00
|
|
|
u8 wlen;
|
|
|
|
u8 rlen;
|
2008-11-08 11:42:30 -07:00
|
|
|
bool done;
|
2008-09-25 11:00:31 -06:00
|
|
|
};
|
|
|
|
|
2006-12-19 13:56:12 -07:00
|
|
|
static struct acpi_ec {
|
2006-09-26 09:50:33 -06:00
|
|
|
acpi_handle handle;
|
2006-12-07 08:42:16 -07:00
|
|
|
unsigned long gpe;
|
2006-09-26 09:50:33 -06:00
|
|
|
unsigned long command_addr;
|
|
|
|
unsigned long data_addr;
|
2006-09-26 09:50:33 -06:00
|
|
|
unsigned long global_lock;
|
2007-10-22 04:18:30 -06:00
|
|
|
unsigned long flags;
|
2006-12-07 08:42:16 -07:00
|
|
|
struct mutex lock;
|
2006-09-26 09:50:33 -06:00
|
|
|
wait_queue_head_t wait;
|
2007-05-29 06:43:02 -06:00
|
|
|
struct list_head list;
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction *curr;
|
|
|
|
spinlock_t curr_lock;
|
2007-03-07 12:28:00 -07:00
|
|
|
} *boot_ec, *first_ec;
|
2006-09-26 09:50:33 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Transaction Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-20 17:23:26 -07:00
|
|
|
u8 x = inb(ec->command_addr);
|
2008-01-23 20:33:06 -07:00
|
|
|
pr_debug(PREFIX "---> status = 0x%2.2x\n", x);
|
2007-11-20 17:23:26 -07:00
|
|
|
return x;
|
2005-03-18 23:10:05 -07:00
|
|
|
}
|
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
|
2006-09-26 09:50:33 -06:00
|
|
|
{
|
2007-11-20 17:23:26 -07:00
|
|
|
u8 x = inb(ec->data_addr);
|
2008-01-23 20:33:06 -07:00
|
|
|
pr_debug(PREFIX "---> data = 0x%2.2x\n", x);
|
2008-09-25 11:00:31 -06:00
|
|
|
return x;
|
2006-09-26 09:50:33 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
|
2005-07-23 02:08:00 -06:00
|
|
|
{
|
2008-01-23 20:33:06 -07:00
|
|
|
pr_debug(PREFIX "<--- command = 0x%2.2x\n", command);
|
2006-09-26 09:50:33 -06:00
|
|
|
outb(command, ec->command_addr);
|
2005-07-23 02:08:00 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
|
2005-07-23 02:08:00 -06:00
|
|
|
{
|
2008-01-23 20:33:06 -07:00
|
|
|
pr_debug(PREFIX "<--- data = 0x%2.2x\n", data);
|
2006-09-26 09:50:33 -06:00
|
|
|
outb(data, ec->data_addr);
|
2006-09-26 09:50:33 -06:00
|
|
|
}
|
2005-07-23 02:08:00 -06:00
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
static int ec_transaction_done(struct acpi_ec *ec)
|
2006-09-26 09:50:33 -06:00
|
|
|
{
|
2008-09-25 11:00:31 -06:00
|
|
|
unsigned long flags;
|
|
|
|
int ret = 0;
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_lock_irqsave(&ec->curr_lock, flags);
|
2008-11-08 11:42:30 -07:00
|
|
|
if (!ec->curr || ec->curr->done)
|
2008-09-25 11:00:31 -06:00
|
|
|
ret = 1;
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_unlock_irqrestore(&ec->curr_lock, flags);
|
2008-09-25 11:00:31 -06:00
|
|
|
return ret;
|
2005-07-23 02:08:00 -06:00
|
|
|
}
|
2005-03-18 23:10:05 -07:00
|
|
|
|
2008-11-11 15:40:19 -07:00
|
|
|
static void start_transaction(struct acpi_ec *ec)
|
|
|
|
{
|
|
|
|
ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
|
|
|
|
ec->curr->done = false;
|
|
|
|
acpi_ec_write_cmd(ec, ec->curr->command);
|
|
|
|
}
|
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
static void gpe_transaction(struct acpi_ec *ec, u8 status)
|
2006-09-26 09:50:33 -06:00
|
|
|
{
|
2008-09-25 11:00:31 -06:00
|
|
|
unsigned long flags;
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_lock_irqsave(&ec->curr_lock, flags);
|
|
|
|
if (!ec->curr)
|
2008-09-25 11:00:31 -06:00
|
|
|
goto unlock;
|
2008-11-11 15:40:19 -07:00
|
|
|
if (ec->curr->wlen > ec->curr->wi) {
|
|
|
|
if ((status & ACPI_EC_FLAG_IBF) == 0)
|
|
|
|
acpi_ec_write_data(ec,
|
|
|
|
ec->curr->wdata[ec->curr->wi++]);
|
|
|
|
else
|
2008-11-08 11:42:30 -07:00
|
|
|
goto err;
|
2008-11-11 15:40:19 -07:00
|
|
|
} else if (ec->curr->rlen > ec->curr->ri) {
|
2008-09-25 11:00:31 -06:00
|
|
|
if ((status & ACPI_EC_FLAG_OBF) == 1) {
|
2008-11-11 15:40:19 -07:00
|
|
|
ec->curr->rdata[ec->curr->ri++] = acpi_ec_read_data(ec);
|
|
|
|
if (ec->curr->rlen == ec->curr->ri)
|
2008-11-08 11:42:30 -07:00
|
|
|
ec->curr->done = true;
|
2008-09-25 11:00:31 -06:00
|
|
|
} else
|
2008-11-08 11:42:30 -07:00
|
|
|
goto err;
|
2008-11-11 15:40:19 -07:00
|
|
|
} else if (ec->curr->wlen == ec->curr->wi &&
|
|
|
|
(status & ACPI_EC_FLAG_IBF) == 0)
|
2008-11-08 11:42:30 -07:00
|
|
|
ec->curr->done = true;
|
|
|
|
goto unlock;
|
|
|
|
err:
|
|
|
|
/* false interrupt, state didn't change */
|
2008-11-13 02:00:03 -07:00
|
|
|
if (in_interrupt())
|
|
|
|
++ec->curr->irq_count;
|
2008-09-25 11:00:31 -06:00
|
|
|
unlock:
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_unlock_irqrestore(&ec->curr_lock, flags);
|
2008-03-21 08:07:03 -06:00
|
|
|
}
|
2008-01-23 20:28:34 -07:00
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
static int acpi_ec_wait(struct acpi_ec *ec)
|
2008-03-21 08:07:03 -06:00
|
|
|
{
|
2008-09-25 11:00:31 -06:00
|
|
|
if (wait_event_timeout(ec->wait, ec_transaction_done(ec),
|
|
|
|
msecs_to_jiffies(ACPI_EC_DELAY)))
|
|
|
|
return 0;
|
2008-11-11 15:40:19 -07:00
|
|
|
/* try restart command if we get any false interrupts */
|
|
|
|
if (ec->curr->irq_count &&
|
|
|
|
(acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) {
|
|
|
|
pr_debug(PREFIX "controller reset, restart transaction\n");
|
|
|
|
start_transaction(ec);
|
|
|
|
if (wait_event_timeout(ec->wait, ec_transaction_done(ec),
|
|
|
|
msecs_to_jiffies(ACPI_EC_DELAY)))
|
|
|
|
return 0;
|
|
|
|
}
|
2008-09-25 11:00:31 -06:00
|
|
|
/* missing GPEs, switch back to poll mode */
|
|
|
|
if (printk_ratelimit())
|
|
|
|
pr_info(PREFIX "missing confirmations, "
|
|
|
|
"switch off interrupt mode.\n");
|
2008-03-21 08:07:15 -06:00
|
|
|
set_bit(EC_FLAGS_NO_GPE, &ec->flags);
|
2008-03-21 08:07:03 -06:00
|
|
|
clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
|
2008-09-25 11:00:31 -06:00
|
|
|
return 1;
|
2008-03-21 08:07:03 -06:00
|
|
|
}
|
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
static void acpi_ec_gpe_query(void *ec_cxt);
|
|
|
|
|
|
|
|
static int ec_check_sci(struct acpi_ec *ec, u8 state)
|
2006-09-26 09:50:33 -06:00
|
|
|
{
|
2008-09-25 11:00:31 -06:00
|
|
|
if (state & ACPI_EC_FLAG_SCI) {
|
|
|
|
if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
|
|
|
|
return acpi_os_execute(OSL_EC_BURST_HANDLER,
|
|
|
|
acpi_ec_gpe_query, ec);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ec_poll(struct acpi_ec *ec)
|
|
|
|
{
|
|
|
|
unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
|
2008-10-27 15:35:30 -06:00
|
|
|
udelay(ACPI_EC_UDELAY);
|
2008-09-25 11:00:31 -06:00
|
|
|
while (time_before(jiffies, delay)) {
|
|
|
|
gpe_transaction(ec, acpi_ec_read_status(ec));
|
2008-10-27 15:35:30 -06:00
|
|
|
udelay(ACPI_EC_UDELAY);
|
2008-09-25 11:00:31 -06:00
|
|
|
if (ec_transaction_done(ec))
|
ACPI: Avoid bogus EC timeout when EC is in Polling mode
When EC is in Polling mode, OS will check the EC status continually by using
the following source code:
clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
while (time_before(jiffies, delay)) {
if (acpi_ec_check_status(ec, event))
return 0;
msleep(1);
}
But msleep is realized by the function of schedule_timeout. At the same time
although one process is already waken up by some events, it won't be scheduled
immediately. So maybe there exists the following phenomena:
a. The current jiffies is already after the predefined jiffies.
But before timeout happens, OS has no chance to check the EC
status again.
b. If preemptible schedule is enabled, maybe preempt schedule will happen
before checking loop. When the process is resumed again, maybe
timeout already happens, which means that OS has no chance to check
the EC status.
In such case maybe EC status is already what OS expects when timeout happens.
But OS has no chance to check the EC status and regards it as AE_TIME.
So it will be more appropriate that OS will try to check the EC status again
when timeout happens. If the EC status is what we expect, it won't be regarded
as timeout. Only when the EC status is not what we expect, it will be regarded
as timeout, which means that EC controller can't give a response in time.
http://bugzilla.kernel.org/show_bug.cgi?id=9823
http://bugzilla.kernel.org/show_bug.cgi?id=11141
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
2008-08-10 20:33:31 -06:00
|
|
|
return 0;
|
2006-12-07 08:42:16 -07:00
|
|
|
}
|
2008-03-21 08:07:15 -06:00
|
|
|
return -ETIME;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-09-25 14:54:28 -06:00
|
|
|
static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
|
|
|
|
struct transaction *t,
|
2007-05-04 06:16:19 -06:00
|
|
|
int force_poll)
|
2005-07-23 02:08:00 -06:00
|
|
|
{
|
2008-09-25 11:00:31 -06:00
|
|
|
unsigned long tmp;
|
|
|
|
int ret = 0;
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_debug(PREFIX "transaction start\n");
|
2008-09-25 11:00:31 -06:00
|
|
|
/* disable GPE during transaction if storm is detected */
|
|
|
|
if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
|
|
|
|
clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
|
2008-10-25 11:48:46 -06:00
|
|
|
acpi_disable_gpe(NULL, ec->gpe);
|
2006-09-26 09:50:33 -06:00
|
|
|
}
|
2008-09-25 11:00:31 -06:00
|
|
|
/* start transaction */
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_lock_irqsave(&ec->curr_lock, tmp);
|
2008-09-25 11:00:31 -06:00
|
|
|
/* following two actions should be kept atomic */
|
2008-09-25 14:54:28 -06:00
|
|
|
ec->curr = t;
|
2008-11-11 15:40:19 -07:00
|
|
|
start_transaction(ec);
|
2008-09-25 14:54:28 -06:00
|
|
|
if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
|
2007-10-22 04:18:30 -06:00
|
|
|
clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_unlock_irqrestore(&ec->curr_lock, tmp);
|
2008-09-25 11:00:31 -06:00
|
|
|
/* if we selected poll mode or failed in GPE-mode do a poll loop */
|
|
|
|
if (force_poll ||
|
|
|
|
!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) ||
|
|
|
|
acpi_ec_wait(ec))
|
|
|
|
ret = ec_poll(ec);
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_debug(PREFIX "transaction end\n");
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_lock_irqsave(&ec->curr_lock, tmp);
|
|
|
|
ec->curr = NULL;
|
|
|
|
spin_unlock_irqrestore(&ec->curr_lock, tmp);
|
2008-09-25 11:00:31 -06:00
|
|
|
if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
|
|
|
|
/* check if we received SCI during transaction */
|
|
|
|
ec_check_sci(ec, acpi_ec_read_status(ec));
|
|
|
|
/* it is safe to enable GPE outside of transaction */
|
2008-10-25 11:48:46 -06:00
|
|
|
acpi_enable_gpe(NULL, ec->gpe);
|
2008-09-25 11:00:31 -06:00
|
|
|
} else if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
|
2008-09-25 14:54:28 -06:00
|
|
|
t->irq_count > ACPI_EC_STORM_THRESHOLD) {
|
2008-11-01 05:05:26 -06:00
|
|
|
pr_info(PREFIX "GPE storm detected, "
|
|
|
|
"transactions will use polling mode\n");
|
2008-09-25 11:00:31 -06:00
|
|
|
set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ec_check_ibf0(struct acpi_ec *ec)
|
|
|
|
{
|
|
|
|
u8 status = acpi_ec_read_status(ec);
|
|
|
|
return (status & ACPI_EC_FLAG_IBF) == 0;
|
2005-07-23 02:08:00 -06:00
|
|
|
}
|
|
|
|
|
2008-10-15 16:02:33 -06:00
|
|
|
static int ec_wait_ibf0(struct acpi_ec *ec)
|
|
|
|
{
|
|
|
|
unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
|
|
|
|
/* interrupt wait manually if GPE mode is not active */
|
|
|
|
unsigned long timeout = test_bit(EC_FLAGS_GPE_MODE, &ec->flags) ?
|
|
|
|
msecs_to_jiffies(ACPI_EC_DELAY) : msecs_to_jiffies(1);
|
|
|
|
while (time_before(jiffies, delay))
|
|
|
|
if (wait_event_timeout(ec->wait, ec_check_ibf0(ec), timeout))
|
|
|
|
return 0;
|
|
|
|
return -ETIME;
|
2005-07-23 02:08:00 -06:00
|
|
|
}
|
|
|
|
|
2008-09-25 14:54:28 -06:00
|
|
|
static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t,
|
2007-05-04 06:16:19 -06:00
|
|
|
int force_poll)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-05 10:12:24 -06:00
|
|
|
int status;
|
2005-08-11 15:32:05 -06:00
|
|
|
u32 glk;
|
2008-09-25 14:54:28 -06:00
|
|
|
if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2008-09-25 14:54:28 -06:00
|
|
|
if (t->rdata)
|
|
|
|
memset(t->rdata, 0, t->rlen);
|
2006-12-07 08:42:17 -07:00
|
|
|
mutex_lock(&ec->lock);
|
2006-09-26 09:50:33 -06:00
|
|
|
if (ec->global_lock) {
|
2005-04-16 16:20:36 -06:00
|
|
|
status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
|
2007-02-15 13:16:18 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2008-09-25 11:00:31 -06:00
|
|
|
status = -ENODEV;
|
|
|
|
goto unlock;
|
2007-02-15 13:16:18 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-10-15 16:02:33 -06:00
|
|
|
if (ec_wait_ibf0(ec)) {
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_err(PREFIX "input buffer is not empty, "
|
|
|
|
"aborting transaction\n");
|
2008-09-25 11:00:31 -06:00
|
|
|
status = -ETIME;
|
2005-03-18 23:10:05 -07:00
|
|
|
goto end;
|
2005-08-09 23:40:00 -06:00
|
|
|
}
|
2008-09-25 14:54:28 -06:00
|
|
|
status = acpi_ec_transaction_unlocked(ec, t, force_poll);
|
2008-09-25 11:00:31 -06:00
|
|
|
end:
|
2006-09-26 09:50:33 -06:00
|
|
|
if (ec->global_lock)
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_release_global_lock(glk);
|
2008-09-25 11:00:31 -06:00
|
|
|
unlock:
|
2006-12-07 08:42:17 -07:00
|
|
|
mutex_unlock(&ec->lock);
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
/*
|
|
|
|
* Note: samsung nv5000 doesn't work with ec burst mode.
|
|
|
|
* http://bugzilla.kernel.org/show_bug.cgi?id=4980
|
|
|
|
*/
|
2008-12-09 12:45:30 -07:00
|
|
|
static int acpi_ec_burst_enable(struct acpi_ec *ec)
|
2007-03-07 12:28:00 -07:00
|
|
|
{
|
|
|
|
u8 d;
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
|
|
|
|
.wdata = NULL, .rdata = &d,
|
|
|
|
.wlen = 0, .rlen = 1};
|
|
|
|
|
|
|
|
return acpi_ec_transaction(ec, &t, 0);
|
2007-03-07 12:28:00 -07:00
|
|
|
}
|
|
|
|
|
2008-12-09 12:45:30 -07:00
|
|
|
static int acpi_ec_burst_disable(struct acpi_ec *ec)
|
2007-03-07 12:28:00 -07:00
|
|
|
{
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
|
|
|
|
.wdata = NULL, .rdata = NULL,
|
|
|
|
.wlen = 0, .rlen = 0};
|
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
|
2008-09-25 14:54:28 -06:00
|
|
|
acpi_ec_transaction(ec, &t, 0) : 0;
|
2007-03-07 12:28:00 -07:00
|
|
|
}
|
|
|
|
|
2006-12-07 08:42:17 -07:00
|
|
|
static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
|
2006-09-26 09:50:33 -06:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
u8 d;
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction t = {.command = ACPI_EC_COMMAND_READ,
|
|
|
|
.wdata = &address, .rdata = &d,
|
|
|
|
.wlen = 1, .rlen = 1};
|
2006-09-26 09:50:33 -06:00
|
|
|
|
2008-09-25 14:54:28 -06:00
|
|
|
result = acpi_ec_transaction(ec, &t, 0);
|
2006-09-26 09:50:33 -06:00
|
|
|
*data = d;
|
|
|
|
return result;
|
|
|
|
}
|
2006-09-26 09:50:33 -06:00
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
|
|
|
|
{
|
2006-12-07 08:42:17 -07:00
|
|
|
u8 wdata[2] = { address, data };
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
|
|
|
|
.wdata = wdata, .rdata = NULL,
|
|
|
|
.wlen = 2, .rlen = 0};
|
|
|
|
|
|
|
|
return acpi_ec_transaction(ec, &t, 0);
|
2006-09-26 09:50:33 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Externally callable EC access functions. For now, assume 1 EC only
|
|
|
|
*/
|
2007-03-07 12:28:00 -07:00
|
|
|
int ec_burst_enable(void)
|
|
|
|
{
|
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
2007-03-07 12:28:00 -07:00
|
|
|
return acpi_ec_burst_enable(first_ec);
|
2007-03-07 12:28:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(ec_burst_enable);
|
|
|
|
|
|
|
|
int ec_burst_disable(void)
|
|
|
|
{
|
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
2007-03-07 12:28:00 -07:00
|
|
|
return acpi_ec_burst_disable(first_ec);
|
2007-03-07 12:28:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(ec_burst_disable);
|
|
|
|
|
2006-12-07 08:42:17 -07:00
|
|
|
int ec_read(u8 addr, u8 * val)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err;
|
2006-09-26 09:50:33 -06:00
|
|
|
u8 temp_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
err = acpi_ec_read(first_ec, addr, &temp_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!err) {
|
|
|
|
*val = temp_data;
|
|
|
|
return 0;
|
2005-08-11 15:32:05 -06:00
|
|
|
} else
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
2005-08-11 15:32:05 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
EXPORT_SYMBOL(ec_read);
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
int ec_write(u8 addr, u8 val)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
err = acpi_ec_write(first_ec, addr, val);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2005-08-11 15:32:05 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
EXPORT_SYMBOL(ec_write);
|
|
|
|
|
2006-10-26 23:47:34 -06:00
|
|
|
int ec_transaction(u8 command,
|
2007-03-07 16:29:35 -07:00
|
|
|
const u8 * wdata, unsigned wdata_len,
|
2007-05-04 06:16:19 -06:00
|
|
|
u8 * rdata, unsigned rdata_len,
|
|
|
|
int force_poll)
|
2005-07-23 02:08:00 -06:00
|
|
|
{
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction t = {.command = command,
|
|
|
|
.wdata = wdata, .rdata = rdata,
|
|
|
|
.wlen = wdata_len, .rlen = rdata_len};
|
2006-09-05 10:12:24 -06:00
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
2005-07-23 02:08:00 -06:00
|
|
|
|
2008-09-25 14:54:28 -06:00
|
|
|
return acpi_ec_transaction(first_ec, &t, force_poll);
|
2005-07-23 02:08:00 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-03 20:49:00 -06:00
|
|
|
EXPORT_SYMBOL(ec_transaction);
|
|
|
|
|
2006-12-07 08:42:17 -07:00
|
|
|
static int acpi_ec_query(struct acpi_ec *ec, u8 * data)
|
2006-09-26 09:50:33 -06:00
|
|
|
{
|
|
|
|
int result;
|
2006-12-07 08:42:17 -07:00
|
|
|
u8 d;
|
2008-09-25 14:54:28 -06:00
|
|
|
struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
|
|
|
|
.wdata = NULL, .rdata = &d,
|
|
|
|
.wlen = 0, .rlen = 1};
|
2006-12-07 08:42:17 -07:00
|
|
|
if (!ec || !data)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-07 08:42:17 -07:00
|
|
|
/*
|
|
|
|
* Query the EC to find out which _Qxx method we need to evaluate.
|
|
|
|
* Note that successful completion of the query causes the ACPI_EC_SCI
|
|
|
|
* bit to be cleared (and thus clearing the interrupt source).
|
|
|
|
*/
|
2005-08-09 23:40:00 -06:00
|
|
|
|
2008-09-25 14:54:28 -06:00
|
|
|
result = acpi_ec_transaction(ec, &t, 0);
|
2006-12-07 08:42:17 -07:00
|
|
|
if (result)
|
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-07 08:42:17 -07:00
|
|
|
if (!d)
|
|
|
|
return -ENODATA;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-07 08:42:17 -07:00
|
|
|
*data = d;
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Event Management
|
|
|
|
-------------------------------------------------------------------------- */
|
2007-05-29 06:43:02 -06:00
|
|
|
int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
|
|
|
|
acpi_handle handle, acpi_ec_query_func func,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct acpi_ec_query_handler *handler =
|
|
|
|
kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
|
|
|
|
if (!handler)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
handler->query_bit = query_bit;
|
|
|
|
handler->handle = handle;
|
|
|
|
handler->func = func;
|
|
|
|
handler->data = data;
|
|
|
|
mutex_lock(&ec->lock);
|
2007-09-26 09:43:22 -06:00
|
|
|
list_add(&handler->node, &ec->list);
|
2007-05-29 06:43:02 -06:00
|
|
|
mutex_unlock(&ec->lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
|
|
|
|
|
|
|
|
void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
|
|
|
|
{
|
2007-10-24 10:26:00 -06:00
|
|
|
struct acpi_ec_query_handler *handler, *tmp;
|
2007-05-29 06:43:02 -06:00
|
|
|
mutex_lock(&ec->lock);
|
2007-10-24 10:26:00 -06:00
|
|
|
list_for_each_entry_safe(handler, tmp, &ec->list, node) {
|
2007-05-29 06:43:02 -06:00
|
|
|
if (query_bit == handler->query_bit) {
|
|
|
|
list_del(&handler->node);
|
|
|
|
kfree(handler);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&ec->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static void acpi_ec_gpe_query(void *ec_cxt)
|
2005-07-23 02:08:00 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec = ec_cxt;
|
2006-09-26 09:50:33 -06:00
|
|
|
u8 value = 0;
|
2007-05-29 06:43:02 -06:00
|
|
|
struct acpi_ec_query_handler *handler, copy;
|
2005-07-23 02:08:00 -06:00
|
|
|
|
2006-12-07 08:42:16 -07:00
|
|
|
if (!ec || acpi_ec_query(ec, &value))
|
2006-12-07 08:42:16 -07:00
|
|
|
return;
|
2007-05-29 06:43:02 -06:00
|
|
|
mutex_lock(&ec->lock);
|
|
|
|
list_for_each_entry(handler, &ec->list, node) {
|
|
|
|
if (value == handler->query_bit) {
|
|
|
|
/* have custom handler for this bit */
|
|
|
|
memcpy(©, handler, sizeof(copy));
|
|
|
|
mutex_unlock(&ec->lock);
|
|
|
|
if (copy.func) {
|
|
|
|
copy.func(copy.data);
|
|
|
|
} else if (copy.handle) {
|
|
|
|
acpi_evaluate_object(copy.handle, NULL, NULL, NULL);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&ec->lock);
|
2005-07-23 02:08:00 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static u32 acpi_ec_gpe_handler(void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec = data;
|
2008-09-25 11:00:31 -06:00
|
|
|
u8 status;
|
2007-05-04 06:16:19 -06:00
|
|
|
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_debug(PREFIX "~~~> interrupt\n");
|
2008-09-25 11:00:31 -06:00
|
|
|
status = acpi_ec_read_status(ec);
|
|
|
|
|
2008-11-11 02:54:11 -07:00
|
|
|
if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) {
|
|
|
|
gpe_transaction(ec, status);
|
|
|
|
if (ec_transaction_done(ec) &&
|
|
|
|
(status & ACPI_EC_FLAG_IBF) == 0)
|
|
|
|
wake_up(&ec->wait);
|
|
|
|
}
|
2005-03-18 23:10:05 -07:00
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
ec_check_sci(ec, status);
|
|
|
|
if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
|
|
|
|
!test_bit(EC_FLAGS_NO_GPE, &ec->flags)) {
|
2007-10-22 04:19:03 -06:00
|
|
|
/* this is non-query, must be confirmation */
|
2008-11-01 05:05:26 -06:00
|
|
|
if (!test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
|
|
|
|
if (printk_ratelimit())
|
|
|
|
pr_info(PREFIX "non-query interrupt received,"
|
|
|
|
" switching to interrupt mode\n");
|
|
|
|
} else {
|
|
|
|
/* hush, STORM switches the mode every transaction */
|
|
|
|
pr_debug(PREFIX "non-query interrupt received,"
|
2007-11-20 17:23:26 -07:00
|
|
|
" switching to interrupt mode\n");
|
2008-11-01 05:05:26 -06:00
|
|
|
}
|
2007-10-22 04:18:43 -06:00
|
|
|
set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
|
2007-10-22 04:19:03 -06:00
|
|
|
}
|
2008-09-25 11:00:31 -06:00
|
|
|
return ACPI_INTERRUPT_HANDLED;
|
2008-03-21 08:07:03 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Address Space Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static acpi_status
|
2007-05-29 06:42:52 -06:00
|
|
|
acpi_ec_space_handler(u32 function, acpi_physical_address address,
|
|
|
|
u32 bits, acpi_integer *value,
|
2005-08-11 15:32:05 -06:00
|
|
|
void *handler_context, void *region_context)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec = handler_context;
|
2008-01-10 16:42:51 -07:00
|
|
|
int result = 0, i;
|
2007-05-29 06:42:52 -06:00
|
|
|
u8 temp = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if ((address > 0xFF) || !value || !handler_context)
|
2006-06-26 22:41:40 -06:00
|
|
|
return AE_BAD_PARAMETER;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-29 06:42:52 -06:00
|
|
|
if (function != ACPI_READ && function != ACPI_WRITE)
|
2006-06-26 22:41:40 -06:00
|
|
|
return AE_BAD_PARAMETER;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-29 06:42:52 -06:00
|
|
|
if (bits != 8 && acpi_strict)
|
|
|
|
return AE_BAD_PARAMETER;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-10 16:42:57 -07:00
|
|
|
acpi_ec_burst_enable(ec);
|
|
|
|
|
2008-01-10 16:42:51 -07:00
|
|
|
if (function == ACPI_READ) {
|
|
|
|
result = acpi_ec_read(ec, address, &temp);
|
|
|
|
*value = temp;
|
|
|
|
} else {
|
|
|
|
temp = 0xff & (*value);
|
|
|
|
result = acpi_ec_write(ec, address, temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 8; unlikely(bits - i > 0); i += 8) {
|
|
|
|
++address;
|
2007-05-29 06:42:52 -06:00
|
|
|
if (function == ACPI_READ) {
|
|
|
|
result = acpi_ec_read(ec, address, &temp);
|
|
|
|
(*value) |= ((acpi_integer)temp) << i;
|
|
|
|
} else {
|
|
|
|
temp = 0xff & ((*value) >> i);
|
|
|
|
result = acpi_ec_write(ec, address, temp);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-10 16:42:57 -07:00
|
|
|
acpi_ec_burst_disable(ec);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (result) {
|
|
|
|
case -EINVAL:
|
2006-06-26 22:41:40 -06:00
|
|
|
return AE_BAD_PARAMETER;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case -ENODEV:
|
2006-06-26 22:41:40 -06:00
|
|
|
return AE_NOT_FOUND;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case -ETIME:
|
2006-06-26 22:41:40 -06:00
|
|
|
return AE_TIME;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2006-06-26 22:41:40 -06:00
|
|
|
return AE_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
FS Interface (/proc)
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static struct proc_dir_entry *acpi_ec_dir;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static int acpi_ec_read_info(struct seq_file *seq, void *offset)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec = seq->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!ec)
|
|
|
|
goto end;
|
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
seq_printf(seq, "gpe:\t\t\t0x%02x\n", (u32) ec->gpe);
|
|
|
|
seq_printf(seq, "ports:\t\t\t0x%02x, 0x%02x\n",
|
|
|
|
(unsigned)ec->command_addr, (unsigned)ec->data_addr);
|
|
|
|
seq_printf(seq, "use global lock:\t%s\n",
|
2006-09-26 09:50:33 -06:00
|
|
|
ec->global_lock ? "yes" : "no");
|
2005-08-11 15:32:05 -06:00
|
|
|
end:
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, acpi_ec_read_info, PDE(inode)->data);
|
|
|
|
}
|
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
static struct file_operations acpi_ec_info_ops = {
|
2005-08-11 15:32:05 -06:00
|
|
|
.open = acpi_ec_info_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static int acpi_ec_add_fs(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-11 15:32:05 -06:00
|
|
|
struct proc_dir_entry *entry = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!acpi_device_dir(device)) {
|
|
|
|
acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
|
2005-08-11 15:32:05 -06:00
|
|
|
acpi_ec_dir);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!acpi_device_dir(device))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-04-29 02:02:27 -06:00
|
|
|
entry = proc_create_data(ACPI_EC_FILE_INFO, S_IRUGO,
|
|
|
|
acpi_device_dir(device),
|
|
|
|
&acpi_ec_info_ops, acpi_driver_data(device));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!entry)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static int acpi_ec_remove_fs(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
|
|
|
if (acpi_device_dir(device)) {
|
|
|
|
remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
|
|
|
|
remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
|
|
|
|
acpi_device_dir(device) = NULL;
|
|
|
|
}
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
2007-03-07 12:28:00 -07:00
|
|
|
static acpi_status
|
|
|
|
ec_parse_io_ports(struct acpi_resource *resource, void *context);
|
|
|
|
|
|
|
|
static struct acpi_ec *make_acpi_ec(void)
|
|
|
|
{
|
|
|
|
struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
|
|
|
if (!ec)
|
|
|
|
return NULL;
|
2007-10-22 04:18:30 -06:00
|
|
|
ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
|
2007-03-07 12:28:00 -07:00
|
|
|
mutex_init(&ec->lock);
|
|
|
|
init_waitqueue_head(&ec->wait);
|
2007-05-29 06:43:02 -06:00
|
|
|
INIT_LIST_HEAD(&ec->list);
|
2008-09-25 14:54:28 -06:00
|
|
|
spin_lock_init(&ec->curr_lock);
|
2007-03-07 12:28:00 -07:00
|
|
|
return ec;
|
|
|
|
}
|
2007-05-29 06:43:02 -06:00
|
|
|
|
2007-08-13 23:03:42 -06:00
|
|
|
static acpi_status
|
|
|
|
acpi_ec_register_query_methods(acpi_handle handle, u32 level,
|
|
|
|
void *context, void **return_value)
|
|
|
|
{
|
2008-12-16 01:46:12 -07:00
|
|
|
char node_name[5];
|
|
|
|
struct acpi_buffer buffer = { sizeof(node_name), node_name };
|
2007-08-13 23:03:42 -06:00
|
|
|
struct acpi_ec *ec = context;
|
|
|
|
int value = 0;
|
2008-12-16 01:46:12 -07:00
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
|
|
|
|
|
|
|
|
if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1) {
|
2007-08-13 23:03:42 -06:00
|
|
|
acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
|
|
|
|
}
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
2007-08-03 15:52:48 -06:00
|
|
|
static acpi_status
|
|
|
|
ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
|
2007-05-29 06:43:02 -06:00
|
|
|
{
|
2007-08-03 15:52:48 -06:00
|
|
|
acpi_status status;
|
2008-11-03 12:26:40 -07:00
|
|
|
unsigned long long tmp = 0;
|
2007-08-03 15:52:48 -06:00
|
|
|
|
|
|
|
struct acpi_ec *ec = context;
|
|
|
|
status = acpi_walk_resources(handle, METHOD_NAME__CRS,
|
|
|
|
ec_parse_io_ports, ec);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return status;
|
2007-05-29 06:43:02 -06:00
|
|
|
|
|
|
|
/* Get GPE bit assignment (EC events). */
|
|
|
|
/* TODO: Add support for _GPE returning a package */
|
2008-10-10 00:22:59 -06:00
|
|
|
status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
|
2007-08-03 15:52:48 -06:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return status;
|
2008-10-10 00:22:59 -06:00
|
|
|
ec->gpe = tmp;
|
2007-05-29 06:43:02 -06:00
|
|
|
/* Use the global lock for all EC transactions? */
|
2008-11-03 12:26:40 -07:00
|
|
|
tmp = 0;
|
2008-10-10 00:22:59 -06:00
|
|
|
acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
|
|
|
|
ec->global_lock = tmp;
|
2007-05-29 06:43:02 -06:00
|
|
|
ec->handle = handle;
|
2007-08-03 15:52:48 -06:00
|
|
|
return AE_CTRL_TERMINATE;
|
2007-05-29 06:43:02 -06:00
|
|
|
}
|
|
|
|
|
2007-09-05 17:56:38 -06:00
|
|
|
static void ec_remove_handlers(struct acpi_ec *ec)
|
|
|
|
{
|
|
|
|
if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
|
|
|
|
ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_err(PREFIX "failed to remove space handler\n");
|
2007-09-05 17:56:38 -06:00
|
|
|
if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
|
|
|
|
&acpi_ec_gpe_handler)))
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_err(PREFIX "failed to remove gpe handler\n");
|
2008-09-25 11:00:31 -06:00
|
|
|
clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
|
2007-09-05 17:56:38 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 09:50:33 -06:00
|
|
|
static int acpi_ec_add(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-26 09:50:33 -06:00
|
|
|
struct acpi_ec *ec = NULL;
|
2005-07-23 02:08:00 -06:00
|
|
|
|
|
|
|
if (!device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2007-03-07 12:28:00 -07:00
|
|
|
strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_EC_CLASS);
|
|
|
|
|
2007-09-05 17:56:38 -06:00
|
|
|
/* Check for boot EC */
|
2008-03-24 14:22:36 -06:00
|
|
|
if (boot_ec &&
|
|
|
|
(boot_ec->handle == device->handle ||
|
|
|
|
boot_ec->handle == ACPI_ROOT_OBJECT)) {
|
|
|
|
ec = boot_ec;
|
|
|
|
boot_ec = NULL;
|
|
|
|
} else {
|
|
|
|
ec = make_acpi_ec();
|
|
|
|
if (!ec)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (ec_parse_device(device->handle, 0, ec, NULL) !=
|
|
|
|
AE_CTRL_TERMINATE) {
|
|
|
|
kfree(ec);
|
|
|
|
return -EINVAL;
|
2007-09-05 17:56:38 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
ec->handle = device->handle;
|
2008-03-24 14:22:36 -06:00
|
|
|
|
|
|
|
/* Find and register all query methods */
|
|
|
|
acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
|
|
|
|
acpi_ec_register_query_methods, ec, NULL);
|
|
|
|
|
2007-09-05 17:56:38 -06:00
|
|
|
if (!first_ec)
|
|
|
|
first_ec = ec;
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = ec;
|
2007-03-07 12:28:00 -07:00
|
|
|
acpi_ec_add_fs(device);
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
|
2007-09-05 17:56:38 -06:00
|
|
|
ec->gpe, ec->command_addr, ec->data_addr);
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_info(PREFIX "driver started in %s mode\n",
|
2007-10-22 04:19:03 -06:00
|
|
|
(test_bit(EC_FLAGS_GPE_MODE, &ec->flags))?"interrupt":"poll");
|
2007-03-07 12:28:00 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static int acpi_ec_remove(struct acpi_device *device, int type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec;
|
2007-07-29 09:00:37 -06:00
|
|
|
struct acpi_ec_query_handler *handler, *tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ec = acpi_driver_data(device);
|
2007-05-29 06:43:02 -06:00
|
|
|
mutex_lock(&ec->lock);
|
2007-07-29 09:00:37 -06:00
|
|
|
list_for_each_entry_safe(handler, tmp, &ec->list, node) {
|
2007-05-29 06:43:02 -06:00
|
|
|
list_del(&handler->node);
|
|
|
|
kfree(handler);
|
|
|
|
}
|
|
|
|
mutex_unlock(&ec->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_ec_remove_fs(device);
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = NULL;
|
2007-03-07 12:28:00 -07:00
|
|
|
if (ec == first_ec)
|
2007-03-07 12:28:00 -07:00
|
|
|
first_ec = NULL;
|
2007-09-05 17:56:38 -06:00
|
|
|
kfree(ec);
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static acpi_status
|
2007-03-07 12:28:00 -07:00
|
|
|
ec_parse_io_ports(struct acpi_resource *resource, void *context)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec = context;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
if (resource->type != ACPI_RESOURCE_TYPE_IO)
|
2005-04-16 16:20:36 -06:00
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The first address region returned is the data port, and
|
|
|
|
* the second address region returned is the status/command
|
|
|
|
* port.
|
|
|
|
*/
|
2007-03-07 12:28:00 -07:00
|
|
|
if (ec->data_addr == 0)
|
2006-09-26 09:50:33 -06:00
|
|
|
ec->data_addr = resource->data.io.minimum;
|
2007-03-07 12:28:00 -07:00
|
|
|
else if (ec->command_addr == 0)
|
2006-09-26 09:50:33 -06:00
|
|
|
ec->command_addr = resource->data.io.minimum;
|
2007-03-07 12:28:00 -07:00
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
return AE_CTRL_TERMINATE;
|
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
static int ec_install_handlers(struct acpi_ec *ec)
|
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
acpi_status status;
|
2008-09-25 11:00:31 -06:00
|
|
|
if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
|
2007-09-05 17:56:38 -06:00
|
|
|
return 0;
|
2007-03-07 12:28:00 -07:00
|
|
|
status = acpi_install_gpe_handler(NULL, ec->gpe,
|
2008-09-25 11:00:31 -06:00
|
|
|
ACPI_GPE_EDGE_TRIGGERED,
|
|
|
|
&acpi_ec_gpe_handler, ec);
|
2007-03-07 12:28:00 -07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -ENODEV;
|
|
|
|
acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
|
2008-10-25 11:48:46 -06:00
|
|
|
acpi_enable_gpe(NULL, ec->gpe);
|
2007-03-07 12:28:00 -07:00
|
|
|
status = acpi_install_address_space_handler(ec->handle,
|
|
|
|
ACPI_ADR_SPACE_EC,
|
|
|
|
&acpi_ec_space_handler,
|
2008-03-24 14:22:29 -06:00
|
|
|
NULL, ec);
|
2007-03-07 12:28:00 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2008-10-17 00:02:44 -06:00
|
|
|
if (status == AE_NOT_FOUND) {
|
|
|
|
/*
|
|
|
|
* Maybe OS fails in evaluating the _REG object.
|
|
|
|
* The AE_NOT_FOUND error will be ignored and OS
|
|
|
|
* continue to initialize EC.
|
|
|
|
*/
|
|
|
|
printk(KERN_ERR "Fail in evaluating the _REG object"
|
|
|
|
" of EC device. Broken bios is suspected.\n");
|
|
|
|
} else {
|
|
|
|
acpi_remove_gpe_handler(NULL, ec->gpe,
|
|
|
|
&acpi_ec_gpe_handler);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2007-03-07 12:28:00 -07:00
|
|
|
}
|
|
|
|
|
2008-09-25 11:00:31 -06:00
|
|
|
set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
|
2007-03-07 12:28:00 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static int acpi_ec_start(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec;
|
2007-05-29 06:43:02 -06:00
|
|
|
int ret = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ec = acpi_driver_data(device);
|
|
|
|
|
|
|
|
if (!ec)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-05 17:56:38 -06:00
|
|
|
ret = ec_install_handlers(ec);
|
2007-05-29 06:43:02 -06:00
|
|
|
|
|
|
|
/* EC is fully operational, allow queries */
|
2007-10-22 04:18:30 -06:00
|
|
|
clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
|
2007-05-29 06:43:02 -06:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static int acpi_ec_stop(struct acpi_device *device, int type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-07 12:28:00 -07:00
|
|
|
struct acpi_ec *ec;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
ec = acpi_driver_data(device);
|
2007-03-07 12:28:00 -07:00
|
|
|
if (!ec)
|
|
|
|
return -EINVAL;
|
2007-09-05 17:56:38 -06:00
|
|
|
ec_remove_handlers(ec);
|
2007-08-23 22:10:11 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-01 12:12:55 -07:00
|
|
|
int __init acpi_boot_ec_enable(void)
|
|
|
|
{
|
2008-09-25 11:00:31 -06:00
|
|
|
if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
|
2008-01-01 12:12:55 -07:00
|
|
|
return 0;
|
|
|
|
if (!ec_install_handlers(boot_ec)) {
|
|
|
|
first_ec = boot_ec;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
2008-03-21 08:07:21 -06:00
|
|
|
static const struct acpi_device_id ec_device_ids[] = {
|
|
|
|
{"PNP0C09", 0},
|
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
int __init acpi_ec_ecdt_probe(void)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
2009-01-13 16:57:53 -07:00
|
|
|
struct acpi_ec *saved_ec = NULL;
|
2005-08-11 15:32:05 -06:00
|
|
|
struct acpi_table_ecdt *ecdt_ptr;
|
2005-07-23 02:08:00 -06:00
|
|
|
|
2007-03-07 12:28:00 -07:00
|
|
|
boot_ec = make_acpi_ec();
|
|
|
|
if (!boot_ec)
|
2007-03-07 12:28:00 -07:00
|
|
|
return -ENOMEM;
|
|
|
|
/*
|
|
|
|
* Generate a boot ec context
|
|
|
|
*/
|
2007-02-02 09:48:22 -07:00
|
|
|
status = acpi_get_table(ACPI_SIG_ECDT, 1,
|
|
|
|
(struct acpi_table_header **)&ecdt_ptr);
|
2007-08-03 15:52:48 -06:00
|
|
|
if (ACPI_SUCCESS(status)) {
|
2007-11-20 17:23:26 -07:00
|
|
|
pr_info(PREFIX "EC description table is found, configuring boot EC\n");
|
2007-08-03 15:52:48 -06:00
|
|
|
boot_ec->command_addr = ecdt_ptr->control.address;
|
|
|
|
boot_ec->data_addr = ecdt_ptr->data.address;
|
|
|
|
boot_ec->gpe = ecdt_ptr->gpe;
|
2008-03-10 22:27:16 -06:00
|
|
|
boot_ec->handle = ACPI_ROOT_OBJECT;
|
2008-03-24 14:22:36 -06:00
|
|
|
acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle);
|
2009-01-13 16:57:53 -07:00
|
|
|
/* Don't trust ECDT, which comes from ASUSTek */
|
|
|
|
if (!dmi_name_in_vendors("ASUS"))
|
2008-11-26 15:11:53 -07:00
|
|
|
goto install;
|
2009-01-13 16:57:53 -07:00
|
|
|
saved_ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
|
|
|
if (!saved_ec)
|
|
|
|
return -ENOMEM;
|
2009-01-17 04:06:02 -07:00
|
|
|
memcpy(saved_ec, boot_ec, sizeof(*saved_ec));
|
2008-11-26 15:11:53 -07:00
|
|
|
/* fall through */
|
2007-08-03 15:52:48 -06:00
|
|
|
}
|
2008-11-26 15:11:53 -07:00
|
|
|
/* This workaround is needed only on some broken machines,
|
|
|
|
* which require early EC, but fail to provide ECDT */
|
|
|
|
printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n");
|
|
|
|
status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
|
|
|
|
boot_ec, NULL);
|
|
|
|
/* Check that acpi_get_devices actually find something */
|
|
|
|
if (ACPI_FAILURE(status) || !boot_ec->handle)
|
|
|
|
goto error;
|
2009-01-13 16:57:53 -07:00
|
|
|
if (saved_ec) {
|
|
|
|
/* try to find good ECDT from ASUSTek */
|
|
|
|
if (saved_ec->command_addr != boot_ec->command_addr ||
|
|
|
|
saved_ec->data_addr != boot_ec->data_addr ||
|
|
|
|
saved_ec->gpe != boot_ec->gpe ||
|
|
|
|
saved_ec->handle != boot_ec->handle)
|
|
|
|
pr_info(PREFIX "ASUSTek keeps feeding us with broken "
|
|
|
|
"ECDT tables, which are very hard to workaround. "
|
|
|
|
"Trying to use DSDT EC info instead. Please send "
|
|
|
|
"output of acpidump to linux-acpi@vger.kernel.org\n");
|
|
|
|
kfree(saved_ec);
|
|
|
|
saved_ec = NULL;
|
|
|
|
} else {
|
|
|
|
/* We really need to limit this workaround, the only ASUS,
|
|
|
|
* which needs it, has fake EC._INI method, so use it as flag.
|
|
|
|
* Keep boot_ec struct as it will be needed soon.
|
|
|
|
*/
|
|
|
|
acpi_handle dummy;
|
|
|
|
if (!dmi_name_in_vendors("ASUS") ||
|
|
|
|
ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI",
|
|
|
|
&dummy)))
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2008-11-26 15:11:53 -07:00
|
|
|
install:
|
|
|
|
if (!ec_install_handlers(boot_ec)) {
|
2007-03-07 12:28:00 -07:00
|
|
|
first_ec = boot_ec;
|
2007-03-07 12:28:00 -07:00
|
|
|
return 0;
|
2007-03-07 12:28:00 -07:00
|
|
|
}
|
2008-11-26 15:11:53 -07:00
|
|
|
error:
|
2007-03-07 12:28:00 -07:00
|
|
|
kfree(boot_ec);
|
|
|
|
boot_ec = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2008-03-21 08:07:21 -06:00
|
|
|
static int acpi_ec_suspend(struct acpi_device *device, pm_message_t state)
|
|
|
|
{
|
|
|
|
struct acpi_ec *ec = acpi_driver_data(device);
|
|
|
|
/* Stop using GPE */
|
|
|
|
set_bit(EC_FLAGS_NO_GPE, &ec->flags);
|
|
|
|
clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
|
2008-10-25 11:48:46 -06:00
|
|
|
acpi_disable_gpe(NULL, ec->gpe);
|
2008-03-21 08:07:21 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_ec_resume(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
struct acpi_ec *ec = acpi_driver_data(device);
|
|
|
|
/* Enable use of GPE back */
|
|
|
|
clear_bit(EC_FLAGS_NO_GPE, &ec->flags);
|
2008-10-25 11:48:46 -06:00
|
|
|
acpi_enable_gpe(NULL, ec->gpe);
|
2008-03-21 08:07:21 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct acpi_driver acpi_ec_driver = {
|
|
|
|
.name = "ec",
|
|
|
|
.class = ACPI_EC_CLASS,
|
|
|
|
.ids = ec_device_ids,
|
|
|
|
.ops = {
|
|
|
|
.add = acpi_ec_add,
|
|
|
|
.remove = acpi_ec_remove,
|
|
|
|
.start = acpi_ec_start,
|
|
|
|
.stop = acpi_ec_stop,
|
|
|
|
.suspend = acpi_ec_suspend,
|
|
|
|
.resume = acpi_ec_resume,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2005-08-11 15:32:05 -06:00
|
|
|
static int __init acpi_ec_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-11 15:32:05 -06:00
|
|
|
int result = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (acpi_disabled)
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
|
|
|
|
if (!acpi_ec_dir)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Now register the driver for the EC */
|
|
|
|
result = acpi_bus_register_driver(&acpi_ec_driver);
|
|
|
|
if (result < 0) {
|
|
|
|
remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(acpi_ec_init);
|
|
|
|
|
|
|
|
/* EC driver currently not unloadable */
|
|
|
|
#if 0
|
2005-08-11 15:32:05 -06:00
|
|
|
static void __exit acpi_ec_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
|
|
|
acpi_bus_unregister_driver(&acpi_ec_driver);
|
|
|
|
|
|
|
|
remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-10-22 04:18:43 -06:00
|
|
|
#endif /* 0 */
|