mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-31 04:01:48 -04:00
Pull release into acpica branch
This commit is contained in:
Len Brown
commit
292dd876ee
4153 changed files with 174896 additions and 96659 deletions
|
|
@ -168,7 +168,6 @@ config ACPI_NUMA
|
|||
config ACPI_ASUS
|
||||
tristate "ASUS/Medion Laptop Extras"
|
||||
depends on X86
|
||||
default y
|
||||
---help---
|
||||
This driver provides support for extra features of ACPI-compatible
|
||||
ASUS laptops. As some of Medion laptops are made by ASUS, it may also
|
||||
|
|
@ -209,7 +208,6 @@ config ACPI_IBM
|
|||
config ACPI_TOSHIBA
|
||||
tristate "Toshiba Laptop Extras"
|
||||
depends on X86
|
||||
default y
|
||||
---help---
|
||||
This driver adds support for access to certain system settings
|
||||
on "legacy free" Toshiba laptops. These laptops can be recognized by
|
||||
|
|
@ -269,7 +267,6 @@ config ACPI_DEBUG
|
|||
|
||||
config ACPI_EC
|
||||
bool
|
||||
depends on X86
|
||||
default y
|
||||
help
|
||||
This driver is required on some systems for the proper operation of
|
||||
|
|
|
|||
|
|
@ -78,9 +78,9 @@ MODULE_LICENSE("GPL");
|
|||
static uid_t asus_uid;
|
||||
static gid_t asus_gid;
|
||||
module_param(asus_uid, uint, 0);
|
||||
MODULE_PARM_DESC(uid, "UID for entries in /proc/acpi/asus.\n");
|
||||
MODULE_PARM_DESC(asus_uid, "UID for entries in /proc/acpi/asus.\n");
|
||||
module_param(asus_gid, uint, 0);
|
||||
MODULE_PARM_DESC(gid, "GID for entries in /proc/acpi/asus.\n");
|
||||
MODULE_PARM_DESC(asus_gid, "GID for entries in /proc/acpi/asus.\n");
|
||||
|
||||
/* For each model, all features implemented,
|
||||
* those marked with R are relative to HOTK, A for absolute */
|
||||
|
|
@ -302,7 +302,7 @@ static struct model_data model_conf[END_MODEL] = {
|
|||
.brightness_set = "SPLV",
|
||||
.brightness_get = "GPLV",
|
||||
.display_set = "SDSP",
|
||||
.display_get = "\\SSTE"},
|
||||
.display_get = "\\_SB.PCI0.P0P1.VGA.GETD"},
|
||||
{
|
||||
.name = "M6R",
|
||||
.mt_mled = "MLED",
|
||||
|
|
@ -851,6 +851,8 @@ static int __init asus_hotk_add_fs(struct acpi_device *device)
|
|||
mode = S_IFREG | S_IRUGO | S_IWUGO;
|
||||
} else {
|
||||
mode = S_IFREG | S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP;
|
||||
printk(KERN_WARNING " asus_uid and asus_gid parameters are "
|
||||
"deprecated, use chown and chmod instead!\n");
|
||||
}
|
||||
|
||||
acpi_device_dir(device) = asus_proc_dir;
|
||||
|
|
@ -987,9 +989,21 @@ static int __init asus_hotk_get_info(void)
|
|||
printk(KERN_NOTICE " BSTS called, 0x%02x returned\n",
|
||||
bsts_result);
|
||||
|
||||
/* Samsung P30 has a device with a valid _HID whose INIT does not
|
||||
* return anything. Catch this one and any similar here */
|
||||
if (buffer.pointer == NULL) {
|
||||
/* This is unlikely with implicit return */
|
||||
if (buffer.pointer == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
model = (union acpi_object *) buffer.pointer;
|
||||
/*
|
||||
* Samsung P30 has a device with a valid _HID whose INIT does not
|
||||
* return anything. It used to be possible to catch this exception,
|
||||
* but the implicit return code will now happily confuse the
|
||||
* driver. We assume that every ACPI_TYPE_STRING is a valid model
|
||||
* identifier but it's still possible to get completely bogus data.
|
||||
*/
|
||||
if (model->type == ACPI_TYPE_STRING) {
|
||||
printk(KERN_NOTICE " %s model detected, ", model->string.pointer);
|
||||
} else {
|
||||
if (asus_info && /* Samsung P30 */
|
||||
strncmp(asus_info->oem_table_id, "ODEM", 4) == 0) {
|
||||
hotk->model = P30;
|
||||
|
|
@ -1002,13 +1016,10 @@ static int __init asus_hotk_get_info(void)
|
|||
"the developers with your DSDT\n");
|
||||
}
|
||||
hotk->methods = &model_conf[hotk->model];
|
||||
return AE_OK;
|
||||
}
|
||||
|
||||
acpi_os_free(model);
|
||||
|
||||
model = (union acpi_object *)buffer.pointer;
|
||||
if (model->type == ACPI_TYPE_STRING) {
|
||||
printk(KERN_NOTICE " %s model detected, ",
|
||||
model->string.pointer);
|
||||
return AE_OK;
|
||||
}
|
||||
|
||||
hotk->model = END_MODEL;
|
||||
|
|
|
|||
|
|
@ -60,20 +60,20 @@ ACPI_MODULE_NAME("acpi_ec")
|
|||
#define ACPI_EC_BURST_ENABLE 0x82
|
||||
#define ACPI_EC_BURST_DISABLE 0x83
|
||||
#define ACPI_EC_COMMAND_QUERY 0x84
|
||||
#define EC_POLLING 0xFF
|
||||
#define EC_BURST 0x00
|
||||
#define EC_POLL 0xFF
|
||||
#define EC_INTR 0x00
|
||||
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);
|
||||
static int acpi_ec_burst_add(struct acpi_device *device);
|
||||
static int acpi_ec_polling_add(struct acpi_device *device);
|
||||
static int acpi_ec_intr_add(struct acpi_device *device);
|
||||
static int acpi_ec_poll_add(struct acpi_device *device);
|
||||
|
||||
static struct acpi_driver acpi_ec_driver = {
|
||||
.name = ACPI_EC_DRIVER_NAME,
|
||||
.class = ACPI_EC_CLASS,
|
||||
.ids = ACPI_EC_HID,
|
||||
.ops = {
|
||||
.add = acpi_ec_polling_add,
|
||||
.add = acpi_ec_intr_add,
|
||||
.remove = acpi_ec_remove,
|
||||
.start = acpi_ec_start,
|
||||
.stop = acpi_ec_stop,
|
||||
|
|
@ -105,7 +105,7 @@ union acpi_ec {
|
|||
atomic_t pending_gpe;
|
||||
struct semaphore sem;
|
||||
wait_queue_head_t wait;
|
||||
} burst;
|
||||
} intr;
|
||||
|
||||
struct {
|
||||
u32 mode;
|
||||
|
|
@ -117,43 +117,43 @@ union acpi_ec {
|
|||
struct acpi_generic_address data_addr;
|
||||
unsigned long global_lock;
|
||||
spinlock_t lock;
|
||||
} polling;
|
||||
} poll;
|
||||
};
|
||||
|
||||
static int acpi_ec_polling_wait(union acpi_ec *ec, u8 event);
|
||||
static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event);
|
||||
static int acpi_ec_polling_read(union acpi_ec *ec, u8 address, u32 * data);
|
||||
static int acpi_ec_burst_read(union acpi_ec *ec, u8 address, u32 * data);
|
||||
static int acpi_ec_polling_write(union acpi_ec *ec, u8 address, u8 data);
|
||||
static int acpi_ec_burst_write(union acpi_ec *ec, u8 address, u8 data);
|
||||
static int acpi_ec_polling_query(union acpi_ec *ec, u32 * data);
|
||||
static int acpi_ec_burst_query(union acpi_ec *ec, u32 * data);
|
||||
static void acpi_ec_gpe_polling_query(void *ec_cxt);
|
||||
static void acpi_ec_gpe_burst_query(void *ec_cxt);
|
||||
static u32 acpi_ec_gpe_polling_handler(void *data);
|
||||
static u32 acpi_ec_gpe_burst_handler(void *data);
|
||||
static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event);
|
||||
static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event);
|
||||
static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data);
|
||||
static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data);
|
||||
static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data);
|
||||
static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data);
|
||||
static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data);
|
||||
static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data);
|
||||
static void acpi_ec_gpe_poll_query(void *ec_cxt);
|
||||
static void acpi_ec_gpe_intr_query(void *ec_cxt);
|
||||
static u32 acpi_ec_gpe_poll_handler(void *data);
|
||||
static u32 acpi_ec_gpe_intr_handler(void *data);
|
||||
static acpi_status __init
|
||||
acpi_fake_ecdt_polling_callback(acpi_handle handle,
|
||||
acpi_fake_ecdt_poll_callback(acpi_handle handle,
|
||||
u32 Level, void *context, void **retval);
|
||||
|
||||
static acpi_status __init
|
||||
acpi_fake_ecdt_burst_callback(acpi_handle handle,
|
||||
acpi_fake_ecdt_intr_callback(acpi_handle handle,
|
||||
u32 Level, void *context, void **retval);
|
||||
|
||||
static int __init acpi_ec_polling_get_real_ecdt(void);
|
||||
static int __init acpi_ec_burst_get_real_ecdt(void);
|
||||
static int __init acpi_ec_poll_get_real_ecdt(void);
|
||||
static int __init acpi_ec_intr_get_real_ecdt(void);
|
||||
/* If we find an EC via the ECDT, we need to keep a ptr to its context */
|
||||
static union acpi_ec *ec_ecdt;
|
||||
|
||||
/* External interfaces use first EC only, so remember */
|
||||
static struct acpi_device *first_ec;
|
||||
static int acpi_ec_polling_mode = EC_POLLING;
|
||||
static int acpi_ec_poll_mode = EC_INTR;
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
Transaction Management
|
||||
-------------------------------------------------------------------------- */
|
||||
|
||||
static inline u32 acpi_ec_read_status(union acpi_ec *ec)
|
||||
static u32 acpi_ec_read_status(union acpi_ec *ec)
|
||||
{
|
||||
u32 status = 0;
|
||||
|
||||
|
|
@ -163,13 +163,13 @@ static inline u32 acpi_ec_read_status(union acpi_ec *ec)
|
|||
|
||||
static int acpi_ec_wait(union acpi_ec *ec, u8 event)
|
||||
{
|
||||
if (acpi_ec_polling_mode)
|
||||
return acpi_ec_polling_wait(ec, event);
|
||||
if (acpi_ec_poll_mode)
|
||||
return acpi_ec_poll_wait(ec, event);
|
||||
else
|
||||
return acpi_ec_burst_wait(ec, event);
|
||||
return acpi_ec_intr_wait(ec, event);
|
||||
}
|
||||
|
||||
static int acpi_ec_polling_wait(union acpi_ec *ec, u8 event)
|
||||
static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event)
|
||||
{
|
||||
u32 acpi_ec_status = 0;
|
||||
u32 i = ACPI_EC_UDELAY_COUNT;
|
||||
|
|
@ -203,36 +203,31 @@ static int acpi_ec_polling_wait(union acpi_ec *ec, u8 event)
|
|||
|
||||
return -ETIME;
|
||||
}
|
||||
static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event)
|
||||
static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
ACPI_FUNCTION_TRACE("acpi_ec_wait");
|
||||
|
||||
ec->burst.expect_event = event;
|
||||
ec->intr.expect_event = event;
|
||||
smp_mb();
|
||||
|
||||
switch (event) {
|
||||
case ACPI_EC_EVENT_OBF:
|
||||
if (acpi_ec_read_status(ec) & event) {
|
||||
ec->burst.expect_event = 0;
|
||||
case ACPI_EC_EVENT_IBE:
|
||||
if (~acpi_ec_read_status(ec) & event) {
|
||||
ec->intr.expect_event = 0;
|
||||
return_VALUE(0);
|
||||
}
|
||||
break;
|
||||
|
||||
case ACPI_EC_EVENT_IBE:
|
||||
if (~acpi_ec_read_status(ec) & event) {
|
||||
ec->burst.expect_event = 0;
|
||||
return_VALUE(0);
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
result = wait_event_timeout(ec->burst.wait,
|
||||
!ec->burst.expect_event,
|
||||
result = wait_event_timeout(ec->intr.wait,
|
||||
!ec->intr.expect_event,
|
||||
msecs_to_jiffies(ACPI_EC_DELAY));
|
||||
|
||||
ec->burst.expect_event = 0;
|
||||
ec->intr.expect_event = 0;
|
||||
smp_mb();
|
||||
|
||||
/*
|
||||
|
|
@ -255,7 +250,12 @@ static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event)
|
|||
return_VALUE(-ETIME);
|
||||
}
|
||||
|
||||
static int acpi_ec_enter_burst_mode(union acpi_ec *ec)
|
||||
#ifdef ACPI_FUTURE_USAGE
|
||||
/*
|
||||
* Note: samsung nv5000 doesn't work with ec burst mode.
|
||||
* http://bugzilla.kernel.org/show_bug.cgi?id=4980
|
||||
*/
|
||||
int acpi_ec_enter_burst_mode(union acpi_ec *ec)
|
||||
{
|
||||
u32 tmp = 0;
|
||||
int status = 0;
|
||||
|
|
@ -270,45 +270,56 @@ static int acpi_ec_enter_burst_mode(union acpi_ec *ec)
|
|||
acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE,
|
||||
&ec->common.command_addr);
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
|
||||
if (status)
|
||||
return_VALUE(-EINVAL);
|
||||
acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
|
||||
if (tmp != 0x90) { /* Burst ACK byte */
|
||||
return_VALUE(-EINVAL);
|
||||
}
|
||||
}
|
||||
|
||||
atomic_set(&ec->burst.leaving_burst, 0);
|
||||
atomic_set(&ec->intr.leaving_burst, 0);
|
||||
return_VALUE(0);
|
||||
end:
|
||||
printk("Error in acpi_ec_wait\n");
|
||||
printk(KERN_WARNING PREFIX "Error in acpi_ec_wait\n");
|
||||
return_VALUE(-1);
|
||||
}
|
||||
|
||||
static int acpi_ec_leave_burst_mode(union acpi_ec *ec)
|
||||
int acpi_ec_leave_burst_mode(union acpi_ec *ec)
|
||||
{
|
||||
int status = 0;
|
||||
|
||||
ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode");
|
||||
|
||||
atomic_set(&ec->burst.leaving_burst, 1);
|
||||
status = acpi_ec_read_status(ec);
|
||||
if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
|
||||
status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
|
||||
if(status)
|
||||
goto end;
|
||||
acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->common.command_addr);
|
||||
acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
|
||||
}
|
||||
atomic_set(&ec->intr.leaving_burst, 1);
|
||||
return_VALUE(0);
|
||||
end:
|
||||
printk(KERN_WARNING PREFIX "leave burst_mode:error\n");
|
||||
return_VALUE(-1);
|
||||
}
|
||||
#endif /* ACPI_FUTURE_USAGE */
|
||||
|
||||
static int acpi_ec_read(union acpi_ec *ec, u8 address, u32 * data)
|
||||
{
|
||||
if (acpi_ec_polling_mode)
|
||||
return acpi_ec_polling_read(ec, address, data);
|
||||
if (acpi_ec_poll_mode)
|
||||
return acpi_ec_poll_read(ec, address, data);
|
||||
else
|
||||
return acpi_ec_burst_read(ec, address, data);
|
||||
return acpi_ec_intr_read(ec, address, data);
|
||||
}
|
||||
static int acpi_ec_write(union acpi_ec *ec, u8 address, u8 data)
|
||||
{
|
||||
if (acpi_ec_polling_mode)
|
||||
return acpi_ec_polling_write(ec, address, data);
|
||||
if (acpi_ec_poll_mode)
|
||||
return acpi_ec_poll_write(ec, address, data);
|
||||
else
|
||||
return acpi_ec_burst_write(ec, address, data);
|
||||
return acpi_ec_intr_write(ec, address, data);
|
||||
}
|
||||
static int acpi_ec_polling_read(union acpi_ec *ec, u8 address, u32 * data)
|
||||
static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
int result = 0;
|
||||
|
|
@ -328,7 +339,7 @@ static int acpi_ec_polling_read(union acpi_ec *ec, u8 address, u32 * data)
|
|||
return_VALUE(-ENODEV);
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&ec->polling.lock, flags);
|
||||
spin_lock_irqsave(&ec->poll.lock, flags);
|
||||
|
||||
acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
|
||||
&ec->common.command_addr);
|
||||
|
|
@ -347,7 +358,7 @@ static int acpi_ec_polling_read(union acpi_ec *ec, u8 address, u32 * data)
|
|||
*data, address));
|
||||
|
||||
end:
|
||||
spin_unlock_irqrestore(&ec->polling.lock, flags);
|
||||
spin_unlock_irqrestore(&ec->poll.lock, flags);
|
||||
|
||||
if (ec->common.global_lock)
|
||||
acpi_release_global_lock(glk);
|
||||
|
|
@ -355,7 +366,7 @@ static int acpi_ec_polling_read(union acpi_ec *ec, u8 address, u32 * data)
|
|||
return_VALUE(result);
|
||||
}
|
||||
|
||||
static int acpi_ec_polling_write(union acpi_ec *ec, u8 address, u8 data)
|
||||
static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data)
|
||||
{
|
||||
int result = 0;
|
||||
acpi_status status = AE_OK;
|
||||
|
|
@ -373,7 +384,7 @@ static int acpi_ec_polling_write(union acpi_ec *ec, u8 address, u8 data)
|
|||
return_VALUE(-ENODEV);
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&ec->polling.lock, flags);
|
||||
spin_lock_irqsave(&ec->poll.lock, flags);
|
||||
|
||||
acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
|
||||
&ec->common.command_addr);
|
||||
|
|
@ -395,7 +406,7 @@ static int acpi_ec_polling_write(union acpi_ec *ec, u8 address, u8 data)
|
|||
data, address));
|
||||
|
||||
end:
|
||||
spin_unlock_irqrestore(&ec->polling.lock, flags);
|
||||
spin_unlock_irqrestore(&ec->poll.lock, flags);
|
||||
|
||||
if (ec->common.global_lock)
|
||||
acpi_release_global_lock(glk);
|
||||
|
|
@ -403,7 +414,7 @@ static int acpi_ec_polling_write(union acpi_ec *ec, u8 address, u8 data)
|
|||
return_VALUE(result);
|
||||
}
|
||||
|
||||
static int acpi_ec_burst_read(union acpi_ec *ec, u8 address, u32 * data)
|
||||
static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data)
|
||||
{
|
||||
int status = 0;
|
||||
u32 glk;
|
||||
|
|
@ -422,25 +433,24 @@ static int acpi_ec_burst_read(union acpi_ec *ec, u8 address, u32 * data)
|
|||
}
|
||||
|
||||
WARN_ON(in_interrupt());
|
||||
down(&ec->burst.sem);
|
||||
down(&ec->intr.sem);
|
||||
|
||||
acpi_ec_enter_burst_mode(ec);
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
|
||||
if (status) {
|
||||
printk("read EC, IB not empty\n");
|
||||
printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
|
||||
goto end;
|
||||
}
|
||||
acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
|
||||
&ec->common.command_addr);
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
|
||||
if (status) {
|
||||
printk("read EC, IB not empty\n");
|
||||
printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
|
||||
}
|
||||
|
||||
acpi_hw_low_level_write(8, address, &ec->common.data_addr);
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
|
||||
if (status) {
|
||||
printk("read EC, OB not full\n");
|
||||
printk(KERN_DEBUG PREFIX "read EC, OB not full\n");
|
||||
goto end;
|
||||
}
|
||||
acpi_hw_low_level_read(8, data, &ec->common.data_addr);
|
||||
|
|
@ -448,8 +458,7 @@ static int acpi_ec_burst_read(union acpi_ec *ec, u8 address, u32 * data)
|
|||
*data, address));
|
||||
|
||||
end:
|
||||
acpi_ec_leave_burst_mode(ec);
|
||||
up(&ec->burst.sem);
|
||||
up(&ec->intr.sem);
|
||||
|
||||
if (ec->common.global_lock)
|
||||
acpi_release_global_lock(glk);
|
||||
|
|
@ -457,7 +466,7 @@ static int acpi_ec_burst_read(union acpi_ec *ec, u8 address, u32 * data)
|
|||
return_VALUE(status);
|
||||
}
|
||||
|
||||
static int acpi_ec_burst_write(union acpi_ec *ec, u8 address, u8 data)
|
||||
static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data)
|
||||
{
|
||||
int status = 0;
|
||||
u32 glk;
|
||||
|
|
@ -474,25 +483,23 @@ static int acpi_ec_burst_write(union acpi_ec *ec, u8 address, u8 data)
|
|||
}
|
||||
|
||||
WARN_ON(in_interrupt());
|
||||
down(&ec->burst.sem);
|
||||
|
||||
acpi_ec_enter_burst_mode(ec);
|
||||
down(&ec->intr.sem);
|
||||
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
|
||||
if (status) {
|
||||
printk("write EC, IB not empty\n");
|
||||
printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
|
||||
}
|
||||
acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
|
||||
&ec->common.command_addr);
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
|
||||
if (status) {
|
||||
printk("write EC, IB not empty\n");
|
||||
printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
|
||||
}
|
||||
|
||||
acpi_hw_low_level_write(8, address, &ec->common.data_addr);
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
|
||||
if (status) {
|
||||
printk("write EC, IB not empty\n");
|
||||
printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
|
||||
}
|
||||
|
||||
acpi_hw_low_level_write(8, data, &ec->common.data_addr);
|
||||
|
|
@ -500,8 +507,7 @@ static int acpi_ec_burst_write(union acpi_ec *ec, u8 address, u8 data)
|
|||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
|
||||
data, address));
|
||||
|
||||
acpi_ec_leave_burst_mode(ec);
|
||||
up(&ec->burst.sem);
|
||||
up(&ec->intr.sem);
|
||||
|
||||
if (ec->common.global_lock)
|
||||
acpi_release_global_lock(glk);
|
||||
|
|
@ -553,12 +559,12 @@ EXPORT_SYMBOL(ec_write);
|
|||
|
||||
static int acpi_ec_query(union acpi_ec *ec, u32 * data)
|
||||
{
|
||||
if (acpi_ec_polling_mode)
|
||||
return acpi_ec_polling_query(ec, data);
|
||||
if (acpi_ec_poll_mode)
|
||||
return acpi_ec_poll_query(ec, data);
|
||||
else
|
||||
return acpi_ec_burst_query(ec, data);
|
||||
return acpi_ec_intr_query(ec, data);
|
||||
}
|
||||
static int acpi_ec_polling_query(union acpi_ec *ec, u32 * data)
|
||||
static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data)
|
||||
{
|
||||
int result = 0;
|
||||
acpi_status status = AE_OK;
|
||||
|
|
@ -583,7 +589,7 @@ static int acpi_ec_polling_query(union acpi_ec *ec, u32 * data)
|
|||
* Note that successful completion of the query causes the ACPI_EC_SCI
|
||||
* bit to be cleared (and thus clearing the interrupt source).
|
||||
*/
|
||||
spin_lock_irqsave(&ec->polling.lock, flags);
|
||||
spin_lock_irqsave(&ec->poll.lock, flags);
|
||||
|
||||
acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
|
||||
&ec->common.command_addr);
|
||||
|
|
@ -596,14 +602,14 @@ static int acpi_ec_polling_query(union acpi_ec *ec, u32 * data)
|
|||
result = -ENODATA;
|
||||
|
||||
end:
|
||||
spin_unlock_irqrestore(&ec->polling.lock, flags);
|
||||
spin_unlock_irqrestore(&ec->poll.lock, flags);
|
||||
|
||||
if (ec->common.global_lock)
|
||||
acpi_release_global_lock(glk);
|
||||
|
||||
return_VALUE(result);
|
||||
}
|
||||
static int acpi_ec_burst_query(union acpi_ec *ec, u32 * data)
|
||||
static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data)
|
||||
{
|
||||
int status = 0;
|
||||
u32 glk;
|
||||
|
|
@ -620,11 +626,11 @@ static int acpi_ec_burst_query(union acpi_ec *ec, u32 * data)
|
|||
return_VALUE(-ENODEV);
|
||||
}
|
||||
|
||||
down(&ec->burst.sem);
|
||||
down(&ec->intr.sem);
|
||||
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
|
||||
if (status) {
|
||||
printk("query EC, IB not empty\n");
|
||||
printk(KERN_DEBUG PREFIX "query EC, IB not empty\n");
|
||||
goto end;
|
||||
}
|
||||
/*
|
||||
|
|
@ -636,7 +642,7 @@ static int acpi_ec_burst_query(union acpi_ec *ec, u32 * data)
|
|||
&ec->common.command_addr);
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
|
||||
if (status) {
|
||||
printk("query EC, OB not full\n");
|
||||
printk(KERN_DEBUG PREFIX "query EC, OB not full\n");
|
||||
goto end;
|
||||
}
|
||||
|
||||
|
|
@ -645,7 +651,7 @@ static int acpi_ec_burst_query(union acpi_ec *ec, u32 * data)
|
|||
status = -ENODATA;
|
||||
|
||||
end:
|
||||
up(&ec->burst.sem);
|
||||
up(&ec->intr.sem);
|
||||
|
||||
if (ec->common.global_lock)
|
||||
acpi_release_global_lock(glk);
|
||||
|
|
@ -664,13 +670,13 @@ union acpi_ec_query_data {
|
|||
|
||||
static void acpi_ec_gpe_query(void *ec_cxt)
|
||||
{
|
||||
if (acpi_ec_polling_mode)
|
||||
acpi_ec_gpe_polling_query(ec_cxt);
|
||||
if (acpi_ec_poll_mode)
|
||||
acpi_ec_gpe_poll_query(ec_cxt);
|
||||
else
|
||||
acpi_ec_gpe_burst_query(ec_cxt);
|
||||
acpi_ec_gpe_intr_query(ec_cxt);
|
||||
}
|
||||
|
||||
static void acpi_ec_gpe_polling_query(void *ec_cxt)
|
||||
static void acpi_ec_gpe_poll_query(void *ec_cxt)
|
||||
{
|
||||
union acpi_ec *ec = (union acpi_ec *)ec_cxt;
|
||||
u32 value = 0;
|
||||
|
|
@ -685,9 +691,9 @@ static void acpi_ec_gpe_polling_query(void *ec_cxt)
|
|||
if (!ec_cxt)
|
||||
goto end;
|
||||
|
||||
spin_lock_irqsave(&ec->polling.lock, flags);
|
||||
spin_lock_irqsave(&ec->poll.lock, flags);
|
||||
acpi_hw_low_level_read(8, &value, &ec->common.command_addr);
|
||||
spin_unlock_irqrestore(&ec->polling.lock, flags);
|
||||
spin_unlock_irqrestore(&ec->poll.lock, flags);
|
||||
|
||||
/* TBD: Implement asynch events!
|
||||
* NOTE: All we care about are EC-SCI's. Other EC events are
|
||||
|
|
@ -711,7 +717,7 @@ static void acpi_ec_gpe_polling_query(void *ec_cxt)
|
|||
end:
|
||||
acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
|
||||
}
|
||||
static void acpi_ec_gpe_burst_query(void *ec_cxt)
|
||||
static void acpi_ec_gpe_intr_query(void *ec_cxt)
|
||||
{
|
||||
union acpi_ec *ec = (union acpi_ec *)ec_cxt;
|
||||
u32 value;
|
||||
|
|
@ -736,18 +742,18 @@ static void acpi_ec_gpe_burst_query(void *ec_cxt)
|
|||
|
||||
acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
|
||||
end:
|
||||
atomic_dec(&ec->burst.pending_gpe);
|
||||
atomic_dec(&ec->intr.pending_gpe);
|
||||
return;
|
||||
}
|
||||
|
||||
static u32 acpi_ec_gpe_handler(void *data)
|
||||
{
|
||||
if (acpi_ec_polling_mode)
|
||||
return acpi_ec_gpe_polling_handler(data);
|
||||
if (acpi_ec_poll_mode)
|
||||
return acpi_ec_gpe_poll_handler(data);
|
||||
else
|
||||
return acpi_ec_gpe_burst_handler(data);
|
||||
return acpi_ec_gpe_intr_handler(data);
|
||||
}
|
||||
static u32 acpi_ec_gpe_polling_handler(void *data)
|
||||
static u32 acpi_ec_gpe_poll_handler(void *data)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
union acpi_ec *ec = (union acpi_ec *)data;
|
||||
|
|
@ -765,7 +771,7 @@ static u32 acpi_ec_gpe_polling_handler(void *data)
|
|||
else
|
||||
return ACPI_INTERRUPT_NOT_HANDLED;
|
||||
}
|
||||
static u32 acpi_ec_gpe_burst_handler(void *data)
|
||||
static u32 acpi_ec_gpe_intr_handler(void *data)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
u32 value;
|
||||
|
|
@ -777,22 +783,22 @@ static u32 acpi_ec_gpe_burst_handler(void *data)
|
|||
acpi_clear_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
|
||||
value = acpi_ec_read_status(ec);
|
||||
|
||||
switch (ec->burst.expect_event) {
|
||||
switch (ec->intr.expect_event) {
|
||||
case ACPI_EC_EVENT_OBF:
|
||||
if (!(value & ACPI_EC_FLAG_OBF))
|
||||
break;
|
||||
case ACPI_EC_EVENT_IBE:
|
||||
if ((value & ACPI_EC_FLAG_IBF))
|
||||
break;
|
||||
ec->burst.expect_event = 0;
|
||||
wake_up(&ec->burst.wait);
|
||||
ec->intr.expect_event = 0;
|
||||
wake_up(&ec->intr.wait);
|
||||
return ACPI_INTERRUPT_HANDLED;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (value & ACPI_EC_FLAG_SCI) {
|
||||
atomic_add(1, &ec->burst.pending_gpe);
|
||||
atomic_add(1, &ec->intr.pending_gpe);
|
||||
status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
|
||||
acpi_ec_gpe_query, ec);
|
||||
return status == AE_OK ?
|
||||
|
|
@ -980,7 +986,7 @@ static int acpi_ec_remove_fs(struct acpi_device *device)
|
|||
Driver Interface
|
||||
-------------------------------------------------------------------------- */
|
||||
|
||||
static int acpi_ec_polling_add(struct acpi_device *device)
|
||||
static int acpi_ec_poll_add(struct acpi_device *device)
|
||||
{
|
||||
int result = 0;
|
||||
acpi_status status = AE_OK;
|
||||
|
|
@ -999,7 +1005,7 @@ static int acpi_ec_polling_add(struct acpi_device *device)
|
|||
|
||||
ec->common.handle = device->handle;
|
||||
ec->common.uid = -1;
|
||||
spin_lock_init(&ec->polling.lock);
|
||||
spin_lock_init(&ec->poll.lock);
|
||||
strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
|
||||
strcpy(acpi_device_class(device), ACPI_EC_CLASS);
|
||||
acpi_driver_data(device) = ec;
|
||||
|
|
@ -1038,7 +1044,7 @@ static int acpi_ec_polling_add(struct acpi_device *device)
|
|||
if (result)
|
||||
goto end;
|
||||
|
||||
printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
|
||||
printk(KERN_INFO PREFIX "%s [%s] (gpe %d) polling mode.\n",
|
||||
acpi_device_name(device), acpi_device_bid(device),
|
||||
(u32) ec->common.gpe_bit);
|
||||
|
||||
|
|
@ -1051,7 +1057,7 @@ static int acpi_ec_polling_add(struct acpi_device *device)
|
|||
|
||||
return_VALUE(result);
|
||||
}
|
||||
static int acpi_ec_burst_add(struct acpi_device *device)
|
||||
static int acpi_ec_intr_add(struct acpi_device *device)
|
||||
{
|
||||
int result = 0;
|
||||
acpi_status status = AE_OK;
|
||||
|
|
@ -1070,10 +1076,10 @@ static int acpi_ec_burst_add(struct acpi_device *device)
|
|||
|
||||
ec->common.handle = device->handle;
|
||||
ec->common.uid = -1;
|
||||
atomic_set(&ec->burst.pending_gpe, 0);
|
||||
atomic_set(&ec->burst.leaving_burst, 1);
|
||||
init_MUTEX(&ec->burst.sem);
|
||||
init_waitqueue_head(&ec->burst.wait);
|
||||
atomic_set(&ec->intr.pending_gpe, 0);
|
||||
atomic_set(&ec->intr.leaving_burst, 1);
|
||||
init_MUTEX(&ec->intr.sem);
|
||||
init_waitqueue_head(&ec->intr.wait);
|
||||
strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
|
||||
strcpy(acpi_device_class(device), ACPI_EC_CLASS);
|
||||
acpi_driver_data(device) = ec;
|
||||
|
|
@ -1112,8 +1118,7 @@ static int acpi_ec_burst_add(struct acpi_device *device)
|
|||
if (result)
|
||||
goto end;
|
||||
|
||||
printk("burst-mode-ec-10-Aug\n");
|
||||
printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
|
||||
printk(KERN_INFO PREFIX "%s [%s] (gpe %d) interrupt mode.\n",
|
||||
acpi_device_name(device), acpi_device_bid(device),
|
||||
(u32) ec->common.gpe_bit);
|
||||
|
||||
|
|
@ -1267,16 +1272,16 @@ acpi_fake_ecdt_callback(acpi_handle handle,
|
|||
u32 Level, void *context, void **retval)
|
||||
{
|
||||
|
||||
if (acpi_ec_polling_mode)
|
||||
return acpi_fake_ecdt_polling_callback(handle,
|
||||
if (acpi_ec_poll_mode)
|
||||
return acpi_fake_ecdt_poll_callback(handle,
|
||||
Level, context, retval);
|
||||
else
|
||||
return acpi_fake_ecdt_burst_callback(handle,
|
||||
return acpi_fake_ecdt_intr_callback(handle,
|
||||
Level, context, retval);
|
||||
}
|
||||
|
||||
static acpi_status __init
|
||||
acpi_fake_ecdt_polling_callback(acpi_handle handle,
|
||||
acpi_fake_ecdt_poll_callback(acpi_handle handle,
|
||||
u32 Level, void *context, void **retval)
|
||||
{
|
||||
acpi_status status;
|
||||
|
|
@ -1295,7 +1300,7 @@ acpi_fake_ecdt_polling_callback(acpi_handle handle,
|
|||
&ec_ecdt->common.gpe_bit);
|
||||
if (ACPI_FAILURE(status))
|
||||
return status;
|
||||
spin_lock_init(&ec_ecdt->polling.lock);
|
||||
spin_lock_init(&ec_ecdt->poll.lock);
|
||||
ec_ecdt->common.global_lock = TRUE;
|
||||
ec_ecdt->common.handle = handle;
|
||||
|
||||
|
|
@ -1308,13 +1313,13 @@ acpi_fake_ecdt_polling_callback(acpi_handle handle,
|
|||
}
|
||||
|
||||
static acpi_status __init
|
||||
acpi_fake_ecdt_burst_callback(acpi_handle handle,
|
||||
acpi_fake_ecdt_intr_callback(acpi_handle handle,
|
||||
u32 Level, void *context, void **retval)
|
||||
{
|
||||
acpi_status status;
|
||||
|
||||
init_MUTEX(&ec_ecdt->burst.sem);
|
||||
init_waitqueue_head(&ec_ecdt->burst.wait);
|
||||
init_MUTEX(&ec_ecdt->intr.sem);
|
||||
init_waitqueue_head(&ec_ecdt->intr.wait);
|
||||
status = acpi_walk_resources(handle, METHOD_NAME__CRS,
|
||||
acpi_ec_io_ports, ec_ecdt);
|
||||
if (ACPI_FAILURE(status))
|
||||
|
|
@ -1380,13 +1385,13 @@ static int __init acpi_ec_fake_ecdt(void)
|
|||
|
||||
static int __init acpi_ec_get_real_ecdt(void)
|
||||
{
|
||||
if (acpi_ec_polling_mode)
|
||||
return acpi_ec_polling_get_real_ecdt();
|
||||
if (acpi_ec_poll_mode)
|
||||
return acpi_ec_poll_get_real_ecdt();
|
||||
else
|
||||
return acpi_ec_burst_get_real_ecdt();
|
||||
return acpi_ec_intr_get_real_ecdt();
|
||||
}
|
||||
|
||||
static int __init acpi_ec_polling_get_real_ecdt(void)
|
||||
static int __init acpi_ec_poll_get_real_ecdt(void)
|
||||
{
|
||||
acpi_status status;
|
||||
struct acpi_table_ecdt *ecdt_ptr;
|
||||
|
|
@ -1411,7 +1416,7 @@ static int __init acpi_ec_polling_get_real_ecdt(void)
|
|||
ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
|
||||
ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
|
||||
ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
|
||||
spin_lock_init(&ec_ecdt->polling.lock);
|
||||
spin_lock_init(&ec_ecdt->poll.lock);
|
||||
/* use the GL just to be safe */
|
||||
ec_ecdt->common.global_lock = TRUE;
|
||||
ec_ecdt->common.uid = ecdt_ptr->uid;
|
||||
|
|
@ -1431,7 +1436,7 @@ static int __init acpi_ec_polling_get_real_ecdt(void)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
static int __init acpi_ec_burst_get_real_ecdt(void)
|
||||
static int __init acpi_ec_intr_get_real_ecdt(void)
|
||||
{
|
||||
acpi_status status;
|
||||
struct acpi_table_ecdt *ecdt_ptr;
|
||||
|
|
@ -1452,8 +1457,8 @@ static int __init acpi_ec_burst_get_real_ecdt(void)
|
|||
return -ENOMEM;
|
||||
memset(ec_ecdt, 0, sizeof(union acpi_ec));
|
||||
|
||||
init_MUTEX(&ec_ecdt->burst.sem);
|
||||
init_waitqueue_head(&ec_ecdt->burst.wait);
|
||||
init_MUTEX(&ec_ecdt->intr.sem);
|
||||
init_waitqueue_head(&ec_ecdt->intr.wait);
|
||||
ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
|
||||
ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
|
||||
ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
|
||||
|
|
@ -1571,22 +1576,22 @@ static int __init acpi_fake_ecdt_setup(char *str)
|
|||
}
|
||||
|
||||
__setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
|
||||
static int __init acpi_ec_set_polling_mode(char *str)
|
||||
static int __init acpi_ec_set_intr_mode(char *str)
|
||||
{
|
||||
int burst;
|
||||
int intr;
|
||||
|
||||
if (!get_option(&str, &burst))
|
||||
if (!get_option(&str, &intr))
|
||||
return 0;
|
||||
|
||||
if (burst) {
|
||||
acpi_ec_polling_mode = EC_BURST;
|
||||
acpi_ec_driver.ops.add = acpi_ec_burst_add;
|
||||
if (intr) {
|
||||
acpi_ec_poll_mode = EC_INTR;
|
||||
acpi_ec_driver.ops.add = acpi_ec_intr_add;
|
||||
} else {
|
||||
acpi_ec_polling_mode = EC_POLLING;
|
||||
acpi_ec_driver.ops.add = acpi_ec_polling_add;
|
||||
acpi_ec_poll_mode = EC_POLL;
|
||||
acpi_ec_driver.ops.add = acpi_ec_poll_add;
|
||||
}
|
||||
printk(KERN_INFO PREFIX "EC %s mode.\n", burst ? "burst" : "polling");
|
||||
printk(KERN_INFO PREFIX "EC %s mode.\n", intr ? "interrupt" : "polling");
|
||||
return 0;
|
||||
}
|
||||
|
||||
__setup("ec_burst=", acpi_ec_set_polling_mode);
|
||||
__setup("ec_intr=", acpi_ec_set_intr_mode);
|
||||
|
|
|
|||
|
|
@ -204,11 +204,13 @@ acpi_os_map_memory(acpi_physical_address phys, acpi_size size,
|
|||
|
||||
return AE_OK;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_os_map_memory);
|
||||
|
||||
void acpi_os_unmap_memory(void __iomem * virt, acpi_size size)
|
||||
{
|
||||
iounmap(virt);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
|
||||
|
||||
#ifdef ACPI_FUTURE_USAGE
|
||||
acpi_status
|
||||
|
|
@ -836,7 +838,7 @@ acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
|
|||
static const int quantum_ms = 1000 / HZ;
|
||||
|
||||
ret = down_trylock(sem);
|
||||
for (i = timeout; (i > 0 && ret < 0); i -= quantum_ms) {
|
||||
for (i = timeout; (i > 0 && ret != 0); i -= quantum_ms) {
|
||||
schedule_timeout_interruptible(1);
|
||||
ret = down_trylock(sem);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -361,8 +361,7 @@ acpi_pci_irq_derive(struct pci_dev *dev,
|
|||
|
||||
if ((bridge->class >> 8) == PCI_CLASS_BRIDGE_CARDBUS) {
|
||||
/* PC card has the same IRQ as its cardbridge */
|
||||
pci_read_config_byte(bridge, PCI_INTERRUPT_PIN,
|
||||
&bridge_pin);
|
||||
bridge_pin = bridge->pin;
|
||||
if (!bridge_pin) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
||||
"No interrupt pin configured for device %s\n",
|
||||
|
|
@ -412,7 +411,7 @@ int acpi_pci_irq_enable(struct pci_dev *dev)
|
|||
if (!dev)
|
||||
return_VALUE(-EINVAL);
|
||||
|
||||
pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
|
||||
pin = dev->pin;
|
||||
if (!pin) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
||||
"No interrupt pin configured for device %s\n",
|
||||
|
|
@ -503,7 +502,7 @@ void acpi_pci_irq_disable(struct pci_dev *dev)
|
|||
if (!dev || !dev->bus)
|
||||
return_VOID;
|
||||
|
||||
pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
|
||||
pin = dev->pin;
|
||||
if (!pin)
|
||||
return_VOID;
|
||||
pin--;
|
||||
|
|
|
|||
|
|
@ -253,31 +253,21 @@ static int acpi_processor_errata(struct acpi_processor *pr)
|
|||
* _PDC is required for a BIOS-OS handshake for most of the newer
|
||||
* ACPI processor features.
|
||||
*/
|
||||
|
||||
int acpi_processor_set_pdc(struct acpi_processor *pr,
|
||||
struct acpi_object_list *pdc_in)
|
||||
static int acpi_processor_set_pdc(struct acpi_processor *pr)
|
||||
{
|
||||
struct acpi_object_list *pdc_in = pr->pdc;
|
||||
acpi_status status = AE_OK;
|
||||
u32 arg0_buf[3];
|
||||
union acpi_object arg0 = { ACPI_TYPE_BUFFER };
|
||||
struct acpi_object_list no_object = { 1, &arg0 };
|
||||
struct acpi_object_list *pdc;
|
||||
|
||||
ACPI_FUNCTION_TRACE("acpi_processor_set_pdc");
|
||||
|
||||
arg0.buffer.length = 12;
|
||||
arg0.buffer.pointer = (u8 *) arg0_buf;
|
||||
arg0_buf[0] = ACPI_PDC_REVISION_ID;
|
||||
arg0_buf[1] = 0;
|
||||
arg0_buf[2] = 0;
|
||||
if (!pdc_in)
|
||||
return_VALUE(status);
|
||||
|
||||
pdc = (pdc_in) ? pdc_in : &no_object;
|
||||
status = acpi_evaluate_object(pr->handle, "_PDC", pdc_in, NULL);
|
||||
|
||||
status = acpi_evaluate_object(pr->handle, "_PDC", pdc, NULL);
|
||||
|
||||
if ((ACPI_FAILURE(status)) && (pdc_in))
|
||||
if (ACPI_FAILURE(status))
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
||||
"Error evaluating _PDC, using legacy perf. control...\n"));
|
||||
"Could not evaluate _PDC, using legacy perf. control...\n"));
|
||||
|
||||
return_VALUE(status);
|
||||
}
|
||||
|
|
@ -357,7 +347,6 @@ static int acpi_processor_add_fs(struct acpi_device *device)
|
|||
ACPI_PROCESSOR_FILE_THROTTLING));
|
||||
else {
|
||||
entry->proc_fops = &acpi_processor_throttling_fops;
|
||||
entry->proc_fops->write = acpi_processor_write_throttling;
|
||||
entry->data = acpi_driver_data(device);
|
||||
entry->owner = THIS_MODULE;
|
||||
}
|
||||
|
|
@ -372,7 +361,6 @@ static int acpi_processor_add_fs(struct acpi_device *device)
|
|||
ACPI_PROCESSOR_FILE_LIMIT));
|
||||
else {
|
||||
entry->proc_fops = &acpi_processor_limit_fops;
|
||||
entry->proc_fops->write = acpi_processor_write_limit;
|
||||
entry->data = acpi_driver_data(device);
|
||||
entry->owner = THIS_MODULE;
|
||||
}
|
||||
|
|
@ -589,6 +577,10 @@ static int acpi_processor_start(struct acpi_device *device)
|
|||
"Error installing device notify handler\n"));
|
||||
}
|
||||
|
||||
/* _PDC call should be done before doing anything else (if reqd.). */
|
||||
arch_acpi_processor_init_pdc(pr);
|
||||
acpi_processor_set_pdc(pr);
|
||||
|
||||
acpi_processor_power_init(pr, device);
|
||||
|
||||
if (pr->flags.throttling) {
|
||||
|
|
|
|||
|
|
@ -95,22 +95,57 @@ static int set_max_cstate(struct dmi_system_id *id)
|
|||
}
|
||||
|
||||
static struct dmi_system_id __initdata processor_power_dmi_table[] = {
|
||||
{set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,
|
||||
"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,
|
||||
"1SET60WW")},
|
||||
(void *)1},
|
||||
{set_max_cstate, "Medion 41700", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,
|
||||
"Phoenix Technologies LTD"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,
|
||||
"R01-A1J")}, (void *)1},
|
||||
{set_max_cstate, "Clevo 5600D", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,
|
||||
"Phoenix Technologies LTD"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,
|
||||
"SHE845M0.86C.0013.D.0302131307")},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET43WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET45WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET47WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET50WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET52WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET55WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET56WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET59WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET61WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET62WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET64WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET65WW") }, (void*)1},
|
||||
{ set_max_cstate, "IBM ThinkPad R40e", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"1SET68WW") }, (void*)1},
|
||||
{ set_max_cstate, "Medion 41700", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J")}, (void *)1},
|
||||
{ set_max_cstate, "Clevo 5600D", {
|
||||
DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
|
||||
DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
|
||||
(void *)2},
|
||||
{},
|
||||
};
|
||||
|
|
@ -550,18 +585,10 @@ static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
|
|||
if (!pr->pblk)
|
||||
return_VALUE(-ENODEV);
|
||||
|
||||
memset(pr->power.states, 0, sizeof(pr->power.states));
|
||||
|
||||
/* if info is obtained from pblk/fadt, type equals state */
|
||||
pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
|
||||
pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
|
||||
pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
|
||||
|
||||
/* the C0 state only exists as a filler in our array,
|
||||
* and all processors need to support C1 */
|
||||
pr->power.states[ACPI_STATE_C0].valid = 1;
|
||||
pr->power.states[ACPI_STATE_C1].valid = 1;
|
||||
|
||||
#ifndef CONFIG_HOTPLUG_CPU
|
||||
/*
|
||||
* Check for P_LVL2_UP flag before entering C2 and above on
|
||||
|
|
@ -591,12 +618,11 @@ static int acpi_processor_get_power_info_default_c1(struct acpi_processor *pr)
|
|||
{
|
||||
ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1");
|
||||
|
||||
/* Zero initialize all the C-states info. */
|
||||
memset(pr->power.states, 0, sizeof(pr->power.states));
|
||||
|
||||
/* if info is obtained from pblk/fadt, type equals state */
|
||||
/* set the first C-State to C1 */
|
||||
pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
|
||||
pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
|
||||
pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
|
||||
|
||||
/* the C0 state only exists as a filler in our array,
|
||||
* and all processors need to support C1 */
|
||||
|
|
@ -610,6 +636,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
{
|
||||
acpi_status status = 0;
|
||||
acpi_integer count;
|
||||
int current_count;
|
||||
int i;
|
||||
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
||||
union acpi_object *cst;
|
||||
|
|
@ -619,10 +646,12 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
if (nocst)
|
||||
return_VALUE(-ENODEV);
|
||||
|
||||
pr->power.count = 0;
|
||||
for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++)
|
||||
memset(&(pr->power.states[i]), 0,
|
||||
sizeof(struct acpi_processor_cx));
|
||||
current_count = 1;
|
||||
|
||||
/* Zero initialize C2 onwards and prepare for fresh CST lookup */
|
||||
for (i = 2; i < ACPI_PROCESSOR_MAX_POWER; i++)
|
||||
memset(&(pr->power.states[i]), 0,
|
||||
sizeof(struct acpi_processor_cx));
|
||||
|
||||
status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
|
|
@ -650,16 +679,6 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
goto end;
|
||||
}
|
||||
|
||||
/* We support up to ACPI_PROCESSOR_MAX_POWER. */
|
||||
if (count > ACPI_PROCESSOR_MAX_POWER) {
|
||||
printk(KERN_WARNING
|
||||
"Limiting number of power states to max (%d)\n",
|
||||
ACPI_PROCESSOR_MAX_POWER);
|
||||
printk(KERN_WARNING
|
||||
"Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
|
||||
count = ACPI_PROCESSOR_MAX_POWER;
|
||||
}
|
||||
|
||||
/* Tell driver that at least _CST is supported. */
|
||||
pr->flags.has_cst = 1;
|
||||
|
||||
|
|
@ -703,7 +722,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
(reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO))
|
||||
continue;
|
||||
|
||||
if ((cx.type < ACPI_STATE_C1) || (cx.type > ACPI_STATE_C3))
|
||||
if ((cx.type < ACPI_STATE_C2) || (cx.type > ACPI_STATE_C3))
|
||||
continue;
|
||||
|
||||
obj = (union acpi_object *)&(element->package.elements[2]);
|
||||
|
|
@ -718,15 +737,28 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
|
||||
cx.power = obj->integer.value;
|
||||
|
||||
(pr->power.count)++;
|
||||
memcpy(&(pr->power.states[pr->power.count]), &cx, sizeof(cx));
|
||||
current_count++;
|
||||
memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
|
||||
|
||||
/*
|
||||
* We support total ACPI_PROCESSOR_MAX_POWER - 1
|
||||
* (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
|
||||
*/
|
||||
if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
|
||||
printk(KERN_WARNING
|
||||
"Limiting number of power states to max (%d)\n",
|
||||
ACPI_PROCESSOR_MAX_POWER);
|
||||
printk(KERN_WARNING
|
||||
"Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
|
||||
pr->power.count));
|
||||
current_count));
|
||||
|
||||
/* Validate number of power states discovered */
|
||||
if (pr->power.count < 2)
|
||||
if (current_count < 2)
|
||||
status = -EFAULT;
|
||||
|
||||
end:
|
||||
|
|
@ -843,6 +875,15 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
|
|||
unsigned int i;
|
||||
unsigned int working = 0;
|
||||
|
||||
#ifdef ARCH_APICTIMER_STOPS_ON_C3
|
||||
struct cpuinfo_x86 *c = cpu_data + pr->id;
|
||||
cpumask_t mask = cpumask_of_cpu(pr->id);
|
||||
|
||||
if (c->x86_vendor == X86_VENDOR_INTEL) {
|
||||
on_each_cpu(switch_ipi_to_APIC_timer, &mask, 1, 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
|
||||
struct acpi_processor_cx *cx = &pr->power.states[i];
|
||||
|
||||
|
|
@ -857,6 +898,12 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
|
|||
|
||||
case ACPI_STATE_C3:
|
||||
acpi_processor_power_verify_c3(pr, cx);
|
||||
#ifdef ARCH_APICTIMER_STOPS_ON_C3
|
||||
if (c->x86_vendor == X86_VENDOR_INTEL) {
|
||||
on_each_cpu(switch_APIC_timer_to_ipi,
|
||||
&mask, 1, 1);
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -877,12 +924,13 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
|
|||
/* NOTE: the idle thread may not be running while calling
|
||||
* this function */
|
||||
|
||||
/* Adding C1 state */
|
||||
acpi_processor_get_power_info_default_c1(pr);
|
||||
result = acpi_processor_get_power_info_cst(pr);
|
||||
if (result == -ENODEV)
|
||||
result = acpi_processor_get_power_info_fadt(pr);
|
||||
acpi_processor_get_power_info_fadt(pr);
|
||||
|
||||
if ((result) || (acpi_processor_power_verify(pr) < 2))
|
||||
result = acpi_processor_get_power_info_default_c1(pr);
|
||||
pr->power.count = acpi_processor_power_verify(pr);
|
||||
|
||||
/*
|
||||
* Set Default Policy
|
||||
|
|
@ -1051,8 +1099,6 @@ int acpi_processor_power_init(struct acpi_processor *pr,
|
|||
}
|
||||
}
|
||||
|
||||
acpi_processor_power_init_pdc(&(pr->power), pr->id);
|
||||
acpi_processor_set_pdc(pr, pr->power.pdc);
|
||||
acpi_processor_get_power_info(pr);
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -315,8 +315,6 @@ static int acpi_processor_get_performance_info(struct acpi_processor *pr)
|
|||
if (!pr || !pr->performance || !pr->handle)
|
||||
return_VALUE(-EINVAL);
|
||||
|
||||
acpi_processor_set_pdc(pr, pr->performance->pdc);
|
||||
|
||||
status = acpi_get_handle(pr->handle, "_PCT", &handle);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
||||
|
|
@ -520,8 +518,8 @@ static void acpi_cpufreq_add_file(struct acpi_processor *pr)
|
|||
"Unable to create '%s' fs entry\n",
|
||||
ACPI_PROCESSOR_FILE_PERFORMANCE));
|
||||
else {
|
||||
acpi_processor_perf_fops.write = acpi_processor_write_performance;
|
||||
entry->proc_fops = &acpi_processor_perf_fops;
|
||||
entry->proc_fops->write = acpi_processor_write_performance;
|
||||
entry->data = acpi_driver_data(device);
|
||||
entry->owner = THIS_MODULE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -348,9 +348,9 @@ static int acpi_processor_limit_open_fs(struct inode *inode, struct file *file)
|
|||
PDE(inode)->data);
|
||||
}
|
||||
|
||||
ssize_t acpi_processor_write_limit(struct file * file,
|
||||
const char __user * buffer,
|
||||
size_t count, loff_t * data)
|
||||
static ssize_t acpi_processor_write_limit(struct file * file,
|
||||
const char __user * buffer,
|
||||
size_t count, loff_t * data)
|
||||
{
|
||||
int result = 0;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
|
|
@ -394,6 +394,7 @@ ssize_t acpi_processor_write_limit(struct file * file,
|
|||
struct file_operations acpi_processor_limit_fops = {
|
||||
.open = acpi_processor_limit_open_fs,
|
||||
.read = seq_read,
|
||||
.write = acpi_processor_write_limit,
|
||||
.llseek = seq_lseek,
|
||||
.release = single_release,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -306,9 +306,9 @@ static int acpi_processor_throttling_open_fs(struct inode *inode,
|
|||
PDE(inode)->data);
|
||||
}
|
||||
|
||||
ssize_t acpi_processor_write_throttling(struct file * file,
|
||||
const char __user * buffer,
|
||||
size_t count, loff_t * data)
|
||||
static ssize_t acpi_processor_write_throttling(struct file * file,
|
||||
const char __user * buffer,
|
||||
size_t count, loff_t * data)
|
||||
{
|
||||
int result = 0;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
|
|
@ -337,6 +337,7 @@ ssize_t acpi_processor_write_throttling(struct file * file,
|
|||
struct file_operations acpi_processor_throttling_fops = {
|
||||
.open = acpi_processor_throttling_open_fs,
|
||||
.read = seq_read,
|
||||
.write = acpi_processor_write_throttling,
|
||||
.llseek = seq_lseek,
|
||||
.release = single_release,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -475,8 +475,10 @@ static LIST_HEAD(acpi_bus_drivers);
|
|||
static DECLARE_MUTEX(acpi_bus_drivers_lock);
|
||||
|
||||
/**
|
||||
* acpi_bus_match
|
||||
* --------------
|
||||
* acpi_bus_match - match device IDs to driver's supported IDs
|
||||
* @device: the device that we are trying to match to a driver
|
||||
* @driver: driver whose device id table is being checked
|
||||
*
|
||||
* Checks the device's hardware (_HID) or compatible (_CID) ids to see if it
|
||||
* matches the specified driver's criteria.
|
||||
*/
|
||||
|
|
@ -489,8 +491,10 @@ acpi_bus_match(struct acpi_device *device, struct acpi_driver *driver)
|
|||
}
|
||||
|
||||
/**
|
||||
* acpi_bus_driver_init
|
||||
* --------------------
|
||||
* acpi_bus_driver_init - add a device to a driver
|
||||
* @device: the device to add and initialize
|
||||
* @driver: driver for the device
|
||||
*
|
||||
* Used to initialize a device via its device driver. Called whenever a
|
||||
* driver is bound to a device. Invokes the driver's add() and start() ops.
|
||||
*/
|
||||
|
|
@ -603,8 +607,9 @@ static int acpi_driver_detach(struct acpi_driver *drv)
|
|||
}
|
||||
|
||||
/**
|
||||
* acpi_bus_register_driver
|
||||
* ------------------------
|
||||
* acpi_bus_register_driver - register a driver with the ACPI bus
|
||||
* @driver: driver being registered
|
||||
*
|
||||
* Registers a driver with the ACPI bus. Searches the namespace for all
|
||||
* devices that match the driver's criteria and binds. Returns the
|
||||
* number of devices that were claimed by the driver, or a negative
|
||||
|
|
@ -633,8 +638,9 @@ int acpi_bus_register_driver(struct acpi_driver *driver)
|
|||
EXPORT_SYMBOL(acpi_bus_register_driver);
|
||||
|
||||
/**
|
||||
* acpi_bus_unregister_driver
|
||||
* --------------------------
|
||||
* acpi_bus_unregister_driver - unregisters a driver with the APIC bus
|
||||
* @driver: driver to unregister
|
||||
*
|
||||
* Unregisters a driver with the ACPI bus. Searches the namespace for all
|
||||
* devices that match the driver's criteria and unbinds.
|
||||
*/
|
||||
|
|
@ -660,8 +666,9 @@ int acpi_bus_unregister_driver(struct acpi_driver *driver)
|
|||
EXPORT_SYMBOL(acpi_bus_unregister_driver);
|
||||
|
||||
/**
|
||||
* acpi_bus_find_driver
|
||||
* --------------------
|
||||
* acpi_bus_find_driver - check if there is a driver installed for the device
|
||||
* @device: device that we are trying to find a supporting driver for
|
||||
*
|
||||
* Parses the list of registered drivers looking for a driver applicable for
|
||||
* the specified device.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -33,9 +33,7 @@ int acpi_sleep_prepare(u32 acpi_state)
|
|||
ACPI_FLUSH_CPU_CACHE();
|
||||
acpi_enable_wakeup_device_prep(acpi_state);
|
||||
#endif
|
||||
if (acpi_state == ACPI_STATE_S5) {
|
||||
acpi_wakeup_gpe_poweroff_prepare();
|
||||
}
|
||||
acpi_gpe_sleep_prepare(acpi_state);
|
||||
acpi_enter_sleep_state_prep(acpi_state);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -53,11 +51,16 @@ void acpi_power_off(void)
|
|||
|
||||
static int acpi_shutdown(struct sys_device *x)
|
||||
{
|
||||
if (system_state == SYSTEM_POWER_OFF) {
|
||||
/* Prepare if we are going to power off the system */
|
||||
switch (system_state) {
|
||||
case SYSTEM_POWER_OFF:
|
||||
/* Prepare to power off the system */
|
||||
return acpi_sleep_prepare(ACPI_STATE_S5);
|
||||
case SYSTEM_SUSPEND_DISK:
|
||||
/* Prepare to suspend the system to disk */
|
||||
return acpi_sleep_prepare(ACPI_STATE_S4);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct sysdev_class acpi_sysclass = {
|
||||
|
|
|
|||
|
|
@ -5,4 +5,4 @@ extern int acpi_suspend (u32 state);
|
|||
extern void acpi_enable_wakeup_device_prep(u8 sleep_state);
|
||||
extern void acpi_enable_wakeup_device(u8 sleep_state);
|
||||
extern void acpi_disable_wakeup_device(u8 sleep_state);
|
||||
extern void acpi_wakeup_gpe_poweroff_prepare(void);
|
||||
extern void acpi_gpe_sleep_prepare(u32 sleep_state);
|
||||
|
|
|
|||
|
|
@ -192,7 +192,7 @@ late_initcall(acpi_wakeup_device_init);
|
|||
* RUNTIME GPEs, we simply mark all GPES that
|
||||
* are not enabled for wakeup from S5 as RUNTIME.
|
||||
*/
|
||||
void acpi_wakeup_gpe_poweroff_prepare(void)
|
||||
void acpi_gpe_sleep_prepare(u32 sleep_state)
|
||||
{
|
||||
struct list_head *node, *next;
|
||||
|
||||
|
|
@ -201,8 +201,8 @@ void acpi_wakeup_gpe_poweroff_prepare(void)
|
|||
struct acpi_device,
|
||||
wakeup_list);
|
||||
|
||||
/* The GPE can wakeup system from S5, don't touch it */
|
||||
if ((u32) dev->wakeup.sleep_state == ACPI_STATE_S5)
|
||||
/* The GPE can wakeup system from this state, don't touch it */
|
||||
if ((u32) dev->wakeup.sleep_state >= sleep_state)
|
||||
continue;
|
||||
/* acpi_set_gpe_type will automatically disable GPE */
|
||||
acpi_set_gpe_type(dev->wakeup.gpe_device,
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
|
||||
#define PREFIX "ACPI: "
|
||||
|
||||
#define ACPI_MAX_TABLES 256
|
||||
#define ACPI_MAX_TABLES 128
|
||||
|
||||
static char *acpi_table_signatures[ACPI_TABLE_COUNT] = {
|
||||
[ACPI_TABLE_UNKNOWN] = "????",
|
||||
|
|
@ -74,7 +74,7 @@ struct acpi_table_sdt {
|
|||
static unsigned long sdt_pa; /* Physical Address */
|
||||
static unsigned long sdt_count; /* Table count */
|
||||
|
||||
static struct acpi_table_sdt sdt_entry[ACPI_MAX_TABLES];
|
||||
static struct acpi_table_sdt sdt_entry[ACPI_MAX_TABLES] __initdata;
|
||||
|
||||
void acpi_table_print(struct acpi_table_header *header, unsigned long phys_addr)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -920,8 +920,8 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
|
|||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
|
||||
"Unable to create 'state' fs entry\n"));
|
||||
else {
|
||||
acpi_video_device_state_fops.write = acpi_video_device_write_state;
|
||||
entry->proc_fops = &acpi_video_device_state_fops;
|
||||
entry->proc_fops->write = acpi_video_device_write_state;
|
||||
entry->data = acpi_driver_data(device);
|
||||
entry->owner = THIS_MODULE;
|
||||
}
|
||||
|
|
@ -934,8 +934,8 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
|
|||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
|
||||
"Unable to create 'brightness' fs entry\n"));
|
||||
else {
|
||||
acpi_video_device_brightness_fops.write = acpi_video_device_write_brightness;
|
||||
entry->proc_fops = &acpi_video_device_brightness_fops;
|
||||
entry->proc_fops->write = acpi_video_device_write_brightness;
|
||||
entry->data = acpi_driver_data(device);
|
||||
entry->owner = THIS_MODULE;
|
||||
}
|
||||
|
|
@ -1239,8 +1239,8 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
|
|||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
|
||||
"Unable to create 'POST' fs entry\n"));
|
||||
else {
|
||||
acpi_video_bus_POST_fops.write = acpi_video_bus_write_POST;
|
||||
entry->proc_fops = &acpi_video_bus_POST_fops;
|
||||
entry->proc_fops->write = acpi_video_bus_write_POST;
|
||||
entry->data = acpi_driver_data(device);
|
||||
entry->owner = THIS_MODULE;
|
||||
}
|
||||
|
|
@ -1253,8 +1253,8 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
|
|||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
|
||||
"Unable to create 'DOS' fs entry\n"));
|
||||
else {
|
||||
acpi_video_bus_DOS_fops.write = acpi_video_bus_write_DOS;
|
||||
entry->proc_fops = &acpi_video_bus_DOS_fops;
|
||||
entry->proc_fops->write = acpi_video_bus_write_DOS;
|
||||
entry->data = acpi_driver_data(device);
|
||||
entry->owner = THIS_MODULE;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue