2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $)
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*/
|
|
|
|
|
|
|
|
#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-19 07:10:05 +01:00
|
|
|
#include <linux/interrupt.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/io.h>
|
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
|
|
|
#include <acpi/actypes.h>
|
|
|
|
|
|
|
|
#define _COMPONENT ACPI_EC_COMPONENT
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_MODULE_NAME("acpi_ec")
|
2005-04-17 00:20:36 +02:00
|
|
|
#define ACPI_EC_COMPONENT 0x00100000
|
|
|
|
#define ACPI_EC_CLASS "embedded_controller"
|
|
|
|
#define ACPI_EC_HID "PNP0C09"
|
|
|
|
#define ACPI_EC_DRIVER_NAME "ACPI Embedded Controller Driver"
|
|
|
|
#define ACPI_EC_DEVICE_NAME "Embedded Controller"
|
|
|
|
#define ACPI_EC_FILE_INFO "info"
|
2006-09-26 17:50:33 +02:00
|
|
|
|
|
|
|
/* EC status register */
|
2005-04-17 00:20:36 +02:00
|
|
|
#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
|
|
|
|
#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
|
2005-03-19 07:10:05 +01:00
|
|
|
#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
|
2005-04-17 00:20:36 +02:00
|
|
|
#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
|
2006-09-26 17:50:33 +02:00
|
|
|
|
|
|
|
/* EC commands */
|
2005-04-17 00:20:36 +02:00
|
|
|
#define ACPI_EC_COMMAND_READ 0x80
|
|
|
|
#define ACPI_EC_COMMAND_WRITE 0x81
|
2005-03-19 07:10:05 +01:00
|
|
|
#define ACPI_EC_BURST_ENABLE 0x82
|
|
|
|
#define ACPI_EC_BURST_DISABLE 0x83
|
2005-04-17 00:20:36 +02:00
|
|
|
#define ACPI_EC_COMMAND_QUERY 0x84
|
2006-09-26 17:50:33 +02:00
|
|
|
|
|
|
|
/* EC events */
|
|
|
|
enum {
|
|
|
|
ACPI_EC_EVENT_OBF_1 = 1, /* Output buffer full */
|
|
|
|
ACPI_EC_EVENT_IBF_0, /* Input buffer empty */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */
|
|
|
|
#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
|
|
|
|
#define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
|
|
|
|
#define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
|
|
|
|
|
|
|
|
enum {
|
|
|
|
EC_INTR = 1, /* Output buffer full */
|
2006-09-26 17:50:33 +02:00
|
|
|
EC_POLL, /* Input buffer empty */
|
2006-09-26 17:50:33 +02:00
|
|
|
};
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int acpi_ec_remove(struct acpi_device *device, int type);
|
|
|
|
static int acpi_ec_start(struct acpi_device *device);
|
|
|
|
static int acpi_ec_stop(struct acpi_device *device, int type);
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_add(struct acpi_device *device);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static struct acpi_driver acpi_ec_driver = {
|
2005-08-11 23:32:05 +02:00
|
|
|
.name = ACPI_EC_DRIVER_NAME,
|
|
|
|
.class = ACPI_EC_CLASS,
|
|
|
|
.ids = ACPI_EC_HID,
|
|
|
|
.ops = {
|
2006-09-26 17:50:33 +02:00
|
|
|
.add = acpi_ec_add,
|
2005-08-11 23:32:05 +02:00
|
|
|
.remove = acpi_ec_remove,
|
|
|
|
.start = acpi_ec_start,
|
|
|
|
.stop = acpi_ec_stop,
|
|
|
|
},
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
2006-09-26 17:50:33 +02:00
|
|
|
|
|
|
|
/* If we find an EC via the ECDT, we need to keep a ptr to its context */
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec {
|
|
|
|
acpi_handle handle;
|
|
|
|
unsigned long uid;
|
|
|
|
unsigned long gpe_bit;
|
2006-09-26 17:50:33 +02:00
|
|
|
unsigned long command_addr;
|
|
|
|
unsigned long data_addr;
|
2006-09-26 17:50:33 +02:00
|
|
|
unsigned long global_lock;
|
|
|
|
struct semaphore sem;
|
|
|
|
unsigned int expect_event;
|
|
|
|
atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
|
|
|
|
wait_queue_head_t wait;
|
2006-09-26 17:50:33 +02:00
|
|
|
} *ec_ecdt;
|
2006-09-26 17:50:33 +02:00
|
|
|
|
|
|
|
/* External interfaces use first EC only, so remember */
|
|
|
|
static struct acpi_device *first_ec;
|
|
|
|
static int acpi_ec_mode = EC_INTR;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Transaction Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
return inb(ec->command_addr);
|
2005-03-19 07:10:05 +01:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
|
2006-09-26 17:50:33 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
return inb(ec->data_addr);
|
2006-09-26 17:50:33 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
|
2005-07-23 10:08:00 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
outb(command, ec->command_addr);
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
|
2005-07-23 10:08:00 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
outb(data, ec->data_addr);
|
2006-09-26 17:50:33 +02:00
|
|
|
}
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_check_status(u8 status, u8 event)
|
|
|
|
{
|
2005-07-23 10:08:00 +02:00
|
|
|
switch (event) {
|
2006-09-26 17:50:33 +02:00
|
|
|
case ACPI_EC_EVENT_OBF_1:
|
|
|
|
if (status & ACPI_EC_FLAG_OBF)
|
|
|
|
return 1;
|
2005-07-23 10:08:00 +02:00
|
|
|
break;
|
2006-09-26 17:50:33 +02:00
|
|
|
case ACPI_EC_EVENT_IBF_0:
|
|
|
|
if (!(status & ACPI_EC_FLAG_IBF))
|
|
|
|
return 1;
|
2005-07-23 10:08:00 +02:00
|
|
|
break;
|
|
|
|
default:
|
2006-09-26 17:50:33 +02:00
|
|
|
break;
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
return 0;
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
2005-03-19 07:10:05 +01:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_wait(struct acpi_ec *ec, u8 event)
|
2006-09-26 17:50:33 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
int i = (acpi_ec_mode == EC_POLL) ? ACPI_EC_UDELAY_COUNT : 0;
|
|
|
|
long time_left;
|
2005-03-19 07:10:05 +01:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ec->expect_event = event;
|
2006-09-26 17:50:33 +02:00
|
|
|
if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
|
2006-09-26 17:50:33 +02:00
|
|
|
ec->expect_event = 0;
|
|
|
|
return 0;
|
2005-08-10 07:40:00 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
do {
|
|
|
|
if (acpi_ec_mode == EC_POLL) {
|
|
|
|
udelay(ACPI_EC_UDELAY);
|
|
|
|
} else {
|
|
|
|
time_left = wait_event_timeout(ec->wait,
|
|
|
|
!ec->expect_event,
|
|
|
|
msecs_to_jiffies(ACPI_EC_DELAY));
|
|
|
|
if (time_left > 0) {
|
|
|
|
ec->expect_event = 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
return 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
|
|
|
|
ec->expect_event = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} while (--i > 0);
|
|
|
|
|
|
|
|
ec->expect_event = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ETIME;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-12-05 22:33:04 +01:00
|
|
|
#ifdef ACPI_FUTURE_USAGE
|
2005-09-27 06:43:00 +02:00
|
|
|
/*
|
|
|
|
* Note: samsung nv5000 doesn't work with ec burst mode.
|
|
|
|
* http://bugzilla.kernel.org/show_bug.cgi?id=4980
|
|
|
|
*/
|
2006-09-26 17:50:33 +02:00
|
|
|
int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
|
2005-03-19 07:10:05 +01:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
u8 tmp = 0;
|
|
|
|
u8 status = 0;
|
2005-03-19 07:10:05 +01:00
|
|
|
|
|
|
|
|
|
|
|
status = acpi_ec_read_status(ec);
|
2005-08-11 23:32:05 +02:00
|
|
|
if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
2005-08-11 23:32:05 +02:00
|
|
|
if (status)
|
2005-08-10 07:40:00 +02:00
|
|
|
goto end;
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_ec_write_cmd(ec, ACPI_EC_BURST_ENABLE);
|
|
|
|
status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
|
|
|
|
tmp = acpi_ec_read_data(ec);
|
2005-08-11 23:32:05 +02:00
|
|
|
if (tmp != 0x90) { /* Burst ACK byte */
|
2006-06-27 06:41:40 +02:00
|
|
|
return -EINVAL;
|
2005-03-19 07:10:05 +01:00
|
|
|
}
|
2005-07-23 06:26:33 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
atomic_set(&ec->leaving_burst, 0);
|
2006-06-27 06:41:40 +02:00
|
|
|
return 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
end:
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "EC wait, burst mode"));
|
2006-06-27 06:41:40 +02:00
|
|
|
return -1;
|
2005-03-19 07:10:05 +01:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
int acpi_ec_leave_burst_mode(struct acpi_ec *ec)
|
2005-03-19 07:10:05 +01:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
u8 status = 0;
|
2005-03-19 07:10:05 +01:00
|
|
|
|
|
|
|
|
2005-09-27 06:43:00 +02:00
|
|
|
status = acpi_ec_read_status(ec);
|
|
|
|
if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
2005-09-27 06:43:00 +02:00
|
|
|
if(status)
|
|
|
|
goto end;
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_ec_write_cmd(ec, ACPI_EC_BURST_DISABLE);
|
|
|
|
acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
2006-09-26 17:50:33 +02:00
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
atomic_set(&ec->leaving_burst, 1);
|
2006-06-27 06:41:40 +02:00
|
|
|
return 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
end:
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode"));
|
2006-06-27 06:41:40 +02:00
|
|
|
return -1;
|
2005-03-19 07:10:05 +01:00
|
|
|
}
|
2005-12-05 22:33:04 +01:00
|
|
|
#endif /* ACPI_FUTURE_USAGE */
|
2005-03-19 07:10:05 +01:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command,
|
2006-09-26 17:50:33 +02:00
|
|
|
const u8 *wdata, unsigned wdata_len,
|
|
|
|
u8 *rdata, unsigned rdata_len)
|
2005-07-23 10:08:00 +02:00
|
|
|
{
|
2006-09-05 18:12:24 +02:00
|
|
|
int result;
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_ec_write_cmd(ec, command);
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
for (; wdata_len > 0; wdata_len --) {
|
2006-09-26 17:50:33 +02:00
|
|
|
result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
2006-09-26 17:50:33 +02:00
|
|
|
if (result)
|
|
|
|
return result;
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_ec_write_data(ec, *(wdata++));
|
2006-09-26 17:50:33 +02:00
|
|
|
}
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
if (command == ACPI_EC_COMMAND_WRITE) {
|
2006-09-26 17:50:33 +02:00
|
|
|
result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
2006-09-26 17:50:33 +02:00
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
}
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
for (; rdata_len > 0; rdata_len --) {
|
2006-09-26 17:50:33 +02:00
|
|
|
result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
|
2006-09-26 17:50:33 +02:00
|
|
|
if (result)
|
|
|
|
return result;
|
2005-08-11 23:32:05 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
*(rdata++) = acpi_ec_read_data(ec);
|
2006-09-26 17:50:33 +02:00
|
|
|
}
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
return 0;
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
|
|
|
|
const u8 *wdata, unsigned wdata_len,
|
|
|
|
u8 *rdata, unsigned rdata_len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-05 18:12:24 +02:00
|
|
|
int status;
|
2005-08-11 23:32:05 +02:00
|
|
|
u32 glk;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata))
|
2006-06-27 06:41:40 +02:00
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
if (rdata)
|
|
|
|
memset(rdata, 0, rdata_len);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
if (ec->global_lock) {
|
2005-04-17 00:20:36 +02:00
|
|
|
status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
|
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
down(&ec->sem);
|
2005-03-19 07:10:05 +01:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
2005-08-10 07:40:00 +02:00
|
|
|
if (status) {
|
2006-09-26 17:50:33 +02:00
|
|
|
printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
|
2005-03-19 07:10:05 +01:00
|
|
|
goto end;
|
2005-08-10 07:40:00 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
status = acpi_ec_transaction_unlocked(ec, command,
|
|
|
|
wdata, wdata_len,
|
|
|
|
rdata, rdata_len);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
end:
|
2006-09-26 17:50:33 +02:00
|
|
|
up(&ec->sem);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
if (ec->global_lock)
|
2005-04-17 00:20:36 +02:00
|
|
|
acpi_release_global_lock(glk);
|
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
|
2006-09-26 17:50:33 +02:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
u8 d;
|
|
|
|
|
|
|
|
result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ,
|
|
|
|
&address, 1, &d, 1);
|
|
|
|
*data = d;
|
|
|
|
return result;
|
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
|
|
|
|
{
|
|
|
|
u8 wdata[2] = { address, data };
|
|
|
|
return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
|
|
|
|
wdata, 2, NULL, 0);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Externally callable EC access functions. For now, assume 1 EC only
|
|
|
|
*/
|
2006-09-26 17:50:33 +02:00
|
|
|
int ec_read(u8 addr, u8 *val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err;
|
2006-09-26 17:50:33 +02:00
|
|
|
u8 temp_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
ec = acpi_driver_data(first_ec);
|
|
|
|
|
|
|
|
err = acpi_ec_read(ec, addr, &temp_data);
|
|
|
|
|
|
|
|
if (!err) {
|
|
|
|
*val = temp_data;
|
|
|
|
return 0;
|
2005-08-11 23:32:05 +02:00
|
|
|
} else
|
2005-04-17 00:20:36 +02:00
|
|
|
return err;
|
|
|
|
}
|
2005-08-11 23:32:05 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL(ec_read);
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
int ec_write(u8 addr, u8 val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
ec = acpi_driver_data(first_ec);
|
|
|
|
|
|
|
|
err = acpi_ec_write(ec, addr, val);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2005-08-11 23:32:05 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL(ec_write);
|
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
extern int ec_transaction(u8 command,
|
|
|
|
const u8 *wdata, unsigned wdata_len,
|
|
|
|
u8 *rdata, unsigned rdata_len)
|
2005-07-23 10:08:00 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec;
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
if (!first_ec)
|
|
|
|
return -ENODEV;
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
ec = acpi_driver_data(first_ec);
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
return acpi_ec_transaction(ec, command, wdata,
|
|
|
|
wdata_len, rdata, rdata_len);
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
|
2006-09-26 17:50:33 +02:00
|
|
|
{
|
|
|
|
int result;
|
2006-09-05 18:12:24 +02:00
|
|
|
u8 d;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
if (!ec || !data)
|
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02: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-10 07:40:00 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
|
|
|
|
if (result)
|
|
|
|
return result;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
if (!d)
|
|
|
|
return -ENODATA;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-05 18:12:24 +02:00
|
|
|
*data = d;
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Event Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec_query_data {
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_handle handle;
|
|
|
|
u8 data;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static void acpi_ec_gpe_query(void *ec_cxt)
|
2005-07-23 10:08:00 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = (struct acpi_ec *)ec_cxt;
|
2006-09-26 17:50:33 +02:00
|
|
|
u8 value = 0;
|
|
|
|
static char object_name[8];
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
if (!ec)
|
2005-07-23 10:08:00 +02:00
|
|
|
goto end;
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
value = acpi_ec_read_status(ec);
|
2005-07-23 10:08:00 +02:00
|
|
|
|
|
|
|
if (!(value & ACPI_EC_FLAG_SCI))
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
if (acpi_ec_query(ec, &value))
|
|
|
|
goto end;
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
snprintf(object_name, 8, "_Q%2.2X", value);
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s", object_name));
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
end:
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static u32 acpi_ec_gpe_handler(void *data)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_status status = AE_OK;
|
2006-09-26 17:50:33 +02:00
|
|
|
u8 value;
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = (struct acpi_ec *)data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_clear_gpe(NULL, ec->gpe_bit, ACPI_ISR);
|
2005-03-19 07:10:05 +01:00
|
|
|
value = acpi_ec_read_status(ec);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
if (acpi_ec_mode == EC_INTR) {
|
|
|
|
if (acpi_ec_check_status(value, ec->expect_event)) {
|
|
|
|
ec->expect_event = 0;
|
|
|
|
wake_up(&ec->wait);
|
|
|
|
}
|
2005-03-19 07:10:05 +01:00
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
if (value & ACPI_EC_FLAG_SCI) {
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec);
|
2005-04-23 05:07:10 +02:00
|
|
|
return status == AE_OK ?
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
|
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_ISR);
|
2005-03-19 07:10:05 +01:00
|
|
|
return status == AE_OK ?
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Address Space Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static acpi_status
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_ec_space_setup(acpi_handle region_handle,
|
|
|
|
u32 function, void *handler_context, void **return_context)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* The EC object is in the handler context and is needed
|
|
|
|
* when calling the acpi_ec_space_handler.
|
|
|
|
*/
|
2005-08-11 23:32:05 +02:00
|
|
|
*return_context = (function != ACPI_REGION_DEACTIVATE) ?
|
|
|
|
handler_context : NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static acpi_status
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_ec_space_handler(u32 function,
|
|
|
|
acpi_physical_address address,
|
|
|
|
u32 bit_width,
|
|
|
|
acpi_integer * value,
|
|
|
|
void *handler_context, void *region_context)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
int result = 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = NULL;
|
2005-08-11 23:32:05 +02:00
|
|
|
u64 temp = *value;
|
|
|
|
acpi_integer f_v = 0;
|
|
|
|
int i = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
if ((address > 0xFF) || !value || !handler_context)
|
2006-06-27 06:41:40 +02:00
|
|
|
return AE_BAD_PARAMETER;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-03-19 07:54:47 +01:00
|
|
|
if (bit_width != 8 && acpi_strict) {
|
2006-06-27 06:41:40 +02:00
|
|
|
return AE_BAD_PARAMETER;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ec = (struct acpi_ec *)handler_context;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
next_byte:
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (function) {
|
|
|
|
case ACPI_READ:
|
2005-03-19 07:54:47 +01:00
|
|
|
temp = 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
result = acpi_ec_read(ec, (u8) address, (u8 *) &temp);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case ACPI_WRITE:
|
2005-03-19 07:54:47 +01:00
|
|
|
result = acpi_ec_write(ec, (u8) address, (u8) temp);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bit_width -= 8;
|
2005-03-19 07:54:47 +01:00
|
|
|
if (bit_width) {
|
|
|
|
if (function == ACPI_READ)
|
|
|
|
f_v |= temp << 8 * i;
|
|
|
|
if (function == ACPI_WRITE)
|
|
|
|
temp >>= 8;
|
2005-04-17 00:20:36 +02:00
|
|
|
i++;
|
2005-03-31 05:12:13 +02:00
|
|
|
address++;
|
2005-04-17 00:20:36 +02:00
|
|
|
goto next_byte;
|
|
|
|
}
|
|
|
|
|
2005-03-19 07:54:47 +01:00
|
|
|
if (function == ACPI_READ) {
|
|
|
|
f_v |= temp << 8 * i;
|
2005-04-17 00:20:36 +02:00
|
|
|
*value = f_v;
|
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
out:
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (result) {
|
|
|
|
case -EINVAL:
|
2006-06-27 06:41:40 +02:00
|
|
|
return AE_BAD_PARAMETER;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case -ENODEV:
|
2006-06-27 06:41:40 +02:00
|
|
|
return AE_NOT_FOUND;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case -ETIME:
|
2006-06-27 06:41:40 +02:00
|
|
|
return AE_TIME;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
default:
|
2006-06-27 06:41:40 +02:00
|
|
|
return AE_OK;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
FS Interface (/proc)
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static struct proc_dir_entry *acpi_ec_dir;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int acpi_ec_read_info(struct seq_file *seq, void *offset)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = (struct acpi_ec *)seq->private;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
if (!ec)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
seq_printf(seq, "gpe bit: 0x%02x\n",
|
2006-09-26 17:50:33 +02:00
|
|
|
(u32) ec->gpe_bit);
|
2005-04-17 00:20:36 +02:00
|
|
|
seq_printf(seq, "ports: 0x%02x, 0x%02x\n",
|
2006-09-26 17:50:33 +02:00
|
|
|
(u32) ec->command_addr,
|
|
|
|
(u32) ec->data_addr);
|
2005-04-17 00:20:36 +02:00
|
|
|
seq_printf(seq, "use global lock: %s\n",
|
2006-09-26 17:50:33 +02:00
|
|
|
ec->global_lock ? "yes" : "no");
|
|
|
|
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
end:
|
2006-06-27 06:41:40 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02: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 17:50:33 +02:00
|
|
|
static struct file_operations acpi_ec_info_ops = {
|
2005-08-11 23:32:05 +02:00
|
|
|
.open = acpi_ec_info_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2005-04-17 00:20:36 +02:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int acpi_ec_add_fs(struct acpi_device *device)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
struct proc_dir_entry *entry = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
if (!acpi_device_dir(device)) {
|
|
|
|
acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_ec_dir);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!acpi_device_dir(device))
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_device_dir(device));
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!entry)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
else {
|
|
|
|
entry->proc_fops = &acpi_ec_info_ops;
|
|
|
|
entry->data = acpi_driver_data(device);
|
|
|
|
entry->owner = THIS_MODULE;
|
|
|
|
}
|
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int acpi_ec_remove_fs(struct acpi_device *device)
|
2005-04-17 00:20:36 +02: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-27 06:41:40 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
static int acpi_ec_add(struct acpi_device *device)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = NULL;
|
2005-07-23 10:08:00 +02:00
|
|
|
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -EINVAL;
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
2005-07-23 10:08:00 +02:00
|
|
|
if (!ec)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENOMEM;
|
2006-09-26 17:50:33 +02:00
|
|
|
memset(ec, 0, sizeof(struct acpi_ec));
|
|
|
|
|
|
|
|
ec->handle = device->handle;
|
|
|
|
ec->uid = -1;
|
|
|
|
init_MUTEX(&ec->sem);
|
|
|
|
if (acpi_ec_mode == EC_INTR) {
|
|
|
|
atomic_set(&ec->leaving_burst, 1);
|
|
|
|
init_waitqueue_head(&ec->wait);
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_EC_CLASS);
|
|
|
|
acpi_driver_data(device) = ec;
|
|
|
|
|
|
|
|
/* Use the global lock for all EC transactions? */
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_evaluate_integer(ec->handle, "_GLK", NULL,
|
|
|
|
&ec->global_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-29 00:04:00 +02:00
|
|
|
/* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
|
|
|
|
http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
|
|
|
|
if (ec_ecdt) {
|
2005-04-17 00:20:36 +02:00
|
|
|
acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_ADR_SPACE_EC,
|
|
|
|
&acpi_ec_space_handler);
|
2005-03-19 07:10:05 +01:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
|
2005-08-11 23:32:05 +02:00
|
|
|
&acpi_ec_gpe_handler);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
kfree(ec_ecdt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get GPE bit assignment (EC events). */
|
|
|
|
/* TODO: Add support for _GPE returning a package */
|
2005-08-11 23:32:05 +02:00
|
|
|
status =
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_evaluate_integer(ec->handle, "_GPE", NULL,
|
|
|
|
&ec->gpe_bit);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit assignment"));
|
2005-04-17 00:20:36 +02:00
|
|
|
result = -ENODEV;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = acpi_ec_add_fs(device);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s [%s] (gpe %d) interrupt mode.",
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_device_name(device), acpi_device_bid(device),
|
2006-09-26 17:50:33 +02:00
|
|
|
(u32) ec->gpe_bit));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!first_ec)
|
|
|
|
first_ec = device;
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
end:
|
2005-04-17 00:20:36 +02:00
|
|
|
if (result)
|
|
|
|
kfree(ec);
|
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return result;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int acpi_ec_remove(struct acpi_device *device, int type)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ec = acpi_driver_data(device);
|
|
|
|
|
|
|
|
acpi_ec_remove_fs(device);
|
|
|
|
|
|
|
|
kfree(ec);
|
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static acpi_status
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_ec_io_ports(struct acpi_resource *resource, void *context)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = (struct acpi_ec *)context;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[ACPI] ACPICA 20050930
Completed a major overhaul of the Resource Manager code -
specifically, optimizations in the area of the AML/internal
resource conversion code. The code has been optimized to
simplify and eliminate duplicated code, CPU stack use has
been decreased by optimizing function parameters and local
variables, and naming conventions across the manager have
been standardized for clarity and ease of maintenance (this
includes function, parameter, variable, and struct/typedef
names.)
All Resource Manager dispatch and information tables have
been moved to a single location for clarity and ease of
maintenance. One new file was created, named "rsinfo.c".
The ACPI return macros (return_ACPI_STATUS, etc.) have
been modified to guarantee that the argument is
not evaluated twice, making them less prone to macro
side-effects. However, since there exists the possibility
of additional stack use if a particular compiler cannot
optimize them (such as in the debug generation case),
the original macros are optionally available. Note that
some invocations of the return_VALUE macro may now cause
size mismatch warnings; the return_UINT8 and return_UINT32
macros are provided to eliminate these. (From Randy Dunlap)
Implemented a new mechanism to enable debug tracing for
individual control methods. A new external interface,
acpi_debug_trace(), is provided to enable this mechanism. The
intent is to allow the host OS to easily enable and disable
tracing for problematic control methods. This interface
can be easily exposed to a user or debugger interface if
desired. See the file psxface.c for details.
acpi_ut_callocate() will now return a valid pointer if a
length of zero is specified - a length of one is used
and a warning is issued. This matches the behavior of
acpi_ut_allocate().
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2005-10-01 01:03:00 +02:00
|
|
|
if (resource->type != ACPI_RESOURCE_TYPE_IO) {
|
2005-04-17 00:20:36 +02:00
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The first address region returned is the data port, and
|
|
|
|
* the second address region returned is the status/command
|
|
|
|
* port.
|
|
|
|
*/
|
2006-09-26 17:50:33 +02:00
|
|
|
if (ec->data_addr == 0) {
|
|
|
|
ec->data_addr = resource->data.io.minimum;
|
|
|
|
} else if (ec->command_addr == 0) {
|
|
|
|
ec->command_addr = resource->data.io.minimum;
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
return AE_CTRL_TERMINATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int acpi_ec_start(struct acpi_device *device)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_status status = AE_OK;
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ec = acpi_driver_data(device);
|
|
|
|
|
|
|
|
if (!ec)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get I/O port addresses. Convert to GAS format.
|
|
|
|
*/
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_walk_resources(ec->handle, METHOD_NAME__CRS,
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_ec_io_ports, ec);
|
2006-09-26 17:50:33 +02:00
|
|
|
if (ACPI_FAILURE(status) || ec->command_addr == 0) {
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
|
|
|
"Error getting I/O port addresses"));
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02lx, ports=0x%2lx,0x%2lx",
|
|
|
|
ec->gpe_bit, ec->command_addr, ec->data_addr));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Install GPE handler
|
|
|
|
*/
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_install_gpe_handler(NULL, ec->gpe_bit,
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_GPE_EDGE_TRIGGERED,
|
|
|
|
&acpi_ec_gpe_handler, ec);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_set_gpe_type(NULL, ec->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
|
|
|
|
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_install_address_space_handler(ec->handle,
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_ADR_SPACE_EC,
|
|
|
|
&acpi_ec_space_handler,
|
|
|
|
&acpi_ec_space_setup, ec);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_remove_gpe_handler(NULL, ec->gpe_bit,
|
2005-08-11 23:32:05 +02:00
|
|
|
&acpi_ec_gpe_handler);
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return AE_OK;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int acpi_ec_stop(struct acpi_device *device, int type)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_status status = AE_OK;
|
2006-09-26 17:50:33 +02:00
|
|
|
struct acpi_ec *ec = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ec = acpi_driver_data(device);
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_remove_address_space_handler(ec->handle,
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_ADR_SPACE_EC,
|
|
|
|
&acpi_ec_space_handler);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
status =
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_remove_gpe_handler(NULL, ec->gpe_bit,
|
2005-08-11 23:32:05 +02:00
|
|
|
&acpi_ec_gpe_handler);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static acpi_status __init
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_fake_ecdt_callback(acpi_handle handle,
|
|
|
|
u32 Level, void *context, void **retval)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_status status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
init_MUTEX(&ec_ecdt->sem);
|
|
|
|
if (acpi_ec_mode == EC_INTR) {
|
|
|
|
init_waitqueue_head(&ec_ecdt->wait);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
status = acpi_walk_resources(handle, METHOD_NAME__CRS,
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_ec_io_ports, ec_ecdt);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return status;
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ec_ecdt->uid = -1;
|
|
|
|
acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
status =
|
|
|
|
acpi_evaluate_integer(handle, "_GPE", NULL,
|
2006-09-26 17:50:33 +02:00
|
|
|
&ec_ecdt->gpe_bit);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return status;
|
2006-09-26 17:50:33 +02:00
|
|
|
ec_ecdt->global_lock = TRUE;
|
|
|
|
ec_ecdt->handle = handle;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "GPE=0x%02lx, ports=0x%2lx, 0x%2lx",
|
|
|
|
ec_ecdt->gpe_bit, ec_ecdt->command_addr, ec_ecdt->data_addr));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return AE_CTRL_TERMINATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some BIOS (such as some from Gateway laptops) access EC region very early
|
|
|
|
* such as in BAT0._INI or EC._INI before an EC device is found and
|
|
|
|
* do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
|
|
|
|
* required, but if EC regison is accessed early, it is required.
|
|
|
|
* The routine tries to workaround the BIOS bug by pre-scan EC device
|
|
|
|
* It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
|
|
|
|
* op region (since _REG isn't invoked yet). The assumption is true for
|
|
|
|
* all systems found.
|
|
|
|
*/
|
2005-08-11 23:32:05 +02:00
|
|
|
static int __init acpi_ec_fake_ecdt(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_status status;
|
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Try to make an fake ECDT"));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ec_ecdt) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
memset(ec_ecdt, 0, sizeof(struct acpi_ec));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
status = acpi_get_devices(ACPI_EC_HID,
|
|
|
|
acpi_fake_ecdt_callback, NULL, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
kfree(ec_ecdt);
|
|
|
|
ec_ecdt = NULL;
|
|
|
|
ret = -ENODEV;
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Can't make an fake ECDT"));
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
return 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
error:
|
2005-04-17 00:20:36 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int __init acpi_ec_get_real_ecdt(void)
|
2005-07-23 10:08:00 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_status status;
|
|
|
|
struct acpi_table_ecdt *ecdt_ptr;
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
|
|
|
|
(struct acpi_table_header **)
|
|
|
|
&ecdt_ptr);
|
2005-07-23 10:08:00 +02:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found ECDT"));
|
2005-07-23 10:08:00 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Generate a temporary ec context to use until the namespace is scanned
|
|
|
|
*/
|
2006-09-26 17:50:33 +02:00
|
|
|
ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
2005-07-23 10:08:00 +02:00
|
|
|
if (!ec_ecdt)
|
|
|
|
return -ENOMEM;
|
2006-09-26 17:50:33 +02:00
|
|
|
memset(ec_ecdt, 0, sizeof(struct acpi_ec));
|
2005-07-23 10:08:00 +02:00
|
|
|
|
2006-09-26 17:50:33 +02:00
|
|
|
init_MUTEX(&ec_ecdt->sem);
|
|
|
|
if (acpi_ec_mode == EC_INTR) {
|
|
|
|
init_waitqueue_head(&ec_ecdt->wait);
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
ec_ecdt->command_addr = ecdt_ptr->ec_control.address;
|
|
|
|
ec_ecdt->data_addr = ecdt_ptr->ec_data.address;
|
2006-09-26 17:50:33 +02:00
|
|
|
ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* use the GL just to be safe */
|
2006-09-26 17:50:33 +02:00
|
|
|
ec_ecdt->global_lock = TRUE;
|
|
|
|
ec_ecdt->uid = ecdt_ptr->uid;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
status =
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2006-09-26 17:50:33 +02:00
|
|
|
error:
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(ec_ecdt);
|
|
|
|
ec_ecdt = NULL;
|
|
|
|
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __initdata acpi_fake_ecdt_enabled;
|
2005-08-11 23:32:05 +02:00
|
|
|
int __init acpi_ec_ecdt_probe(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
acpi_status status;
|
|
|
|
int ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ret = acpi_ec_get_real_ecdt();
|
|
|
|
/* Try to make a fake ECDT */
|
|
|
|
if (ret && acpi_fake_ecdt_enabled) {
|
|
|
|
ret = acpi_ec_fake_ecdt();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Install GPE handler
|
|
|
|
*/
|
2006-09-26 17:50:33 +02:00
|
|
|
status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit,
|
2005-08-11 23:32:05 +02:00
|
|
|
ACPI_GPE_EDGE_TRIGGERED,
|
|
|
|
&acpi_ec_gpe_handler, ec_ecdt);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
goto error;
|
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_set_gpe_type(NULL, ec_ecdt->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
|
|
|
|
acpi_enable_gpe(NULL, ec_ecdt->gpe_bit, ACPI_NOT_ISR);
|
2005-08-11 23:32:05 +02:00
|
|
|
|
|
|
|
status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
|
|
|
|
ACPI_ADR_SPACE_EC,
|
|
|
|
&acpi_ec_space_handler,
|
|
|
|
&acpi_ec_space_setup,
|
|
|
|
ec_ecdt);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
|
2005-08-11 23:32:05 +02:00
|
|
|
&acpi_ec_gpe_handler);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
error:
|
2006-09-26 17:50:33 +02:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(ec_ecdt);
|
|
|
|
ec_ecdt = NULL;
|
|
|
|
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2005-08-11 23:32:05 +02:00
|
|
|
static int __init acpi_ec_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-11 23:32:05 +02:00
|
|
|
int result = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
if (acpi_disabled)
|
2006-06-27 06:41:40 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
|
|
|
|
if (!acpi_ec_dir)
|
2006-06-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02: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-27 06:41:40 +02:00
|
|
|
return -ENODEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return result;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(acpi_ec_init);
|
|
|
|
|
|
|
|
/* EC driver currently not unloadable */
|
|
|
|
#if 0
|
2005-08-11 23:32:05 +02:00
|
|
|
static void __exit acpi_ec_exit(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
|
|
|
|
acpi_bus_unregister_driver(&acpi_ec_driver);
|
|
|
|
|
|
|
|
remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
|
|
|
|
|
2006-06-27 06:41:40 +02:00
|
|
|
return;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-08-11 23:32:05 +02:00
|
|
|
#endif /* 0 */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static int __init acpi_fake_ecdt_setup(char *str)
|
|
|
|
{
|
|
|
|
acpi_fake_ecdt_enabled = 1;
|
2006-03-31 12:30:33 +02:00
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-08-03 23:38:04 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
__setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
|
2005-12-05 22:33:04 +01:00
|
|
|
static int __init acpi_ec_set_intr_mode(char *str)
|
2005-07-23 10:08:00 +02:00
|
|
|
{
|
2005-12-05 22:33:04 +01:00
|
|
|
int intr;
|
2005-08-03 23:38:04 +02:00
|
|
|
|
2005-12-05 22:33:04 +01:00
|
|
|
if (!get_option(&str, &intr))
|
2005-08-03 23:38:04 +02:00
|
|
|
return 0;
|
|
|
|
|
2005-12-05 22:33:04 +01:00
|
|
|
if (intr) {
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_ec_mode = EC_INTR;
|
2005-08-03 23:38:04 +02:00
|
|
|
} else {
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_ec_mode = EC_POLL;
|
2005-08-03 23:38:04 +02:00
|
|
|
}
|
2006-09-26 17:50:33 +02:00
|
|
|
acpi_ec_driver.ops.add = acpi_ec_add;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n", intr ? "interrupt" : "polling"));
|
|
|
|
|
2006-03-31 12:30:33 +02:00
|
|
|
return 1;
|
2005-07-23 10:08:00 +02:00
|
|
|
}
|
2005-08-11 23:32:05 +02:00
|
|
|
|
2005-12-05 22:46:36 +01:00
|
|
|
__setup("ec_intr=", acpi_ec_set_intr_mode);
|