Pull release into acpica branch

16 files changed, 329 insertions, 267 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index fce21c257523..0cce28c4025b 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -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
diff --git a/drivers/acpi/asus_acpi.c b/drivers/acpi/asus_acpi.c
index fec895af6ae6..f4c87750dbf2 100644
--- a/drivers/acpi/asus_acpi.c
+++ b/drivers/acpi/asus_acpi.c
@@ -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;
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 0ecbfa5db1ba..79b09d76c180 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -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;
-                        return_VALUE(0);
-                }
-                break;
-
         case ACPI_EC_EVENT_IBE:
                 if (~acpi_ec_read_status(ec) & event) {
-                        ec->burst.expect_event = 0;
+                        ec->intr.expect_event = 0;
                         return_VALUE(0);
                 }
                 break;
+        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);
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 58e7c47354ee..cc4a4903842a 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -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);
                         }
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index 726dda1fce1c..65aee79b3971 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -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--;
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 1278aca96fe3..99a3a28594da 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -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;
-
-        pdc = (pdc_in) ? pdc_in : &no_object;
+        if (!pdc_in)
+                return_VALUE(status);
 
-        status = acpi_evaluate_object(pr->handle, "_PDC", pdc, NULL);
+        status = acpi_evaluate_object(pr->handle, "_PDC", pdc_in, 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) {
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 807b0df308f1..be2dae52f6fa 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -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);
 
         /*
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index 22c7bb66c200..abbdb37a7f5f 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -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;
         }
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index dc9817cfb882..f99ad05cd6a2 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -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,
 };
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index 74a52d4e79ae..b966549ec000 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -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,
 };
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index c60516d0f66b..9271e5209ac1 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -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.
  */
diff --git a/drivers/acpi/sleep/poweroff.c b/drivers/acpi/sleep/poweroff.c
index af7935a95bcc..47fb4b394eec 100644
--- a/drivers/acpi/sleep/poweroff.c
+++ b/drivers/acpi/sleep/poweroff.c
@@ -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 = {
diff --git a/drivers/acpi/sleep/sleep.h b/drivers/acpi/sleep/sleep.h
index efd0001c6f05..f3e70397a7d6 100644
--- a/drivers/acpi/sleep/sleep.h
+++ b/drivers/acpi/sleep/sleep.h
@@ -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);
diff --git a/drivers/acpi/sleep/wakeup.c b/drivers/acpi/sleep/wakeup.c
index 4134ed43d026..85df0ceda2a9 100644
--- a/drivers/acpi/sleep/wakeup.c
+++ b/drivers/acpi/sleep/wakeup.c
@@ -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,
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index a2bf25b05e1c..31d4f3ffc265 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -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)
 {
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index d10668f14699..bd4887518373 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -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;
         }