49 files changed, 1762 insertions, 747 deletions
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 0f9d4be7ed75..1639998e4d27 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -11,7 +11,7 @@ config ACPI
        bool "ACPI Support"
        depends on IA64 || X86
        depends on PCI
-        select PM
+        depends on PM
        default y
        ---help---
          Advanced Configuration and Power Interface (ACPI) support for 
@@ -97,6 +97,7 @@ config ACPI_BATTERY
 config ACPI_BUTTON
        tristate "Button"
+        depends on INPUT
        default y
        help
          This driver handles events on the power, sleep and lid buttons.
@@ -172,6 +173,7 @@ config ACPI_NUMA
 config ACPI_ASUS
        tristate "ASUS/Medion Laptop Extras"
        depends on X86
+        select BACKLIGHT_CLASS_DEVICE
        ---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
@@ -200,6 +202,7 @@ config ACPI_ASUS
 config ACPI_IBM
        tristate "IBM ThinkPad Laptop Extras"
        depends on X86
+        select BACKLIGHT_CLASS_DEVICE
        ---help---
          This is a Linux ACPI driver for the IBM ThinkPad laptops. It adds
          support for Fn-Fx key combinations, Bluetooth control, video
@@ -222,9 +225,21 @@ config ACPI_IBM_DOCK
          If you are not sure, say N here.
+config ACPI_IBM_BAY
+        bool "Legacy Removable Bay Support"
+        depends on ACPI_IBM
+        depends on ACPI_BAY=n
+        default n
+        ---help---
+          Allows the ibm_acpi driver to handle removable bays.
+          This support is obsoleted by CONFIG_ACPI_BAY.
+          If you are not sure, say N here.
 config ACPI_TOSHIBA
        tristate "Toshiba Laptop Extras"
        depends on X86
+        select BACKLIGHT_CLASS_DEVICE
        ---help---
          This driver adds support for access to certain system settings
          on "legacy free" Toshiba laptops.  These laptops can be recognized by
diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 11abc7bf777e..6daeace796a8 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -109,7 +109,7 @@ static struct proc_dir_entry *acpi_ac_dir;
 static int acpi_ac_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_ac *ac = (struct acpi_ac *)seq->private;
+        struct acpi_ac *ac = seq->private;
        if (!ac)
@@ -187,7 +187,7 @@ static int acpi_ac_remove_fs(struct acpi_device *device)
 static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_ac *ac = (struct acpi_ac *)data;
+        struct acpi_ac *ac = data;
        struct acpi_device *device = NULL;
@@ -221,10 +221,9 @@ static int acpi_ac_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        ac = kmalloc(sizeof(struct acpi_ac), GFP_KERNEL);
+        ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL);
        if (!ac)
                return -ENOMEM;
-        memset(ac, 0, sizeof(struct acpi_ac));
        ac->device = device;
        strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
@@ -269,7 +268,7 @@ static int acpi_ac_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        ac = (struct acpi_ac *)acpi_driver_data(device);
+        ac = acpi_driver_data(device);
        status = acpi_remove_notify_handler(device->handle,
                                            ACPI_ALL_NOTIFY, acpi_ac_notify);
diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index 6bcd9e8e7bcb..cd946ed192d3 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -395,10 +395,9 @@ static int acpi_memory_device_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        mem_device = kmalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
+        mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
        if (!mem_device)
                return -ENOMEM;
-        memset(mem_device, 0, sizeof(struct acpi_memory_device));
        INIT_LIST_HEAD(&mem_device->res_list);
        mem_device->device = device;
@@ -429,7 +428,7 @@ static int acpi_memory_device_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        mem_device = (struct acpi_memory_device *)acpi_driver_data(device);
+        mem_device = acpi_driver_data(device);
        kfree(mem_device);
        return 0;
diff --git a/drivers/acpi/asus_acpi.c b/drivers/acpi/asus_acpi.c
index c7ac9297a204..396140bbbe57 100644
--- a/drivers/acpi/asus_acpi.c
+++ b/drivers/acpi/asus_acpi.c
@@ -35,6 +35,7 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/proc_fs.h>
+#include <linux/backlight.h>
 #include <acpi/acpi_drivers.h>
 #include <acpi/acpi_bus.h>
 #include <asm/uaccess.h>
@@ -402,6 +403,8 @@ static struct model_data model_conf[END_MODEL] = {
 /* procdir we use */
 static struct proc_dir_entry *asus_proc_dir;
+static struct backlight_device *asus_backlight_device;
 /*
 * This header is made available to allow proper configuration given model,
 * revision number , ... this info cannot go in struct asus_hotk because it is
@@ -779,7 +782,7 @@ proc_write_lcd(struct file *file, const char __user * buffer,
        return rv;
 }
-static int read_brightness(void)
+static int read_brightness(struct backlight_device *bd)
 {
        int value;
@@ -801,9 +804,10 @@ static int read_brightness(void)
 /*
 * Change the brightness level
 */
-static void set_brightness(int value)
+static int set_brightness(int value)
 {
        acpi_status status = 0;
+        int ret = 0;
        /* SPLV laptop */
        if (hotk->methods->brightness_set) {
@@ -811,11 +815,12 @@ static void set_brightness(int value)
                                    value, NULL))
                        printk(KERN_WARNING
                               "Asus ACPI: Error changing brightness\n");
-                return;
+                        ret = -EIO;
+                goto out;
        }
        /* No SPLV method if we are here, act as appropriate */
-        value -= read_brightness();
+        value -= read_brightness(NULL);
        while (value != 0) {
                status = acpi_evaluate_object(NULL, (value > 0) ?
                                              hotk->methods->brightness_up :
@@ -825,15 +830,22 @@ static void set_brightness(int value)
                if (ACPI_FAILURE(status))
                        printk(KERN_WARNING
                               "Asus ACPI: Error changing brightness\n");
+                        ret = -EIO;
        }
-        return;
+out:
+        return ret;
+}
+static int set_brightness_status(struct backlight_device *bd)
+{
+        return set_brightness(bd->props->brightness);
 }
 static int
 proc_read_brn(char *page, char **start, off_t off, int count, int *eof,
              void *data)
 {
-        return sprintf(page, "%d\n", read_brightness());
+        return sprintf(page, "%d\n", read_brightness(NULL));
 }
 static int
@@ -1134,7 +1146,7 @@ static int asus_hotk_get_info(void)
        if (ACPI_FAILURE(status))
                printk(KERN_WARNING "  Couldn't get the DSDT table header\n");
        else
-                asus_info = (struct acpi_table_header *)dsdt.pointer;
+                asus_info = dsdt.pointer;
        /* We have to write 0 on init this far for all ASUS models */
        if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
@@ -1156,7 +1168,7 @@ static int asus_hotk_get_info(void)
         * asus_model_match() and try something completely different.
         */
        if (buffer.pointer) {
-                model = (union acpi_object *)buffer.pointer;
+                model = buffer.pointer;
                switch (model->type) {
                case ACPI_TYPE_STRING:
                        string = model->string.pointer;
@@ -1252,11 +1264,9 @@ static int asus_hotk_add(struct acpi_device *device)
        printk(KERN_NOTICE "Asus Laptop ACPI Extras version %s\n",
               ASUS_ACPI_VERSION);
-        hotk =
+        hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
-            (struct asus_hotk *)kmalloc(sizeof(struct asus_hotk), GFP_KERNEL);
        if (!hotk)
                return -ENOMEM;
-        memset(hotk, 0, sizeof(struct asus_hotk));
        hotk->handle = device->handle;
        strcpy(acpi_device_name(device), ACPI_HOTK_DEVICE_NAME);
@@ -1333,6 +1343,26 @@ static int asus_hotk_remove(struct acpi_device *device, int type)
        return 0;
 }
+static struct backlight_properties asus_backlight_data = {
+        .owner          = THIS_MODULE,
+        .get_brightness = read_brightness,
+        .update_status  = set_brightness_status,
+        .max_brightness = 15,
+};
+static void __exit asus_acpi_exit(void)
+{
+        if (asus_backlight_device)
+                backlight_device_unregister(asus_backlight_device);
+        acpi_bus_unregister_driver(&asus_hotk_driver);
+        remove_proc_entry(PROC_ASUS, acpi_root_dir);
+        kfree(asus_info);
+        return;
+}
 static int __init asus_acpi_init(void)
 {
        int result;
@@ -1370,17 +1400,15 @@ static int __init asus_acpi_init(void)
                return result;
        }
-        return 0;
+        asus_backlight_device = backlight_device_register("asus",NULL,NULL,
-}
+                                                          &asus_backlight_data);
+        if (IS_ERR(asus_backlight_device)) {
-static void __exit asus_acpi_exit(void)
+                printk(KERN_ERR "Could not register asus backlight device\n");
-{
+                asus_backlight_device = NULL;
-        acpi_bus_unregister_driver(&asus_hotk_driver);
+                asus_acpi_exit();
-        remove_proc_entry(PROC_ASUS, acpi_root_dir);
+        }
-        kfree(asus_info);
-        return;
+        return 0;
 }
 module_init(asus_acpi_init);
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 026e40755cdd..5f43e0d14899 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -149,7 +149,7 @@ acpi_battery_get_info(struct acpi_battery *battery,
                return -ENODEV;
        }
-        package = (union acpi_object *)buffer.pointer;
+        package = buffer.pointer;
        /* Extract Package Data */
@@ -160,12 +160,11 @@ acpi_battery_get_info(struct acpi_battery *battery,
                goto end;
        }
-        data.pointer = kmalloc(data.length, GFP_KERNEL);
+        data.pointer = kzalloc(data.length, GFP_KERNEL);
        if (!data.pointer) {
                result = -ENOMEM;
                goto end;
        }
-        memset(data.pointer, 0, data.length);
        status = acpi_extract_package(package, &format, &data);
        if (ACPI_FAILURE(status)) {
@@ -179,7 +178,7 @@ acpi_battery_get_info(struct acpi_battery *battery,
        kfree(buffer.pointer);
        if (!result)
-                (*bif) = (struct acpi_battery_info *)data.pointer;
+                (*bif) = data.pointer;
        return result;
 }
@@ -209,7 +208,7 @@ acpi_battery_get_status(struct acpi_battery *battery,
                return -ENODEV;
        }
-        package = (union acpi_object *)buffer.pointer;
+        package = buffer.pointer;
        /* Extract Package Data */
@@ -220,12 +219,11 @@ acpi_battery_get_status(struct acpi_battery *battery,
                goto end;
        }
-        data.pointer = kmalloc(data.length, GFP_KERNEL);
+        data.pointer = kzalloc(data.length, GFP_KERNEL);
        if (!data.pointer) {
                result = -ENOMEM;
                goto end;
        }
-        memset(data.pointer, 0, data.length);
        status = acpi_extract_package(package, &format, &data);
        if (ACPI_FAILURE(status)) {
@@ -239,7 +237,7 @@ acpi_battery_get_status(struct acpi_battery *battery,
        kfree(buffer.pointer);
        if (!result)
-                (*bst) = (struct acpi_battery_status *)data.pointer;
+                (*bst) = data.pointer;
        return result;
 }
@@ -334,7 +332,7 @@ static struct proc_dir_entry *acpi_battery_dir;
 static int acpi_battery_read_info(struct seq_file *seq, void *offset)
 {
        int result = 0;
-        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        struct acpi_battery *battery = seq->private;
        struct acpi_battery_info *bif = NULL;
        char *units = "?";
@@ -418,7 +416,7 @@ static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
 static int acpi_battery_read_state(struct seq_file *seq, void *offset)
 {
        int result = 0;
-        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        struct acpi_battery *battery = seq->private;
        struct acpi_battery_status *bst = NULL;
        char *units = "?";
@@ -494,7 +492,7 @@ static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
 {
-        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        struct acpi_battery *battery = seq->private;
        char *units = "?";
@@ -531,8 +529,8 @@ acpi_battery_write_alarm(struct file *file,
 {
        int result = 0;
        char alarm_string[12] = { '\0' };
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_battery *battery = (struct acpi_battery *)m->private;
+        struct acpi_battery *battery = m->private;
        if (!battery || (count > sizeof(alarm_string) - 1))
@@ -658,7 +656,7 @@ static int acpi_battery_remove_fs(struct acpi_device *device)
 static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_battery *battery = (struct acpi_battery *)data;
+        struct acpi_battery *battery = data;
        struct acpi_device *device = NULL;
@@ -694,10 +692,9 @@ static int acpi_battery_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        battery = kmalloc(sizeof(struct acpi_battery), GFP_KERNEL);
+        battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
        if (!battery)
                return -ENOMEM;
-        memset(battery, 0, sizeof(struct acpi_battery));
        battery->device = device;
        strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
@@ -742,7 +739,7 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        battery = (struct acpi_battery *)acpi_driver_data(device);
+        battery = acpi_driver_data(device);
        status = acpi_remove_notify_handler(device->handle,
                                            ACPI_ALL_NOTIFY,
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index 5ef885e82c78..ac860583c203 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -29,6 +29,7 @@
 #include <linux/types.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/input.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
@@ -62,7 +63,7 @@
 #define _COMPONENT              ACPI_BUTTON_COMPONENT
 ACPI_MODULE_NAME("acpi_button")
-    MODULE_AUTHOR("Paul Diefenbaugh");
+MODULE_AUTHOR("Paul Diefenbaugh");
 MODULE_DESCRIPTION(ACPI_BUTTON_DRIVER_NAME);
 MODULE_LICENSE("GPL");
@@ -78,12 +79,14 @@ static struct acpi_driver acpi_button_driver = {
        .ops = {
                .add = acpi_button_add,
                .remove = acpi_button_remove,
-                },
+        },
 };
 struct acpi_button {
        struct acpi_device *device;     /* Fixed button kludge */
-        u8 type;
+        unsigned int type;
+        struct input_dev *input;
+        char phys[32];                  /* for input device */
        unsigned long pushed;
 };
@@ -109,8 +112,7 @@ static struct proc_dir_entry *acpi_button_dir;
 static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_button *button = (struct acpi_button *)seq->private;
+        struct acpi_button *button = seq->private;
        if (!button || !button->device)
                return 0;
@@ -128,22 +130,17 @@ static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
 static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_button *button = (struct acpi_button *)seq->private;
+        struct acpi_button *button = seq->private;
        acpi_status status;
        unsigned long state;
        if (!button || !button->device)
                return 0;
        status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);
-        if (ACPI_FAILURE(status)) {
+        seq_printf(seq, "state:      %s\n",
-                seq_printf(seq, "state:      unsupported\n");
+                   ACPI_FAILURE(status) ? "unsupported" :
-        } else {
+                        (state ? "open" : "closed"));
-                seq_printf(seq, "state:      %s\n",
-                           (state ? "open" : "closed"));
-        }
        return 0;
 }
@@ -159,8 +156,7 @@ static struct proc_dir_entry *acpi_lid_dir;
 static int acpi_button_add_fs(struct acpi_device *device)
 {
        struct proc_dir_entry *entry = NULL;
-        struct acpi_button *button = NULL;
+        struct acpi_button *button;
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
@@ -228,10 +224,8 @@ static int acpi_button_add_fs(struct acpi_device *device)
 static int acpi_button_remove_fs(struct acpi_device *device)
 {
-        struct acpi_button *button = NULL;
+        struct acpi_button *button = acpi_driver_data(device);
-        button = acpi_driver_data(device);
        if (acpi_device_dir(device)) {
                if (button->type == ACPI_BUTTON_TYPE_LID)
                        remove_proc_entry(ACPI_BUTTON_FILE_STATE,
@@ -253,14 +247,34 @@ static int acpi_button_remove_fs(struct acpi_device *device)
 static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_button *button = (struct acpi_button *)data;
+        struct acpi_button *button = data;
+        struct input_dev *input;
        if (!button || !button->device)
                return;
        switch (event) {
        case ACPI_BUTTON_NOTIFY_STATUS:
+                input = button->input;
+                if (button->type == ACPI_BUTTON_TYPE_LID) {
+                        struct acpi_handle *handle = button->device->handle;
+                        unsigned long state;
+                        if (!ACPI_FAILURE(acpi_evaluate_integer(handle, "_LID",
+                                                                NULL, &state)))
+                                input_report_switch(input, SW_LID, !state);
+                } else {
+                        int keycode = test_bit(KEY_SLEEP, input->keybit) ?
+                                                KEY_SLEEP : KEY_POWER;
+                        input_report_key(input, keycode, 1);
+                        input_sync(input);
+                        input_report_key(input, keycode, 0);
+                }
+                input_sync(input);
                acpi_bus_generate_event(button->device, event,
                                        ++button->pushed);
                break;
@@ -275,8 +289,7 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
 static acpi_status acpi_button_notify_fixed(void *data)
 {
-        struct acpi_button *button = (struct acpi_button *)data;
+        struct acpi_button *button = data;
        if (!button)
                return AE_BAD_PARAMETER;
@@ -286,24 +299,75 @@ static acpi_status acpi_button_notify_fixed(void *data)
        return AE_OK;
 }
-static int acpi_button_add(struct acpi_device *device)
+static int acpi_button_install_notify_handlers(struct acpi_button *button)
 {
-        int result = 0;
+        acpi_status status;
-        acpi_status status = AE_OK;
-        struct acpi_button *button = NULL;
+        switch (button->type) {
+        case ACPI_BUTTON_TYPE_POWERF:
+                status =
+                    acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
+                                                     acpi_button_notify_fixed,
+                                                     button);
+                break;
+        case ACPI_BUTTON_TYPE_SLEEPF:
+                status =
+                    acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
+                                                     acpi_button_notify_fixed,
+                                                     button);
+                break;
+        default:
+                status = acpi_install_notify_handler(button->device->handle,
+                                                     ACPI_DEVICE_NOTIFY,
+                                                     acpi_button_notify,
+                                                     button);
+                break;
+        }
+        return ACPI_FAILURE(status) ? -ENODEV : 0;
+}
+static void acpi_button_remove_notify_handlers(struct acpi_button *button)
+{
+        switch (button->type) {
+        case ACPI_BUTTON_TYPE_POWERF:
+                acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
+                                                acpi_button_notify_fixed);
+                break;
+        case ACPI_BUTTON_TYPE_SLEEPF:
+                acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
+                                                acpi_button_notify_fixed);
+                break;
+        default:
+                acpi_remove_notify_handler(button->device->handle,
+                                           ACPI_DEVICE_NOTIFY,
+                                           acpi_button_notify);
+                break;
+        }
+}
+static int acpi_button_add(struct acpi_device *device)
+{
+        int error;
+        struct acpi_button *button;
+        struct input_dev *input;
        if (!device)
                return -EINVAL;
-        button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);
+        button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
        if (!button)
                return -ENOMEM;
-        memset(button, 0, sizeof(struct acpi_button));
        button->device = device;
        acpi_driver_data(device) = button;
+        button->input = input = input_allocate_device();
+        if (!input) {
+                error = -ENOMEM;
+                goto err_free_button;
+        }
        /*
         * Determine the button type (via hid), as fixed-feature buttons
         * need to be handled a bit differently than generic-space.
@@ -338,39 +402,48 @@ static int acpi_button_add(struct acpi_device *device)
        } else {
                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",
                            acpi_device_hid(device));
-                result = -ENODEV;
+                error = -ENODEV;
-                goto end;
+                goto err_free_input;
        }
-        result = acpi_button_add_fs(device);
+        error = acpi_button_add_fs(device);
-        if (result)
+        if (error)
-                goto end;
+                goto err_free_input;
+        error = acpi_button_install_notify_handlers(button);
+        if (error)
+                goto err_remove_fs;
+        snprintf(button->phys, sizeof(button->phys),
+                 "%s/button/input0", acpi_device_hid(device));
+        input->name = acpi_device_name(device);
+        input->phys = button->phys;
+        input->id.bustype = BUS_HOST;
+        input->id.product = button->type;
        switch (button->type) {
+        case ACPI_BUTTON_TYPE_POWER:
        case ACPI_BUTTON_TYPE_POWERF:
-                status =
+                input->evbit[0] = BIT(EV_KEY);
-                    acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
+                set_bit(KEY_POWER, input->keybit);
-                                                     acpi_button_notify_fixed,
-                                                     button);
                break;
+        case ACPI_BUTTON_TYPE_SLEEP:
        case ACPI_BUTTON_TYPE_SLEEPF:
-                status =
+                input->evbit[0] = BIT(EV_KEY);
-                    acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
+                set_bit(KEY_SLEEP, input->keybit);
-                                                     acpi_button_notify_fixed,
-                                                     button);
                break;
-        default:
-                status = acpi_install_notify_handler(device->handle,
+        case ACPI_BUTTON_TYPE_LID:
-                                                     ACPI_DEVICE_NOTIFY,
+                input->evbit[0] = BIT(EV_SW);
-                                                     acpi_button_notify,
+                set_bit(SW_LID, input->swbit);
-                                                     button);
                break;
        }
-        if (ACPI_FAILURE(status)) {
+        error = input_register_device(input);
-                result = -ENODEV;
+        if (error)
-                goto end;
+                goto err_remove_handlers;
-        }
        if (device->wakeup.flags.valid) {
                /* Button's GPE is run-wake GPE */
@@ -385,47 +458,31 @@ static int acpi_button_add(struct acpi_device *device)
        printk(KERN_INFO PREFIX "%s [%s]\n",
               acpi_device_name(device), acpi_device_bid(device));
-      end:
+        return 0;
-        if (result) {
-                acpi_button_remove_fs(device);
-                kfree(button);
-        }
-        return result;
+ err_remove_handlers:
+        acpi_button_remove_notify_handlers(button);
+ err_remove_fs:
+        acpi_button_remove_fs(device);
+ err_free_input:
+        input_free_device(input);
+ err_free_button:
+        kfree(button);
+        return error;
 }
 static int acpi_button_remove(struct acpi_device *device, int type)
 {
-        acpi_status status = 0;
+        struct acpi_button *button;
-        struct acpi_button *button = NULL;
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
        button = acpi_driver_data(device);
-        /* Unregister for device notifications. */
+        acpi_button_remove_notify_handlers(button);
-        switch (button->type) {
-        case ACPI_BUTTON_TYPE_POWERF:
-                status =
-                    acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
-                                                    acpi_button_notify_fixed);
-                break;
-        case ACPI_BUTTON_TYPE_SLEEPF:
-                status =
-                    acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
-                                                    acpi_button_notify_fixed);
-                break;
-        default:
-                status = acpi_remove_notify_handler(device->handle,
-                                                    ACPI_DEVICE_NOTIFY,
-                                                    acpi_button_notify);
-                break;
-        }
        acpi_button_remove_fs(device);
+        input_unregister_device(button->input);
        kfree(button);
        return 0;
@@ -433,8 +490,7 @@ static int acpi_button_remove(struct acpi_device *device, int type)
 static int __init acpi_button_init(void)
 {
-        int result = 0;
+        int result;
        acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
        if (!acpi_button_dir)
@@ -451,7 +507,6 @@ static int __init acpi_button_init(void)
 static void __exit acpi_button_exit(void)
 {
        acpi_bus_unregister_driver(&acpi_button_driver);
        if (acpi_power_dir)
@@ -461,8 +516,6 @@ static void __exit acpi_button_exit(void)
        if (acpi_lid_dir)
                remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
        remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
-        return;
 }
 module_init(acpi_button_init);
diff --git a/drivers/acpi/container.c b/drivers/acpi/container.c
index 871aa520ece7..0a1863ec91f3 100644
--- a/drivers/acpi/container.c
+++ b/drivers/acpi/container.c
@@ -96,11 +96,10 @@ static int acpi_container_add(struct acpi_device *device)
                return -EINVAL;
        }
-        container = kmalloc(sizeof(struct acpi_container), GFP_KERNEL);
+        container = kzalloc(sizeof(struct acpi_container), GFP_KERNEL);
        if (!container)
                return -ENOMEM;
-        memset(container, 0, sizeof(struct acpi_container));
        container->handle = device->handle;
        strcpy(acpi_device_name(device), ACPI_CONTAINER_DEVICE_NAME);
        strcpy(acpi_device_class(device), ACPI_CONTAINER_CLASS);
@@ -117,7 +116,7 @@ static int acpi_container_remove(struct acpi_device *device, int type)
        acpi_status status = AE_OK;
        struct acpi_container *pc = NULL;
-        pc = (struct acpi_container *)acpi_driver_data(device);
+        pc = acpi_driver_data(device);
        kfree(pc);
        return status;
 }
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index bf5b79ed3613..90990a4b6526 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -27,6 +27,7 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/notifier.h>
+#include <linux/platform_device.h>
 #include <linux/jiffies.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
@@ -39,13 +40,15 @@ MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_NAME);
 MODULE_LICENSE("GPL");
 static struct atomic_notifier_head dock_notifier_list;
+static struct platform_device dock_device;
+static char dock_device_name[] = "dock";
 struct dock_station {
        acpi_handle handle;
        unsigned long last_dock_time;
        u32 flags;
        spinlock_t dd_lock;
-        spinlock_t hp_lock;
+        struct mutex hp_lock;
        struct list_head dependent_devices;
        struct list_head hotplug_devices;
 };
@@ -115,9 +118,9 @@ static void
 dock_add_hotplug_device(struct dock_station *ds,
                        struct dock_dependent_device *dd)
 {
-        spin_lock(&ds->hp_lock);
+        mutex_lock(&ds->hp_lock);
        list_add_tail(&dd->hotplug_list, &ds->hotplug_devices);
-        spin_unlock(&ds->hp_lock);
+        mutex_unlock(&ds->hp_lock);
 }
 /**
@@ -131,9 +134,9 @@ static void
 dock_del_hotplug_device(struct dock_station *ds,
                        struct dock_dependent_device *dd)
 {
-        spin_lock(&ds->hp_lock);
+        mutex_lock(&ds->hp_lock);
        list_del(&dd->hotplug_list);
-        spin_unlock(&ds->hp_lock);
+        mutex_unlock(&ds->hp_lock);
 }
 /**
@@ -296,7 +299,7 @@ static void hotplug_dock_devices(struct dock_station *ds, u32 event)
 {
        struct dock_dependent_device *dd;
-        spin_lock(&ds->hp_lock);
+        mutex_lock(&ds->hp_lock);
        /*
         * First call driver specific hotplug functions
@@ -318,15 +321,17 @@ static void hotplug_dock_devices(struct dock_station *ds, u32 event)
                else
                        dock_create_acpi_device(dd->handle);
        }
-        spin_unlock(&ds->hp_lock);
+        mutex_unlock(&ds->hp_lock);
 }
 static void dock_event(struct dock_station *ds, u32 event, int num)
 {
+        struct device *dev = &dock_device.dev;
        /*
-         * we don't do events until someone tells me that
+         * Indicate that the status of the dock station has
-         * they would like to have them.
+         * changed.
         */
+        kobject_uevent(&dev->kobj, KOBJ_CHANGE);
 }
 /**
@@ -441,6 +446,9 @@ static int dock_in_progress(struct dock_station *ds)
 */
 int register_dock_notifier(struct notifier_block *nb)
 {
+        if (!dock_station)
+                return -ENODEV;
        return atomic_notifier_chain_register(&dock_notifier_list, nb);
 }
@@ -452,6 +460,9 @@ EXPORT_SYMBOL_GPL(register_dock_notifier);
 */
 void unregister_dock_notifier(struct notifier_block *nb)
 {
+        if (!dock_station)
+                return;
        atomic_notifier_chain_unregister(&dock_notifier_list, nb);
 }
@@ -512,6 +523,37 @@ void unregister_hotplug_dock_device(acpi_handle handle)
 EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);
 /**
+ * handle_eject_request - handle an undock request checking for error conditions
+ *
+ * Check to make sure the dock device is still present, then undock and
+ * hotremove all the devices that may need removing.
+ */
+static int handle_eject_request(struct dock_station *ds, u32 event)
+{
+        if (!dock_present(ds))
+                return -ENODEV;
+        if (dock_in_progress(ds))
+                return -EBUSY;
+        /*
+         * here we need to generate the undock
+         * event prior to actually doing the undock
+         * so that the device struct still exists.
+         */
+        dock_event(ds, event, UNDOCK_EVENT);
+        hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST);
+        undock(ds);
+        eject_dock(ds);
+        if (dock_present(ds)) {
+                printk(KERN_ERR PREFIX "Unable to undock!\n");
+                return -EBUSY;
+        }
+        return 0;
+}
+/**
 * dock_notify - act upon an acpi dock notification
 * @handle: the dock station handle
 * @event: the acpi event
@@ -519,13 +561,11 @@ EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);
 *
 * If we are notified to dock, then check to see if the dock is
 * present and then dock.  Notify all drivers of the dock event,
- * and then hotplug and devices that may need hotplugging.  For undock
+ * and then hotplug and devices that may need hotplugging.
- * check to make sure the dock device is still present, then undock
- * and hotremove all the devices that may need removing.
 */
 static void dock_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct dock_station *ds = (struct dock_station *)data;
+        struct dock_station *ds = data;
        switch (event) {
        case ACPI_NOTIFY_BUS_CHECK:
@@ -553,19 +593,7 @@ static void dock_notify(acpi_handle handle, u32 event, void *data)
         * to the driver who wish to hotplug.
         */
        case ACPI_NOTIFY_EJECT_REQUEST:
-                if (!dock_in_progress(ds) && dock_present(ds)) {
+                handle_eject_request(ds, event);
-                        /*
-                         * here we need to generate the undock
-                         * event prior to actually doing the undock
-                         * so that the device struct still exists.
-                         */
-                        dock_event(ds, event, UNDOCK_EVENT);
-                        hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST);
-                        undock(ds);
-                        eject_dock(ds);
-                        if (dock_present(ds))
-                                printk(KERN_ERR PREFIX "Unable to undock!\n");
-                }
                break;
        default:
                printk(KERN_ERR PREFIX "Unknown dock event %d\n", event);
@@ -588,7 +616,7 @@ find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
        acpi_status status;
        acpi_handle tmp;
-        struct dock_station *ds = (struct dock_station *)context;
+        struct dock_station *ds = context;
        struct dock_dependent_device *dd;
        status = acpi_bus_get_ejd(handle, &tmp);
@@ -604,6 +632,33 @@ find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv)
        return AE_OK;
 }
+/*
+ * show_docked - read method for "docked" file in sysfs
+ */
+static ssize_t show_docked(struct device *dev,
+                           struct device_attribute *attr, char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "%d\n", dock_present(dock_station));
+}
+DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);
+/*
+ * write_undock - write method for "undock" file in sysfs
+ */
+static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        int ret;
+        if (!count)
+                return -EINVAL;
+        ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST);
+        return ret ? ret: count;
+}
+DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock);
 /**
 * dock_add - add a new dock station
 * @handle: the dock station handle
@@ -626,9 +681,33 @@ static int dock_add(acpi_handle handle)
        INIT_LIST_HEAD(&dock_station->dependent_devices);
        INIT_LIST_HEAD(&dock_station->hotplug_devices);
        spin_lock_init(&dock_station->dd_lock);
-        spin_lock_init(&dock_station->hp_lock);
+        mutex_init(&dock_station->hp_lock);
        ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list);
+        /* initialize platform device stuff */
+        dock_device.name = dock_device_name;
+        ret = platform_device_register(&dock_device);
+        if (ret) {
+                printk(KERN_ERR PREFIX "Error %d registering dock device\n", ret);
+                kfree(dock_station);
+                return ret;
+        }
+        ret = device_create_file(&dock_device.dev, &dev_attr_docked);
+        if (ret) {
+                printk("Error %d adding sysfs file\n", ret);
+                platform_device_unregister(&dock_device);
+                kfree(dock_station);
+                return ret;
+        }
+        ret = device_create_file(&dock_device.dev, &dev_attr_undock);
+        if (ret) {
+                printk("Error %d adding sysfs file\n", ret);
+                device_remove_file(&dock_device.dev, &dev_attr_docked);
+                platform_device_unregister(&dock_device);
+                kfree(dock_station);
+                return ret;
+        }
        /* Find dependent devices */
        acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                            ACPI_UINT32_MAX, find_dock_devices, dock_station,
@@ -638,7 +717,8 @@ static int dock_add(acpi_handle handle)
        dd = alloc_dock_dependent_device(handle);
        if (!dd) {
                kfree(dock_station);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto dock_add_err_unregister;
        }
        add_dock_dependent_device(dock_station, dd);
@@ -658,8 +738,12 @@ static int dock_add(acpi_handle handle)
        return 0;
 dock_add_err:
-        kfree(dock_station);
        kfree(dd);
+dock_add_err_unregister:
+        device_remove_file(&dock_device.dev, &dev_attr_docked);
+        device_remove_file(&dock_device.dev, &dev_attr_undock);
+        platform_device_unregister(&dock_device);
+        kfree(dock_station);
        return ret;
 }
@@ -686,6 +770,11 @@ static int dock_remove(void)
        if (ACPI_FAILURE(status))
                printk(KERN_ERR "Error removing notify handler\n");
+        /* cleanup sysfs */
+        device_remove_file(&dock_device.dev, &dev_attr_docked);
+        device_remove_file(&dock_device.dev, &dev_attr_undock);
+        platform_device_unregister(&dock_device);
        /* free dock station memory */
        kfree(dock_station);
        return 0;
@@ -703,7 +792,7 @@ static int dock_remove(void)
 static acpi_status
 find_dock(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
-        int *count = (int *)context;
+        int *count = context;
        acpi_status status = AE_OK;
        if (is_dock(handle)) {
@@ -726,7 +815,7 @@ static int __init dock_init(void)
                            ACPI_UINT32_MAX, find_dock, &num, NULL);
        if (!num)
-                return -ENODEV;
+                printk(KERN_INFO "No dock devices found.\n");
        return 0;
 }
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index e6d4b084dca2..9c52d87d6f04 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -45,35 +45,34 @@ ACPI_MODULE_NAME("acpi_ec")
 #define ACPI_EC_DRIVER_NAME             "ACPI Embedded Controller Driver"
 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
 #define ACPI_EC_FILE_INFO               "info"
+#undef PREFIX
+#define PREFIX                          "ACPI: EC: "
 /* EC status register */
 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
 /* EC commands */
-#define ACPI_EC_COMMAND_READ    0x80
+enum ec_command {
-#define ACPI_EC_COMMAND_WRITE   0x81
+        ACPI_EC_COMMAND_READ = 0x80,
-#define ACPI_EC_BURST_ENABLE    0x82
+        ACPI_EC_COMMAND_WRITE = 0x81,
-#define ACPI_EC_BURST_DISABLE   0x83
+        ACPI_EC_BURST_ENABLE = 0x82,
-#define ACPI_EC_COMMAND_QUERY   0x84
+        ACPI_EC_BURST_DISABLE = 0x83,
+        ACPI_EC_COMMAND_QUERY = 0x84,
+};
 /* EC events */
-enum {
+enum ec_event {
        ACPI_EC_EVENT_OBF_1 = 1,        /* Output buffer full */
-        ACPI_EC_EVENT_IBF_0,            /* Input buffer empty */
+        ACPI_EC_EVENT_IBF_0,    /* Input buffer empty */
 };
-#define ACPI_EC_DELAY           50      /* Wait 50ms max. during EC ops */
+#define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
-#define ACPI_EC_UDELAY         100      /* Poll @ 100us increments */
-#define ACPI_EC_UDELAY_COUNT   1000     /* Wait 10ms max. during EC ops */
-enum {
+static enum ec_mode {
-        EC_INTR = 1,    /* Output buffer full */
+        EC_INTR = 1,            /* Output buffer full */
-        EC_POLL,        /* Input buffer empty */
+        EC_POLL,                /* Input buffer empty */
-};
+} acpi_ec_mode = EC_INTR;
 static int acpi_ec_remove(struct acpi_device *device, int type);
 static int acpi_ec_start(struct acpi_device *device);
@@ -93,22 +92,21 @@ static struct acpi_driver acpi_ec_driver = {
 };
 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
-struct acpi_ec {
+static struct acpi_ec {
        acpi_handle handle;
        unsigned long uid;
-        unsigned long gpe_bit;
+        unsigned long gpe;
        unsigned long command_addr;
        unsigned long data_addr;
        unsigned long global_lock;
-        struct semaphore sem;
+        struct mutex lock;
-        unsigned int expect_event;
+        atomic_t query_pending;
        atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
        wait_queue_head_t wait;
 } *ec_ecdt;
 /* External interfaces use first EC only, so remember */
 static struct acpi_device *first_ec;
-static int acpi_ec_mode = EC_INTR;
 /* --------------------------------------------------------------------------
                             Transaction Management
@@ -134,54 +132,41 @@ static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
        outb(data, ec->data_addr);
 }
-static int acpi_ec_check_status(u8 status, u8 event)
+static inline int acpi_ec_check_status(struct acpi_ec *ec, enum ec_event event)
 {
-        switch (event) {
+        u8 status = acpi_ec_read_status(ec);
-        case ACPI_EC_EVENT_OBF_1:
+        if (event == ACPI_EC_EVENT_OBF_1) {
                if (status & ACPI_EC_FLAG_OBF)
                        return 1;
-                break;
+        } else if (event == ACPI_EC_EVENT_IBF_0) {
-        case ACPI_EC_EVENT_IBF_0:
                if (!(status & ACPI_EC_FLAG_IBF))
                        return 1;
-                break;
-        default:
-                break;
        }
        return 0;
 }
-static int acpi_ec_wait(struct acpi_ec *ec, u8 event)
+static int acpi_ec_wait(struct acpi_ec *ec, enum ec_event event)
 {
-        int i = (acpi_ec_mode == EC_POLL) ? ACPI_EC_UDELAY_COUNT : 0;
+        if (acpi_ec_mode == EC_POLL) {
-        long time_left;
+                unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
+                while (time_before(jiffies, delay)) {
-        ec->expect_event = event;
+                        if (acpi_ec_check_status(ec, event))
-        if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
-                ec->expect_event = 0;
-                return 0;
-        }
-        do {
-                if (acpi_ec_mode == EC_POLL) {
-                        udelay(ACPI_EC_UDELAY);
-                } else {
-                        time_left = wait_event_timeout(ec->wait,
-                                    !ec->expect_event,
-                                    msecs_to_jiffies(ACPI_EC_DELAY));
-                        if (time_left > 0) {
-                                ec->expect_event = 0;
                                return 0;
-                        }
                }
-                if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
+        } else {
-                        ec->expect_event = 0;
+                if (wait_event_timeout(ec->wait,
+                                       acpi_ec_check_status(ec, event),
+                                       msecs_to_jiffies(ACPI_EC_DELAY)) ||
+                    acpi_ec_check_status(ec, event)) {
                        return 0;
+                } else {
+                        printk(KERN_ERR PREFIX "acpi_ec_wait timeout,"
+                               " status = %d, expect_event = %d\n",
+                               acpi_ec_read_status(ec), event);
                }
-        } while (--i > 0);
+        }
-        ec->expect_event = 0;
        return -ETIME;
 }
@@ -196,7 +181,6 @@ int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
        u8 tmp = 0;
        u8 status = 0;
        status = acpi_ec_read_status(ec);
        if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
                status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
@@ -212,7 +196,7 @@ int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
        atomic_set(&ec->leaving_burst, 0);
        return 0;
-  end:
+      end:
        ACPI_EXCEPTION((AE_INFO, status, "EC wait, burst mode"));
        return -1;
 }
@@ -221,58 +205,68 @@ int acpi_ec_leave_burst_mode(struct acpi_ec *ec)
 {
        u8 status = 0;
        status = acpi_ec_read_status(ec);
-        if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
+        if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)) {
                status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
-                if(status)
+                if (status)
                        goto end;
                acpi_ec_write_cmd(ec, ACPI_EC_BURST_DISABLE);
                acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
        }
        atomic_set(&ec->leaving_burst, 1);
        return 0;
-  end:
+      end:
        ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode"));
        return -1;
 }
-#endif /* ACPI_FUTURE_USAGE */
+#endif                          /* ACPI_FUTURE_USAGE */
 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command,
-                                        const u8 *wdata, unsigned wdata_len,
+                                        const u8 * wdata, unsigned wdata_len,
-                                        u8 *rdata, unsigned rdata_len)
+                                        u8 * rdata, unsigned rdata_len)
 {
-        int result;
+        int result = 0;
        acpi_ec_write_cmd(ec, command);
-        for (; wdata_len > 0; wdata_len --) {
+        for (; wdata_len > 0; --wdata_len) {
                result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
-                if (result)
+                if (result) {
-                        return result;
+                        printk(KERN_ERR PREFIX
+                               "write_cmd timeout, command = %d\n", command);
+                        goto end;
+                }
                acpi_ec_write_data(ec, *(wdata++));
        }
-        if (command == ACPI_EC_COMMAND_WRITE) {
+        if (!rdata_len) {
                result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
-                if (result)
+                if (result) {
-                        return result;
+                        printk(KERN_ERR PREFIX
+                               "finish-write timeout, command = %d\n", command);
+                        goto end;
+                }
+        } else if (command == ACPI_EC_COMMAND_QUERY) {
+                atomic_set(&ec->query_pending, 0);
        }
-        for (; rdata_len > 0; rdata_len --) {
+        for (; rdata_len > 0; --rdata_len) {
                result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
-                if (result)
+                if (result) {
-                        return result;
+                        printk(KERN_ERR PREFIX "read timeout, command = %d\n",
+                               command);
+                        goto end;
+                }
                *(rdata++) = acpi_ec_read_data(ec);
        }
+      end:
-        return 0;
+        return result;
 }
 static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
-                                const u8 *wdata, unsigned wdata_len,
+                               const u8 * wdata, unsigned wdata_len,
-                                u8 *rdata, unsigned rdata_len)
+                               u8 * rdata, unsigned rdata_len)
 {
        int status;
        u32 glk;
@@ -280,36 +274,40 @@ static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
        if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata))
                return -EINVAL;
-        if (rdata)
+        if (rdata)
-                memset(rdata, 0, rdata_len);
+                memset(rdata, 0, rdata_len);
+        mutex_lock(&ec->lock);
        if (ec->global_lock) {
                status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
                if (ACPI_FAILURE(status))
                        return -ENODEV;
        }
-        down(&ec->sem);
+        /* Make sure GPE is enabled before doing transaction */
+        acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
        status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
        if (status) {
-                printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
+                printk(KERN_DEBUG PREFIX
+                       "input buffer is not empty, aborting transaction\n");
                goto end;
        }
-        status = acpi_ec_transaction_unlocked(ec, command,
+        status = acpi_ec_transaction_unlocked(ec, command,
-                                              wdata, wdata_len,
+                                              wdata, wdata_len,
-                                              rdata, rdata_len);
+                                              rdata, rdata_len);
-end:
+      end:
-        up(&ec->sem);
        if (ec->global_lock)
                acpi_release_global_lock(glk);
+        mutex_unlock(&ec->lock);
        return status;
 }
-static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
+static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
 {
        int result;
        u8 d;
@@ -322,15 +320,15 @@ static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
 {
-        u8 wdata[2] = { address, data };
+        u8 wdata[2] = { address, data };
-        return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
+        return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
                                   wdata, 2, NULL, 0);
 }
 /*
 * Externally callable EC access functions. For now, assume 1 EC only
 */
-int ec_read(u8 addr, u8 *val)
+int ec_read(u8 addr, u8 * val)
 {
        struct acpi_ec *ec;
        int err;
@@ -369,9 +367,9 @@ int ec_write(u8 addr, u8 val)
 EXPORT_SYMBOL(ec_write);
-extern int ec_transaction(u8 command,
+int ec_transaction(u8 command,
-                          const u8 *wdata, unsigned wdata_len,
+                          const u8 * wdata, unsigned wdata_len,
-                          u8 *rdata, unsigned rdata_len)
+                          u8 * rdata, unsigned rdata_len)
 {
        struct acpi_ec *ec;
@@ -386,65 +384,49 @@ extern int ec_transaction(u8 command,
 EXPORT_SYMBOL(ec_transaction);
-static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
+static int acpi_ec_query(struct acpi_ec *ec, u8 * data)
 {
        int result;
-        u8 d;
+        u8 d;
-        if (!ec || !data)
+        if (!ec || !data)
-                return -EINVAL;
+                return -EINVAL;
-        /*
+        /*
-         * Query the EC to find out which _Qxx method we need to evaluate.
+         * Query the EC to find out which _Qxx method we need to evaluate.
-         * Note that successful completion of the query causes the ACPI_EC_SCI
+         * Note that successful completion of the query causes the ACPI_EC_SCI
-         * bit to be cleared (and thus clearing the interrupt source).
+         * bit to be cleared (and thus clearing the interrupt source).
-         */
+         */
-        result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
+        result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
-        if (result)
+        if (result)
-                return result;
+                return result;
-        if (!d)
+        if (!d)
-                return -ENODATA;
+                return -ENODATA;
-        *data = d;
+        *data = d;
-        return 0;
+        return 0;
 }
 /* --------------------------------------------------------------------------
                                Event Management
   -------------------------------------------------------------------------- */
-struct acpi_ec_query_data {
-        acpi_handle handle;
-        u8 data;
-};
 static void acpi_ec_gpe_query(void *ec_cxt)
 {
        struct acpi_ec *ec = (struct acpi_ec *)ec_cxt;
        u8 value = 0;
-        static char object_name[8];
+        char object_name[8];
-        if (!ec)
+        if (!ec || acpi_ec_query(ec, &value))
-                goto end;
+                return;
-        value = acpi_ec_read_status(ec);
-        if (!(value & ACPI_EC_FLAG_SCI))
-                goto end;
-        if (acpi_ec_query(ec, &value))
-                goto end;
        snprintf(object_name, 8, "_Q%2.2X", value);
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s", object_name));
+        printk(KERN_INFO PREFIX "evaluating %s\n", object_name);
        acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
-      end:
-        acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
 }
 static u32 acpi_ec_gpe_handler(void *data)
@@ -453,22 +435,18 @@ static u32 acpi_ec_gpe_handler(void *data)
        u8 value;
        struct acpi_ec *ec = (struct acpi_ec *)data;
-        acpi_clear_gpe(NULL, ec->gpe_bit, ACPI_ISR);
-        value = acpi_ec_read_status(ec);
        if (acpi_ec_mode == EC_INTR) {
-                if (acpi_ec_check_status(value, ec->expect_event)) {
+                wake_up(&ec->wait);
-                        ec->expect_event = 0;
-                        wake_up(&ec->wait);
-                }
        }
-        if (value & ACPI_EC_FLAG_SCI) {
+        value = acpi_ec_read_status(ec);
-                status = acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec);
+        if ((value & ACPI_EC_FLAG_SCI) && !atomic_read(&ec->query_pending)) {
-                return status == AE_OK ?
+                atomic_set(&ec->query_pending, 1);
-                    ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
+                status =
+                    acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query,
+                                    ec);
        }
-        acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_ISR);
        return status == AE_OK ?
            ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
 }
@@ -504,7 +482,6 @@ acpi_ec_space_handler(u32 function,
        acpi_integer f_v = 0;
        int i = 0;
        if ((address > 0xFF) || !value || !handler_context)
                return AE_BAD_PARAMETER;
@@ -518,7 +495,7 @@ acpi_ec_space_handler(u32 function,
        switch (function) {
        case ACPI_READ:
                temp = 0;
-                result = acpi_ec_read(ec, (u8) address, (u8 *) &temp);
+                result = acpi_ec_read(ec, (u8) address, (u8 *) & temp);
                break;
        case ACPI_WRITE:
                result = acpi_ec_write(ec, (u8) address, (u8) temp);
@@ -571,18 +548,15 @@ static int acpi_ec_read_info(struct seq_file *seq, void *offset)
 {
        struct acpi_ec *ec = (struct acpi_ec *)seq->private;
        if (!ec)
                goto end;
-        seq_printf(seq, "gpe bit:                 0x%02x\n",
+        seq_printf(seq, "gpe:                 0x%02x\n", (u32) ec->gpe);
-                   (u32) ec->gpe_bit);
        seq_printf(seq, "ports:                   0x%02x, 0x%02x\n",
-                   (u32) ec->command_addr,
+                   (u32) ec->command_addr, (u32) ec->data_addr);
-                   (u32) ec->data_addr);
        seq_printf(seq, "use global lock:         %s\n",
                   ec->global_lock ? "yes" : "no");
-        acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
+        acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
      end:
        return 0;
@@ -605,7 +579,6 @@ static int acpi_ec_add_fs(struct acpi_device *device)
 {
        struct proc_dir_entry *entry = NULL;
        if (!acpi_device_dir(device)) {
                acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                     acpi_ec_dir);
@@ -648,18 +621,17 @@ static int acpi_ec_add(struct acpi_device *device)
        acpi_status status = AE_OK;
        struct acpi_ec *ec = NULL;
        if (!device)
                return -EINVAL;
-        ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
+        ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
        if (!ec)
                return -ENOMEM;
-        memset(ec, 0, sizeof(struct acpi_ec));
        ec->handle = device->handle;
        ec->uid = -1;
-        init_MUTEX(&ec->sem);
+        mutex_init(&ec->lock);
+        atomic_set(&ec->query_pending, 0);
        if (acpi_ec_mode == EC_INTR) {
                atomic_set(&ec->leaving_burst, 1);
                init_waitqueue_head(&ec->wait);
@@ -669,8 +641,7 @@ static int acpi_ec_add(struct acpi_device *device)
        acpi_driver_data(device) = ec;
        /* Use the global lock for all EC transactions? */
-        acpi_evaluate_integer(ec->handle, "_GLK", NULL,
+        acpi_evaluate_integer(ec->handle, "_GLK", NULL, &ec->global_lock);
-                              &ec->global_lock);
        /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
           http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
@@ -679,7 +650,7 @@ static int acpi_ec_add(struct acpi_device *device)
                                                  ACPI_ADR_SPACE_EC,
                                                  &acpi_ec_space_handler);
-                acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
+                acpi_remove_gpe_handler(NULL, ec_ecdt->gpe,
                                        &acpi_ec_gpe_handler);
                kfree(ec_ecdt);
@@ -687,11 +658,10 @@ static int acpi_ec_add(struct acpi_device *device)
        /* Get GPE bit assignment (EC events). */
        /* TODO: Add support for _GPE returning a package */
-        status =
+        status = acpi_evaluate_integer(ec->handle, "_GPE", NULL, &ec->gpe);
-            acpi_evaluate_integer(ec->handle, "_GPE", NULL,
-                                  &ec->gpe_bit);
        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit assignment"));
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Obtaining GPE bit assignment"));
                result = -ENODEV;
                goto end;
        }
@@ -701,13 +671,13 @@ static int acpi_ec_add(struct acpi_device *device)
                goto end;
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s [%s] (gpe %d) interrupt mode.",
-               acpi_device_name(device), acpi_device_bid(device),
+                          acpi_device_name(device), acpi_device_bid(device),
-               (u32) ec->gpe_bit));
+                          (u32) ec->gpe));
        if (!first_ec)
                first_ec = device;
-  end:
+      end:
        if (result)
                kfree(ec);
@@ -718,7 +688,6 @@ static int acpi_ec_remove(struct acpi_device *device, int type)
 {
        struct acpi_ec *ec = NULL;
        if (!device)
                return -EINVAL;
@@ -761,7 +730,6 @@ static int acpi_ec_start(struct acpi_device *device)
        acpi_status status = AE_OK;
        struct acpi_ec *ec = NULL;
        if (!device)
                return -EINVAL;
@@ -782,27 +750,26 @@ static int acpi_ec_start(struct acpi_device *device)
        }
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02lx, ports=0x%2lx,0x%2lx",
-                          ec->gpe_bit, ec->command_addr, ec->data_addr));
+                          ec->gpe, ec->command_addr, ec->data_addr));
        /*
         * Install GPE handler
         */
-        status = acpi_install_gpe_handler(NULL, ec->gpe_bit,
+        status = acpi_install_gpe_handler(NULL, ec->gpe,
                                          ACPI_GPE_EDGE_TRIGGERED,
                                          &acpi_ec_gpe_handler, ec);
        if (ACPI_FAILURE(status)) {
                return -ENODEV;
        }
-        acpi_set_gpe_type(NULL, ec->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
+        acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
-        acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
+        acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
        status = acpi_install_address_space_handler(ec->handle,
                                                    ACPI_ADR_SPACE_EC,
                                                    &acpi_ec_space_handler,
                                                    &acpi_ec_space_setup, ec);
        if (ACPI_FAILURE(status)) {
-                acpi_remove_gpe_handler(NULL, ec->gpe_bit,
+                acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler);
-                                        &acpi_ec_gpe_handler);
                return -ENODEV;
        }
@@ -814,7 +781,6 @@ static int acpi_ec_stop(struct acpi_device *device, int type)
        acpi_status status = AE_OK;
        struct acpi_ec *ec = NULL;
        if (!device)
                return -EINVAL;
@@ -826,9 +792,7 @@ static int acpi_ec_stop(struct acpi_device *device, int type)
        if (ACPI_FAILURE(status))
                return -ENODEV;
-        status =
+        status = acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler);
-            acpi_remove_gpe_handler(NULL, ec->gpe_bit,
-                                    &acpi_ec_gpe_handler);
        if (ACPI_FAILURE(status))
                return -ENODEV;
@@ -841,7 +805,7 @@ acpi_fake_ecdt_callback(acpi_handle handle,
 {
        acpi_status status;
-        init_MUTEX(&ec_ecdt->sem);
+        mutex_init(&ec_ecdt->lock);
        if (acpi_ec_mode == EC_INTR) {
                init_waitqueue_head(&ec_ecdt->wait);
        }
@@ -853,16 +817,15 @@ acpi_fake_ecdt_callback(acpi_handle handle,
        ec_ecdt->uid = -1;
        acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->uid);
-        status =
+        status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->gpe);
-            acpi_evaluate_integer(handle, "_GPE", NULL,
-                                  &ec_ecdt->gpe_bit);
        if (ACPI_FAILURE(status))
                return status;
        ec_ecdt->global_lock = TRUE;
        ec_ecdt->handle = handle;
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "GPE=0x%02lx, ports=0x%2lx, 0x%2lx",
-               ec_ecdt->gpe_bit, ec_ecdt->command_addr, ec_ecdt->data_addr));
+                          ec_ecdt->gpe, ec_ecdt->command_addr,
+                          ec_ecdt->data_addr));
        return AE_CTRL_TERMINATE;
 }
@@ -884,12 +847,11 @@ static int __init acpi_ec_fake_ecdt(void)
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Try to make an fake ECDT"));
-        ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
+        ec_ecdt = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
        if (!ec_ecdt) {
                ret = -ENOMEM;
                goto error;
        }
-        memset(ec_ecdt, 0, sizeof(struct acpi_ec));
        status = acpi_get_devices(ACPI_EC_HID,
                                  acpi_fake_ecdt_callback, NULL, NULL);
@@ -901,7 +863,7 @@ static int __init acpi_ec_fake_ecdt(void)
                goto error;
        }
        return 0;
-  error:
+      error:
        return ret;
 }
@@ -921,30 +883,28 @@ static int __init acpi_ec_get_real_ecdt(void)
        /*
         * Generate a temporary ec context to use until the namespace is scanned
         */
-        ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
+        ec_ecdt = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
        if (!ec_ecdt)
                return -ENOMEM;
-        memset(ec_ecdt, 0, sizeof(struct acpi_ec));
-        init_MUTEX(&ec_ecdt->sem);
+        mutex_init(&ec_ecdt->lock);
        if (acpi_ec_mode == EC_INTR) {
                init_waitqueue_head(&ec_ecdt->wait);
        }
        ec_ecdt->command_addr = ecdt_ptr->ec_control.address;
        ec_ecdt->data_addr = ecdt_ptr->ec_data.address;
-        ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit;
+        ec_ecdt->gpe = ecdt_ptr->gpe_bit;
        /* use the GL just to be safe */
        ec_ecdt->global_lock = TRUE;
        ec_ecdt->uid = ecdt_ptr->uid;
-        status =
+        status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
-            acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
        if (ACPI_FAILURE(status)) {
                goto error;
        }
        return 0;
-  error:
+      error:
        ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
        kfree(ec_ecdt);
        ec_ecdt = NULL;
@@ -970,14 +930,14 @@ int __init acpi_ec_ecdt_probe(void)
        /*
         * Install GPE handler
         */
-        status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit,
+        status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe,
                                          ACPI_GPE_EDGE_TRIGGERED,
                                          &acpi_ec_gpe_handler, ec_ecdt);
        if (ACPI_FAILURE(status)) {
                goto error;
        }
-        acpi_set_gpe_type(NULL, ec_ecdt->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
+        acpi_set_gpe_type(NULL, ec_ecdt->gpe, ACPI_GPE_TYPE_RUNTIME);
-        acpi_enable_gpe(NULL, ec_ecdt->gpe_bit, ACPI_NOT_ISR);
+        acpi_enable_gpe(NULL, ec_ecdt->gpe, ACPI_NOT_ISR);
        status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
                                                    ACPI_ADR_SPACE_EC,
@@ -985,7 +945,7 @@ int __init acpi_ec_ecdt_probe(void)
                                                    &acpi_ec_space_setup,
                                                    ec_ecdt);
        if (ACPI_FAILURE(status)) {
-                acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
+                acpi_remove_gpe_handler(NULL, ec_ecdt->gpe,
                                        &acpi_ec_gpe_handler);
                goto error;
        }
@@ -1004,7 +964,6 @@ static int __init acpi_ec_init(void)
 {
        int result = 0;
        if (acpi_disabled)
                return 0;
@@ -1057,7 +1016,8 @@ static int __init acpi_ec_set_intr_mode(char *str)
                acpi_ec_mode = EC_POLL;
        }
        acpi_ec_driver.ops.add = acpi_ec_add;
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n", intr ? "interrupt" : "polling"));
+        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n",
+                          intr ? "interrupt" : "polling"));
        return 1;
 }
diff --git a/drivers/acpi/events/evmisc.c b/drivers/acpi/events/evmisc.c
index ee2a10bf9077..bf63edc6608d 100644
--- a/drivers/acpi/events/evmisc.c
+++ b/drivers/acpi/events/evmisc.c
@@ -331,7 +331,6 @@ static void ACPI_SYSTEM_XFACE acpi_ev_global_lock_thread(void *context)
 static u32 acpi_ev_global_lock_handler(void *context)
 {
        u8 acquired = FALSE;
-        acpi_status status;
        /*
         * Attempt to get the lock
diff --git a/drivers/acpi/executer/exmutex.c b/drivers/acpi/executer/exmutex.c
index 3a39c2e8e104..bf90f04f2c60 100644
--- a/drivers/acpi/executer/exmutex.c
+++ b/drivers/acpi/executer/exmutex.c
@@ -266,10 +266,10 @@ acpi_ex_release_mutex(union acpi_operand_object *obj_desc,
             walk_state->thread->thread_id)
            && (obj_desc->mutex.os_mutex != ACPI_GLOBAL_LOCK)) {
                ACPI_ERROR((AE_INFO,
-                            "Thread %X cannot release Mutex [%4.4s] acquired by thread %X",
+                            "Thread %lX cannot release Mutex [%4.4s] acquired by thread %lX",
-                            (u32) walk_state->thread->thread_id,
+                            (unsigned long)walk_state->thread->thread_id,
                            acpi_ut_get_node_name(obj_desc->mutex.node),
-                            (u32) obj_desc->mutex.owner_thread->thread_id));
+                            (unsigned long)obj_desc->mutex.owner_thread->thread_id));
                return_ACPI_STATUS(AE_AML_NOT_OWNER);
        }
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 045c89477e59..f305a826ca2d 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -99,8 +99,8 @@ acpi_fan_write_state(struct file *file, const char __user * buffer,
                     size_t count, loff_t * ppos)
 {
        int result = 0;
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_fan *fan = (struct acpi_fan *)m->private;
+        struct acpi_fan *fan = m->private;
        char state_string[12] = { '\0' };
@@ -186,10 +186,9 @@ static int acpi_fan_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        fan = kmalloc(sizeof(struct acpi_fan), GFP_KERNEL);
+        fan = kzalloc(sizeof(struct acpi_fan), GFP_KERNEL);
        if (!fan)
                return -ENOMEM;
-        memset(fan, 0, sizeof(struct acpi_fan));
        fan->device = device;
        strcpy(acpi_device_name(device), "Fan");
@@ -229,7 +228,7 @@ static int acpi_fan_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        fan = (struct acpi_fan *)acpi_driver_data(device);
+        fan = acpi_driver_data(device);
        acpi_fan_remove_fs(device);
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index a2f46d587d55..8a0324b43e53 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -96,7 +96,7 @@ struct acpi_find_pci_root {
 static acpi_status
 do_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
 {
-        unsigned long *busnr = (unsigned long *)data;
+        unsigned long *busnr = data;
        struct acpi_resource_address64 address;
        if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
@@ -189,8 +189,12 @@ find_pci_rootbridge(acpi_handle handle, u32 lvl, void *context, void **rv)
        bus = tmp;
        if (seg == find->seg && bus == find->bus)
+        {
                find->handle = handle;
-        status = AE_OK;
+                status = AE_CTRL_TERMINATE;
+        }
+        else
+                status = AE_OK;
      exit:
        kfree(buffer.pointer);
        return status;
@@ -217,7 +221,7 @@ do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
        acpi_status status;
        struct acpi_device_info *info;
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        struct acpi_find_child *find = (struct acpi_find_child *)context;
+        struct acpi_find_child *find = context;
        status = acpi_get_object_info(handle, &buffer);
        if (ACPI_SUCCESS(status)) {
diff --git a/drivers/acpi/hotkey.c b/drivers/acpi/hotkey.c
index 1ba2db671865..8edfb92f7ede 100644
--- a/drivers/acpi/hotkey.c
+++ b/drivers/acpi/hotkey.c
@@ -265,8 +265,7 @@ static char *format_result(union acpi_object *object)
 static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_polling_hotkey *poll_hotkey =
+        struct acpi_polling_hotkey *poll_hotkey = seq->private;
-            (struct acpi_polling_hotkey *)seq->private;
        char *buf;
@@ -577,7 +576,7 @@ init_poll_hotkey_device(union acpi_hotkey *key, char **config_entry,
        if (ACPI_FAILURE(status))
                goto do_fail_zero;
        key->poll_hotkey.poll_result =
-            (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL);
+            kmalloc(sizeof(union acpi_object), GFP_KERNEL);
        if (!key->poll_hotkey.poll_result)
                goto do_fail_zero;
        return AE_OK;
diff --git a/drivers/acpi/i2c_ec.c b/drivers/acpi/i2c_ec.c
index 6342e612c203..8338be0990bc 100644
--- a/drivers/acpi/i2c_ec.c
+++ b/drivers/acpi/i2c_ec.c
@@ -309,18 +309,16 @@ static int acpi_ec_hc_add(struct acpi_device *device)
                return -EINVAL;
        }
-        ec_hc = kmalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL);
+        ec_hc = kzalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL);
        if (!ec_hc) {
                return -ENOMEM;
        }
-        memset(ec_hc, 0, sizeof(struct acpi_ec_hc));
-        smbus = kmalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL);
+        smbus = kzalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL);
        if (!smbus) {
                kfree(ec_hc);
                return -ENOMEM;
        }
-        memset(smbus, 0, sizeof(struct acpi_ec_smbus));
        ec_hc->handle = device->handle;
        strcpy(acpi_device_name(device), ACPI_EC_HC_DEVICE_NAME);
@@ -393,7 +391,7 @@ static void __exit acpi_ec_hc_exit(void)
 struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device)
 {
-        return ((struct acpi_ec_hc *)acpi_driver_data(device->parent));
+        return acpi_driver_data(device->parent);
 }
 EXPORT_SYMBOL(acpi_get_ec_hc);
diff --git a/drivers/acpi/ibm_acpi.c b/drivers/acpi/ibm_acpi.c
index 5a8445959f67..b72d13d11a27 100644
--- a/drivers/acpi/ibm_acpi.c
+++ b/drivers/acpi/ibm_acpi.c
@@ -3,6 +3,7 @@
 *
 *
 *  Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
+ *  Copyright (C) 2006 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
@@ -19,10 +20,14 @@
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
-#define IBM_VERSION "0.12a"
+#define IBM_VERSION "0.13"
 /*
 *  Changelog:
+ *
+ *  2006-11-22  0.13    new maintainer
+ *                      changelog now lives in git commit history, and will
+ *                      not be updated further in-file.
 *  
 *  2005-08-17  0.12    fix compilation on 2.6.13-rc kernels
 *  2005-03-17  0.11    support for 600e, 770x
@@ -77,9 +82,16 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/types.h>
+#include <linux/string.h>
 #include <linux/proc_fs.h>
+#include <linux/backlight.h>
 #include <asm/uaccess.h>
+#include <linux/dmi.h>
+#include <linux/jiffies.h>
+#include <linux/workqueue.h>
 #include <acpi/acpi_drivers.h>
 #include <acpi/acnamesp.h>
@@ -88,7 +100,7 @@
 #define IBM_FILE "ibm_acpi"
 #define IBM_URL "http://ibm-acpi.sf.net/"
-MODULE_AUTHOR("Borislav Deianov");
+MODULE_AUTHOR("Borislav Deianov, Henrique de Moraes Holschuh");
 MODULE_DESCRIPTION(IBM_DESC);
 MODULE_VERSION(IBM_VERSION);
 MODULE_LICENSE("GPL");
@@ -116,28 +128,6 @@ static acpi_handle root_handle = NULL;
        static char        *object##_path;                      \
        static char        *object##_paths[] = { paths }
-/*
- * The following models are supported to various degrees:
- *
- * 570, 600e, 600x, 770e, 770x
- * A20m, A21e, A21m, A21p, A22p, A30, A30p, A31, A31p
- * G40, G41
- * R30, R31, R32, R40, R40e, R50, R50e, R50p, R51
- * T20, T21, T22, T23, T30, T40, T40p, T41, T41p, T42, T42p, T43
- * X20, X21, X22, X23, X24, X30, X31, X40
- *
- * The following models have no supported features:
- *
- * 240, 240x, i1400
- *
- * Still missing DSDTs for the following models:
- *
- * A20p, A22e, A22m
- * R52
- * S31
- * T43p
- */
 IBM_HANDLE(ec, root, "\\_SB.PCI0.ISA.EC0",      /* 240, 240x */
           "\\_SB.PCI.ISA.EC",  /* 570 */
           "\\_SB.PCI0.ISA0.EC0",       /* 600e/x, 770e, 770x */
@@ -167,8 +157,10 @@ IBM_HANDLE(dock, root, "\\_SB.GDCK",	/* X30, X31, X40 */
           "\\_SB.PCI.ISA.SLCE",        /* 570 */
    );                          /* A21e,G4x,R30,R31,R32,R40,R40e,R50e */
 #endif
+#ifdef CONFIG_ACPI_IBM_BAY
 IBM_HANDLE(bay, root, "\\_SB.PCI.IDE.SECN.MAST",        /* 570 */
           "\\_SB.PCI0.IDE0.IDES.IDSM", /* 600e/x, 770e, 770x */
+           "\\_SB.PCI0.SATA.SCND.MSTR", /* T60, X60, Z60 */ 
           "\\_SB.PCI0.IDE0.SCND.MSTR", /* all others */
    );                          /* A21e, R30, R31 */
@@ -183,6 +175,7 @@ IBM_HANDLE(bay2, root, "\\_SB.PCI0.IDE0.PRIM.SLAV",	/* A3x, R32 */
 IBM_HANDLE(bay2_ej, bay2, "_EJ3",       /* 600e/x, 770e, A3x */
           "_EJ0",              /* 770x */
    );                          /* all others */
+#endif
 /* don't list other alternatives as we install a notify handler on the 570 */
 IBM_HANDLE(pci, root, "\\_SB.PCI");     /* 570 */
@@ -203,7 +196,7 @@ IBM_HANDLE(led, ec, "SLED",	/* 570 */
 IBM_HANDLE(beep, ec, "BEEP");   /* all except R30, R31 */
 IBM_HANDLE(ecrd, ec, "ECRD");   /* 570 */
 IBM_HANDLE(ecwr, ec, "ECWR");   /* 570 */
-IBM_HANDLE(fans, ec, "FANS");   /* X31, X40 */
+IBM_HANDLE(fans, ec, "FANS");   /* X31, X40, X41 */
 IBM_HANDLE(gfan, ec, "GFAN",    /* 570 */
           "\\FSPD",            /* 600e/x, 770e, 770x */
@@ -216,6 +209,152 @@ IBM_HANDLE(sfan, ec, "SFAN",	/* 570 */
 #define IBM_HKEY_HID    "IBM0068"
 #define IBM_PCI_HID     "PNP0A03"
+enum thermal_access_mode {
+        IBMACPI_THERMAL_NONE = 0,       /* No thermal support */
+        IBMACPI_THERMAL_ACPI_TMP07,     /* Use ACPI TMP0-7 */
+        IBMACPI_THERMAL_ACPI_UPDT,      /* Use ACPI TMP0-7 with UPDT */
+        IBMACPI_THERMAL_TPEC_8,         /* Use ACPI EC regs, 8 sensors */
+        IBMACPI_THERMAL_TPEC_16,        /* Use ACPI EC regs, 16 sensors */
+};
+#define IBMACPI_MAX_THERMAL_SENSORS 16  /* Max thermal sensors supported */
+struct ibm_thermal_sensors_struct {
+        s32 temp[IBMACPI_MAX_THERMAL_SENSORS];
+};
+/*
+ * FAN ACCESS MODES
+ *
+ * IBMACPI_FAN_RD_ACPI_GFAN:
+ *      ACPI GFAN method: returns fan level
+ *
+ *      see IBMACPI_FAN_WR_ACPI_SFAN
+ *      EC 0x2f not available if GFAN exists
+ *
+ * IBMACPI_FAN_WR_ACPI_SFAN:
+ *      ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
+ *
+ *      EC 0x2f might be available *for reading*, but never for writing.
+ *
+ * IBMACPI_FAN_WR_TPEC:
+ *      ThinkPad EC register 0x2f (HFSP): fan control loop mode Supported
+ *      on almost all ThinkPads
+ *
+ *      Fan speed changes of any sort (including those caused by the
+ *      disengaged mode) are usually done slowly by the firmware as the
+ *      maximum ammount of fan duty cycle change per second seems to be
+ *      limited.
+ *
+ *      Reading is not available if GFAN exists.
+ *      Writing is not available if SFAN exists.
+ *
+ *      Bits
+ *       7      automatic mode engaged;
+ *              (default operation mode of the ThinkPad)
+ *              fan level is ignored in this mode.
+ *       6      disengage mode (takes precedence over bit 7);
+ *              not available on all thinkpads.  May disable
+ *              the tachometer, and speeds up fan to 100% duty-cycle,
+ *              which speeds it up far above the standard RPM
+ *              levels.  It is not impossible that it could cause
+ *              hardware damage.
+ *      5-3     unused in some models.  Extra bits for fan level
+ *              in others, but still useless as all values above
+ *              7 map to the same speed as level 7 in these models.
+ *      2-0     fan level (0..7 usually)
+ *                      0x00 = stop
+ *                      0x07 = max (set when temperatures critical)
+ *              Some ThinkPads may have other levels, see
+ *              IBMACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
+ *
+ *      FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
+ *      boot. Apparently the EC does not intialize it, so unless ACPI DSDT
+ *      does so, its initial value is meaningless (0x07).
+ *
+ *      For firmware bugs, refer to:
+ *      http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
+ *
+ *      ----
+ *
+ *      ThinkPad EC register 0x84 (LSB), 0x85 (MSB):
+ *      Main fan tachometer reading (in RPM)
+ *
+ *      This register is present on all ThinkPads with a new-style EC, and
+ *      it is known not to be present on the A21m/e, and T22, as there is
+ *      something else in offset 0x84 according to the ACPI DSDT.  Other
+ *      ThinkPads from this same time period (and earlier) probably lack the
+ *      tachometer as well.
+ *
+ *      Unfortunately a lot of ThinkPads with new-style ECs but whose firwmare
+ *      was never fixed by IBM to report the EC firmware version string
+ *      probably support the tachometer (like the early X models), so
+ *      detecting it is quite hard.  We need more data to know for sure.
+ *
+ *      FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings
+ *      might result.
+ *
+ *      FIRMWARE BUG: when EC 0x2f bit 6 is set (disengaged mode), this
+ *      register is not invalidated in ThinkPads that disable tachometer
+ *      readings.  Thus, the tachometer readings go stale.
+ *
+ *      For firmware bugs, refer to:
+ *      http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
+ *
+ * IBMACPI_FAN_WR_ACPI_FANS:
+ *      ThinkPad X31, X40, X41.  Not available in the X60.
+ *
+ *      FANS ACPI handle: takes three arguments: low speed, medium speed,
+ *      high speed.  ACPI DSDT seems to map these three speeds to levels
+ *      as follows: STOP LOW LOW MED MED HIGH HIGH HIGH HIGH
+ *      (this map is stored on FAN0..FAN8 as "0,1,1,2,2,3,3,3,3")
+ *
+ *      The speeds are stored on handles
+ *      (FANA:FAN9), (FANC:FANB), (FANE:FAND).
+ *
+ *      There are three default speed sets, acessible as handles:
+ *      FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
+ *
+ *      ACPI DSDT switches which set is in use depending on various
+ *      factors.
+ *
+ *      IBMACPI_FAN_WR_TPEC is also available and should be used to
+ *      command the fan.  The X31/X40/X41 seems to have 8 fan levels,
+ *      but the ACPI tables just mention level 7.
+ */
+enum fan_status_access_mode {
+        IBMACPI_FAN_NONE = 0,           /* No fan status or control */
+        IBMACPI_FAN_RD_ACPI_GFAN,       /* Use ACPI GFAN */
+        IBMACPI_FAN_RD_TPEC,            /* Use ACPI EC regs 0x2f, 0x84-0x85 */
+};
+enum fan_control_access_mode {
+        IBMACPI_FAN_WR_NONE = 0,        /* No fan control */
+        IBMACPI_FAN_WR_ACPI_SFAN,       /* Use ACPI SFAN */
+        IBMACPI_FAN_WR_TPEC,            /* Use ACPI EC reg 0x2f */
+        IBMACPI_FAN_WR_ACPI_FANS,       /* Use ACPI FANS and EC reg 0x2f */
+};
+enum fan_control_commands {
+        IBMACPI_FAN_CMD_SPEED   = 0x0001,       /* speed command */
+        IBMACPI_FAN_CMD_LEVEL   = 0x0002,       /* level command  */
+        IBMACPI_FAN_CMD_ENABLE  = 0x0004,       /* enable/disable cmd,
+                                                 * and also watchdog cmd */
+};
+enum {                                  /* Fan control constants */
+        fan_status_offset = 0x2f,       /* EC register 0x2f */
+        fan_rpm_offset = 0x84,          /* EC register 0x84: LSB, 0x85 MSB (RPM)
+                                         * 0x84 must be read before 0x85 */
+        IBMACPI_FAN_EC_DISENGAGED       = 0x40, /* EC mode: tachometer
+                                                 * disengaged */
+        IBMACPI_FAN_EC_AUTO             = 0x80, /* EC mode: auto fan
+                                                 * control */
+};
+static char *ibm_thinkpad_ec_found = NULL;
 struct ibm_struct {
        char *name;
        char param[32];
@@ -243,6 +382,8 @@ struct ibm_struct {
 static struct proc_dir_entry *proc_dir = NULL;
+static struct backlight_device *ibm_backlight_device = NULL;
 #define onoff(status,bit) ((status) & (1 << (bit)) ? "on" : "off")
 #define enabled(status,bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
 #define strlencmp(a,b) (strncmp((a), (b), strlen(b)))
@@ -581,8 +722,7 @@ static int wan_status(void)
 {
        int status;
-        if (!wan_supported ||
+        if (!wan_supported || !acpi_evalf(hkey_handle, &status, "GWAN", "d"))
-            !acpi_evalf(hkey_handle, &status, "GWAN", "d"))
                status = 0;
        return status;
@@ -630,12 +770,15 @@ static int wan_write(char *buf)
        return 0;
 }
-static int video_supported;
+enum video_access_mode {
-static int video_orig_autosw;
+        IBMACPI_VIDEO_NONE = 0,
+        IBMACPI_VIDEO_570,      /* 570 */
+        IBMACPI_VIDEO_770,      /* 600e/x, 770e, 770x */
+        IBMACPI_VIDEO_NEW,      /* all others */
+};
-#define VIDEO_570 1
+static enum video_access_mode video_supported;
-#define VIDEO_770 2
+static int video_orig_autosw;
-#define VIDEO_NEW 3
 static int video_init(void)
 {
@@ -647,16 +790,16 @@ static int video_init(void)
        if (!vid_handle)
                /* video switching not supported on R30, R31 */
-                video_supported = 0;
+                video_supported = IBMACPI_VIDEO_NONE;
        else if (acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
                /* 570 */
-                video_supported = VIDEO_570;
+                video_supported = IBMACPI_VIDEO_570;
        else if (acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
                /* 600e/x, 770e, 770x */
-                video_supported = VIDEO_770;
+                video_supported = IBMACPI_VIDEO_770;
        else
                /* all others */
-                video_supported = VIDEO_NEW;
+                video_supported = IBMACPI_VIDEO_NEW;
        return 0;
 }
@@ -666,15 +809,15 @@ static int video_status(void)
        int status = 0;
        int i;
-        if (video_supported == VIDEO_570) {
+        if (video_supported == IBMACPI_VIDEO_570) {
                if (acpi_evalf(NULL, &i, "\\_SB.PHS", "dd", 0x87))
                        status = i & 3;
-        } else if (video_supported == VIDEO_770) {
+        } else if (video_supported == IBMACPI_VIDEO_770) {
                if (acpi_evalf(NULL, &i, "\\VCDL", "d"))
                        status |= 0x01 * i;
                if (acpi_evalf(NULL, &i, "\\VCDC", "d"))
                        status |= 0x02 * i;
-        } else if (video_supported == VIDEO_NEW) {
+        } else if (video_supported == IBMACPI_VIDEO_NEW) {
                acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1);
                if (acpi_evalf(NULL, &i, "\\VCDC", "d"))
                        status |= 0x02 * i;
@@ -693,9 +836,10 @@ static int video_autosw(void)
 {
        int autosw = 0;
-        if (video_supported == VIDEO_570)
+        if (video_supported == IBMACPI_VIDEO_570)
                acpi_evalf(vid_handle, &autosw, "SWIT", "d");
-        else if (video_supported == VIDEO_770 || video_supported == VIDEO_NEW)
+        else if (video_supported == IBMACPI_VIDEO_770 ||
+                 video_supported == IBMACPI_VIDEO_NEW)
                acpi_evalf(vid_handle, &autosw, "^VDEE", "d");
        return autosw & 1;
@@ -715,12 +859,12 @@ static int video_read(char *p)
        len += sprintf(p + len, "status:\t\tsupported\n");
        len += sprintf(p + len, "lcd:\t\t%s\n", enabled(status, 0));
        len += sprintf(p + len, "crt:\t\t%s\n", enabled(status, 1));
-        if (video_supported == VIDEO_NEW)
+        if (video_supported == IBMACPI_VIDEO_NEW)
                len += sprintf(p + len, "dvi:\t\t%s\n", enabled(status, 3));
        len += sprintf(p + len, "auto:\t\t%s\n", enabled(autosw, 0));
        len += sprintf(p + len, "commands:\tlcd_enable, lcd_disable\n");
        len += sprintf(p + len, "commands:\tcrt_enable, crt_disable\n");
-        if (video_supported == VIDEO_NEW)
+        if (video_supported == IBMACPI_VIDEO_NEW)
                len += sprintf(p + len, "commands:\tdvi_enable, dvi_disable\n");
        len += sprintf(p + len, "commands:\tauto_enable, auto_disable\n");
        len += sprintf(p + len, "commands:\tvideo_switch, expand_toggle\n");
@@ -735,7 +879,7 @@ static int video_switch(void)
        if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", 1))
                return -EIO;
-        ret = video_supported == VIDEO_570 ?
+        ret = video_supported == IBMACPI_VIDEO_570 ?
            acpi_evalf(ec_handle, NULL, "_Q16", "v") :
            acpi_evalf(vid_handle, NULL, "VSWT", "v");
        acpi_evalf(vid_handle, NULL, "_DOS", "vd", autosw);
@@ -745,9 +889,9 @@ static int video_switch(void)
 static int video_expand(void)
 {
-        if (video_supported == VIDEO_570)
+        if (video_supported == IBMACPI_VIDEO_570)
                return acpi_evalf(ec_handle, NULL, "_Q17", "v");
-        else if (video_supported == VIDEO_770)
+        else if (video_supported == IBMACPI_VIDEO_770)
                return acpi_evalf(vid_handle, NULL, "VEXP", "v");
        else
                return acpi_evalf(NULL, NULL, "\\VEXP", "v");
@@ -757,10 +901,10 @@ static int video_switch2(int status)
 {
        int ret;
-        if (video_supported == VIDEO_570) {
+        if (video_supported == IBMACPI_VIDEO_570) {
                ret = acpi_evalf(NULL, NULL,
                                 "\\_SB.PHS2", "vdd", 0x8b, status | 0x80);
-        } else if (video_supported == VIDEO_770) {
+        } else if (video_supported == IBMACPI_VIDEO_770) {
                int autosw = video_autosw();
                if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", 1))
                        return -EIO;
@@ -796,10 +940,10 @@ static int video_write(char *buf)
                        enable |= 0x02;
                } else if (strlencmp(cmd, "crt_disable") == 0) {
                        disable |= 0x02;
-                } else if (video_supported == VIDEO_NEW &&
+                } else if (video_supported == IBMACPI_VIDEO_NEW &&
                           strlencmp(cmd, "dvi_enable") == 0) {
                        enable |= 0x08;
-                } else if (video_supported == VIDEO_NEW &&
+                } else if (video_supported == IBMACPI_VIDEO_NEW &&
                           strlencmp(cmd, "dvi_disable") == 0) {
                        disable |= 0x08;
                } else if (strlencmp(cmd, "auto_enable") == 0) {
@@ -898,6 +1042,7 @@ static int light_write(char *buf)
        return 0;
 }
+#if defined(CONFIG_ACPI_IBM_DOCK) || defined(CONFIG_ACPI_IBM_BAY)
 static int _sta(acpi_handle handle)
 {
        int status;
@@ -907,6 +1052,7 @@ static int _sta(acpi_handle handle)
        return status;
 }
+#endif
 #ifdef CONFIG_ACPI_IBM_DOCK
 #define dock_docked() (_sta(dock_handle) & 1)
@@ -972,6 +1118,7 @@ static void dock_notify(struct ibm_struct *ibm, u32 event)
 }
 #endif
+#ifdef CONFIG_ACPI_IBM_BAY
 static int bay_status_supported;
 static int bay_status2_supported;
 static int bay_eject_supported;
@@ -1047,6 +1194,7 @@ static void bay_notify(struct ibm_struct *ibm, u32 event)
 {
        acpi_bus_generate_event(ibm->device, event, 0);
 }
+#endif
 static int cmos_read(char *p)
 {
@@ -1094,26 +1242,28 @@ static int cmos_write(char *buf)
        return 0;
 }
-static int led_supported;
+enum led_access_mode {
+        IBMACPI_LED_NONE = 0,
-#define LED_570 1
+        IBMACPI_LED_570,        /* 570 */
-#define LED_OLD 2
+        IBMACPI_LED_OLD,        /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
-#define LED_NEW 3
+        IBMACPI_LED_NEW,        /* all others */
+};
+static enum led_access_mode led_supported;
 static int led_init(void)
 {
        if (!led_handle)
                /* led not supported on R30, R31 */
-                led_supported = 0;
+                led_supported = IBMACPI_LED_NONE;
        else if (strlencmp(led_path, "SLED") == 0)
                /* 570 */
-                led_supported = LED_570;
+                led_supported = IBMACPI_LED_570;
        else if (strlencmp(led_path, "SYSL") == 0)
                /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
-                led_supported = LED_OLD;
+                led_supported = IBMACPI_LED_OLD;
        else
                /* all others */
-                led_supported = LED_NEW;
+                led_supported = IBMACPI_LED_NEW;
        return 0;
 }
@@ -1130,7 +1280,7 @@ static int led_read(char *p)
        }
        len += sprintf(p + len, "status:\t\tsupported\n");
-        if (led_supported == LED_570) {
+        if (led_supported == IBMACPI_LED_570) {
                /* 570 */
                int i, status;
                for (i = 0; i < 8; i++) {
@@ -1179,13 +1329,13 @@ static int led_write(char *buf)
                } else
                        return -EINVAL;
-                if (led_supported == LED_570) {
+                if (led_supported == IBMACPI_LED_570) {
                        /* 570 */
                        led = 1 << led;
                        if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
                                        led, led_sled_arg1[ind]))
                                return -EIO;
-                } else if (led_supported == LED_OLD) {
+                } else if (led_supported == IBMACPI_LED_OLD) {
                        /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
                        led = 1 << led;
                        ret = ec_write(EC_HLMS, led);
@@ -1272,50 +1422,142 @@ static int acpi_ec_write(int i, u8 v)
        return 1;
 }
-static int thermal_tmp_supported;
+static enum thermal_access_mode thermal_read_mode;
-static int thermal_updt_supported;
 static int thermal_init(void)
 {
-        /* temperatures not supported on 570, G4x, R30, R31, R32 */
+        u8 t, ta1, ta2;
-        thermal_tmp_supported = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
+        int i;
+        int acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
+        if (ibm_thinkpad_ec_found && experimental) {
+                /*
+                 * Direct EC access mode: sensors at registers
+                 * 0x78-0x7F, 0xC0-0xC7.  Registers return 0x00 for
+                 * non-implemented, thermal sensors return 0x80 when
+                 * not available
+                 */
-        /* 600e/x, 770e, 770x */
+                ta1 = ta2 = 0;
-        thermal_updt_supported = acpi_evalf(ec_handle, NULL, "UPDT", "qv");
+                for (i = 0; i < 8; i++) {
+                        if (likely(acpi_ec_read(0x78 + i, &t))) {
+                                ta1 |= t;
+                        } else {
+                                ta1 = 0;
+                                break;
+                        }
+                        if (likely(acpi_ec_read(0xC0 + i, &t))) {
+                                ta2 |= t;
+                        } else {
+                                ta1 = 0;
+                                break;
+                        }
+                }
+                if (ta1 == 0) {
+                        /* This is sheer paranoia, but we handle it anyway */
+                        if (acpi_tmp7) {
+                                printk(IBM_ERR
+                                       "ThinkPad ACPI EC access misbehaving, "
+                                       "falling back to ACPI TMPx access mode\n");
+                                thermal_read_mode = IBMACPI_THERMAL_ACPI_TMP07;
+                        } else {
+                                printk(IBM_ERR
+                                       "ThinkPad ACPI EC access misbehaving, "
+                                       "disabling thermal sensors access\n");
+                                thermal_read_mode = IBMACPI_THERMAL_NONE;
+                        }
+                } else {
+                        thermal_read_mode =
+                            (ta2 != 0) ?
+                            IBMACPI_THERMAL_TPEC_16 : IBMACPI_THERMAL_TPEC_8;
+                }
+        } else if (acpi_tmp7) {
+                if (acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
+                        /* 600e/x, 770e, 770x */
+                        thermal_read_mode = IBMACPI_THERMAL_ACPI_UPDT;
+                } else {
+                        /* Standard ACPI TMPx access, max 8 sensors */
+                        thermal_read_mode = IBMACPI_THERMAL_ACPI_TMP07;
+                }
+        } else {
+                /* temperatures not supported on 570, G4x, R30, R31, R32 */
+                thermal_read_mode = IBMACPI_THERMAL_NONE;
+        }
        return 0;
 }
-static int thermal_read(char *p)
+static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
 {
-        int len = 0;
+        int i, t;
+        s8 tmp;
+        char tmpi[] = "TMPi";
-        if (!thermal_tmp_supported)
+        if (!s)
-                len += sprintf(p + len, "temperatures:\tnot supported\n");
+                return -EINVAL;
-        else {
-                int i, t;
-                char tmpi[] = "TMPi";
-                s8 tmp[8];
-                if (thermal_updt_supported)
+        switch (thermal_read_mode) {
-                        if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
+#if IBMACPI_MAX_THERMAL_SENSORS >= 16
+        case IBMACPI_THERMAL_TPEC_16:
+                for (i = 0; i < 8; i++) {
+                        if (!acpi_ec_read(0xC0 + i, &tmp))
+                                return -EIO;
+                        s->temp[i + 8] = tmp * 1000;
+                }
+                /* fallthrough */
+#endif
+        case IBMACPI_THERMAL_TPEC_8:
+                for (i = 0; i < 8; i++) {
+                        if (!acpi_ec_read(0x78 + i, &tmp))
                                return -EIO;
+                        s->temp[i] = tmp * 1000;
+                }
+                return (thermal_read_mode == IBMACPI_THERMAL_TPEC_16) ? 16 : 8;
+        case IBMACPI_THERMAL_ACPI_UPDT:
+                if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
+                        return -EIO;
                for (i = 0; i < 8; i++) {
                        tmpi[3] = '0' + i;
                        if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
                                return -EIO;
-                        if (thermal_updt_supported)
+                        s->temp[i] = (t - 2732) * 100;
-                                tmp[i] = (t - 2732 + 5) / 10;
-                        else
-                                tmp[i] = t;
                }
+                return 8;
-                len += sprintf(p + len,
+        case IBMACPI_THERMAL_ACPI_TMP07:
-                               "temperatures:\t%d %d %d %d %d %d %d %d\n",
+                for (i = 0; i < 8; i++) {
-                               tmp[0], tmp[1], tmp[2], tmp[3],
+                        tmpi[3] = '0' + i;
-                               tmp[4], tmp[5], tmp[6], tmp[7]);
+                        if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
+                                return -EIO;
+                        s->temp[i] = t * 1000;
+                }
+                return 8;
+        case IBMACPI_THERMAL_NONE:
+        default:
+                return 0;
        }
+}
+static int thermal_read(char *p)
+{
+        int len = 0;
+        int n, i;
+        struct ibm_thermal_sensors_struct t;
+        n = thermal_get_sensors(&t);
+        if (unlikely(n < 0))
+                return n;
+        len += sprintf(p + len, "temperatures:\t");
+        if (n > 0) {
+                for (i = 0; i < (n - 1); i++)
+                        len += sprintf(p + len, "%d ", t.temp[i] / 1000);
+                len += sprintf(p + len, "%d\n", t.temp[i] / 1000);
+        } else
+                len += sprintf(p + len, "not supported\n");
        return len;
 }
@@ -1381,12 +1623,23 @@ static int ecdump_write(char *buf)
 static int brightness_offset = 0x31;
+static int brightness_get(struct backlight_device *bd)
+{
+        u8 level;
+        if (!acpi_ec_read(brightness_offset, &level))
+                return -EIO;
+        level &= 0x7;
+        return level;
+}
 static int brightness_read(char *p)
 {
        int len = 0;
-        u8 level;
+        int level;
-        if (!acpi_ec_read(brightness_offset, &level)) {
+        if ((level = brightness_get(NULL)) < 0) {
                len += sprintf(p + len, "level:\t\tunreadable\n");
        } else {
                len += sprintf(p + len, "level:\t\t%d\n", level & 0x7);
@@ -1401,16 +1654,34 @@ static int brightness_read(char *p)
 #define BRIGHTNESS_UP   4
 #define BRIGHTNESS_DOWN 5
-static int brightness_write(char *buf)
+static int brightness_set(int value)
 {
        int cmos_cmd, inc, i;
-        u8 level;
+        int current_value = brightness_get(NULL);
+        value &= 7;
+        cmos_cmd = value > current_value ? BRIGHTNESS_UP : BRIGHTNESS_DOWN;
+        inc = value > current_value ? 1 : -1;
+        for (i = current_value; i != value; i += inc) {
+                if (!cmos_eval(cmos_cmd))
+                        return -EIO;
+                if (!acpi_ec_write(brightness_offset, i + inc))
+                        return -EIO;
+        }
+        return 0;
+}
+static int brightness_write(char *buf)
+{
+        int level;
        int new_level;
        char *cmd;
        while ((cmd = next_cmd(&buf))) {
-                if (!acpi_ec_read(brightness_offset, &level))
+                if ((level = brightness_get(NULL)) < 0)
-                        return -EIO;
+                        return level;
                level &= 7;
                if (strlencmp(cmd, "up") == 0) {
@@ -1423,19 +1694,44 @@ static int brightness_write(char *buf)
                } else
                        return -EINVAL;
-                cmos_cmd = new_level > level ? BRIGHTNESS_UP : BRIGHTNESS_DOWN;
+                brightness_set(new_level);
-                inc = new_level > level ? 1 : -1;
-                for (i = level; i != new_level; i += inc) {
-                        if (!cmos_eval(cmos_cmd))
-                                return -EIO;
-                        if (!acpi_ec_write(brightness_offset, i + inc))
-                                return -EIO;
-                }
        }
        return 0;
 }
+static int brightness_update_status(struct backlight_device *bd)
+{
+        return brightness_set(bd->props->brightness);
+}
+static struct backlight_properties ibm_backlight_data = {
+        .owner          = THIS_MODULE,
+        .get_brightness = brightness_get,
+        .update_status  = brightness_update_status,
+        .max_brightness = 7,
+};
+static int brightness_init(void)
+{
+        ibm_backlight_device = backlight_device_register("ibm", NULL, NULL,
+                                                         &ibm_backlight_data);
+        if (IS_ERR(ibm_backlight_device)) {
+                printk(IBM_ERR "Could not register backlight device\n");
+                return PTR_ERR(ibm_backlight_device);
+        }
+        return 0;
+}
+static void brightness_exit(void)
+{
+        if (ibm_backlight_device) {
+                backlight_device_unregister(ibm_backlight_device);
+                ibm_backlight_device = NULL;
+        }
+}
 static int volume_offset = 0x30;
 static int volume_read(char *p)
@@ -1522,86 +1818,482 @@ static int volume_write(char *buf)
        return 0;
 }
-static int fan_status_offset = 0x2f;
+static enum fan_status_access_mode fan_status_access_mode;
-static int fan_rpm_offset = 0x84;
+static enum fan_control_access_mode fan_control_access_mode;
+static enum fan_control_commands fan_control_commands;
-static int fan_read(char *p)
+static int fan_control_status_known;
+static u8 fan_control_initial_status;
+static void fan_watchdog_fire(struct work_struct *ignored);
+static int fan_watchdog_maxinterval;
+static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire);
+static int fan_init(void)
 {
-        int len = 0;
+        fan_status_access_mode = IBMACPI_FAN_NONE;
-        int s;
+        fan_control_access_mode = IBMACPI_FAN_WR_NONE;
-        u8 lo, hi, status;
+        fan_control_commands = 0;
+        fan_control_status_known = 1;
+        fan_watchdog_maxinterval = 0;
        if (gfan_handle) {
                /* 570, 600e/x, 770e, 770x */
-                if (!acpi_evalf(gfan_handle, &s, NULL, "d"))
+                fan_status_access_mode = IBMACPI_FAN_RD_ACPI_GFAN;
-                        return -EIO;
+        } else {
+                /* all other ThinkPads: note that even old-style
+                 * ThinkPad ECs supports the fan control register */
+                if (likely(acpi_ec_read(fan_status_offset,
+                                        &fan_control_initial_status))) {
+                        fan_status_access_mode = IBMACPI_FAN_RD_TPEC;
+                        /* In some ThinkPads, neither the EC nor the ACPI
+                         * DSDT initialize the fan status, and it ends up
+                         * being set to 0x07 when it *could* be either
+                         * 0x07 or 0x80.
+                         *
+                         * Enable for TP-1Y (T43), TP-78 (R51e),
+                         * TP-76 (R52), TP-70 (T43, R52), which are known
+                         * to be buggy. */
+                        if (fan_control_initial_status == 0x07 &&
+                            ibm_thinkpad_ec_found &&
+                            ((ibm_thinkpad_ec_found[0] == '1' &&
+                              ibm_thinkpad_ec_found[1] == 'Y') ||
+                             (ibm_thinkpad_ec_found[0] == '7' &&
+                              (ibm_thinkpad_ec_found[1] == '6' ||
+                               ibm_thinkpad_ec_found[1] == '8' ||
+                               ibm_thinkpad_ec_found[1] == '0'))
+                            )) {
+                                printk(IBM_NOTICE
+                                       "fan_init: initial fan status is "
+                                       "unknown, assuming it is in auto "
+                                       "mode\n");
+                                fan_control_status_known = 0;
+                        }
+                } else {
+                        printk(IBM_ERR
+                               "ThinkPad ACPI EC access misbehaving, "
+                               "fan status and control unavailable\n");
+                        return 0;
+                }
+        }
-                len += sprintf(p + len, "level:\t\t%d\n", s);
+        if (sfan_handle) {
+                /* 570, 770x-JL */
+                fan_control_access_mode = IBMACPI_FAN_WR_ACPI_SFAN;
+                fan_control_commands |=
+                    IBMACPI_FAN_CMD_LEVEL | IBMACPI_FAN_CMD_ENABLE;
        } else {
+                if (!gfan_handle) {
+                        /* gfan without sfan means no fan control */
+                        /* all other models implement TP EC 0x2f control */
+                        if (fans_handle) {
+                                /* X31, X40, X41 */
+                                fan_control_access_mode =
+                                    IBMACPI_FAN_WR_ACPI_FANS;
+                                fan_control_commands |=
+                                    IBMACPI_FAN_CMD_SPEED |
+                                    IBMACPI_FAN_CMD_LEVEL |
+                                    IBMACPI_FAN_CMD_ENABLE;
+                        } else {
+                                fan_control_access_mode = IBMACPI_FAN_WR_TPEC;
+                                fan_control_commands |=
+                                    IBMACPI_FAN_CMD_LEVEL |
+                                    IBMACPI_FAN_CMD_ENABLE;
+                        }
+                }
+        }
+        return 0;
+}
+static int fan_get_status(u8 *status)
+{
+        u8 s;
+        /* TODO:
+         * Add IBMACPI_FAN_RD_ACPI_FANS ? */
+        switch (fan_status_access_mode) {
+        case IBMACPI_FAN_RD_ACPI_GFAN:
+                /* 570, 600e/x, 770e, 770x */
+                if (unlikely(!acpi_evalf(gfan_handle, &s, NULL, "d")))
+                        return -EIO;
+                if (likely(status))
+                        *status = s & 0x07;
+                break;
+        case IBMACPI_FAN_RD_TPEC:
                /* all except 570, 600e/x, 770e, 770x */
-                if (!acpi_ec_read(fan_status_offset, &status))
+                if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
-                        len += sprintf(p + len, "status:\t\tunreadable\n");
+                        return -EIO;
-                else
-                        len += sprintf(p + len, "status:\t\t%s\n",
-                                       enabled(status, 7));
-                if (!acpi_ec_read(fan_rpm_offset, &lo) ||
+                if (likely(status))
-                    !acpi_ec_read(fan_rpm_offset + 1, &hi))
+                        *status = s;
-                        len += sprintf(p + len, "speed:\t\tunreadable\n");
-                else
+                break;
-                        len += sprintf(p + len, "speed:\t\t%d\n",
-                                       (hi << 8) + lo);
+        default:
+                return -ENXIO;
        }
-        if (sfan_handle)
+        return 0;
-                /* 570, 770x-JL */
+}
-                len += sprintf(p + len, "commands:\tlevel <level>"
-                               " (<level> is 0-7)\n");
+static int fan_get_speed(unsigned int *speed)
-        if (!gfan_handle)
+{
+        u8 hi, lo;
+        switch (fan_status_access_mode) {
+        case IBMACPI_FAN_RD_TPEC:
                /* all except 570, 600e/x, 770e, 770x */
-                len += sprintf(p + len, "commands:\tenable, disable\n");
+                if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
-        if (fans_handle)
+                             !acpi_ec_read(fan_rpm_offset + 1, &hi)))
-                /* X31, X40 */
+                        return -EIO;
+                if (likely(speed))
+                        *speed = (hi << 8) | lo;
+                break;
+        default:
+                return -ENXIO;
+        }
+        return 0;
+}
+static void fan_exit(void)
+{
+        cancel_delayed_work(&fan_watchdog_task);
+        flush_scheduled_work();
+}
+static void fan_watchdog_reset(void)
+{
+        static int fan_watchdog_active = 0;
+        if (fan_watchdog_active)
+                cancel_delayed_work(&fan_watchdog_task);
+        if (fan_watchdog_maxinterval > 0) {
+                fan_watchdog_active = 1;
+                if (!schedule_delayed_work(&fan_watchdog_task,
+                                msecs_to_jiffies(fan_watchdog_maxinterval
+                                                 * 1000))) {
+                        printk(IBM_ERR "failed to schedule the fan watchdog, "
+                               "watchdog will not trigger\n");
+                }
+        } else
+                fan_watchdog_active = 0;
+}
+static int fan_read(char *p)
+{
+        int len = 0;
+        int rc;
+        u8 status;
+        unsigned int speed = 0;
+        switch (fan_status_access_mode) {
+        case IBMACPI_FAN_RD_ACPI_GFAN:
+                /* 570, 600e/x, 770e, 770x */
+                if ((rc = fan_get_status(&status)) < 0)
+                        return rc;
+                len += sprintf(p + len, "status:\t\t%s\n"
+                               "level:\t\t%d\n",
+                               (status != 0) ? "enabled" : "disabled", status);
+                break;
+        case IBMACPI_FAN_RD_TPEC:
+                /* all except 570, 600e/x, 770e, 770x */
+                if ((rc = fan_get_status(&status)) < 0)
+                        return rc;
+                if (unlikely(!fan_control_status_known)) {
+                        if (status != fan_control_initial_status)
+                                fan_control_status_known = 1;
+                        else
+                                /* Return most likely status. In fact, it
+                                 * might be the only possible status */
+                                status = IBMACPI_FAN_EC_AUTO;
+                }
+                len += sprintf(p + len, "status:\t\t%s\n",
+                               (status != 0) ? "enabled" : "disabled");
+                /* No ThinkPad boots on disengaged mode, we can safely
+                 * assume the tachometer is online if fan control status
+                 * was unknown */
+                if ((rc = fan_get_speed(&speed)) < 0)
+                        return rc;
+                len += sprintf(p + len, "speed:\t\t%d\n", speed);
+                if (status & IBMACPI_FAN_EC_DISENGAGED)
+                        /* Disengaged mode takes precedence */
+                        len += sprintf(p + len, "level:\t\tdisengaged\n");
+                else if (status & IBMACPI_FAN_EC_AUTO)
+                        len += sprintf(p + len, "level:\t\tauto\n");
+                else
+                        len += sprintf(p + len, "level:\t\t%d\n", status);
+                break;
+        case IBMACPI_FAN_NONE:
+        default:
+                len += sprintf(p + len, "status:\t\tnot supported\n");
+        }
+        if (fan_control_commands & IBMACPI_FAN_CMD_LEVEL) {
+                len += sprintf(p + len, "commands:\tlevel <level>");
+                switch (fan_control_access_mode) {
+                case IBMACPI_FAN_WR_ACPI_SFAN:
+                        len += sprintf(p + len, " (<level> is 0-7)\n");
+                        break;
+                default:
+                        len += sprintf(p + len, " (<level> is 0-7, "
+                                       "auto, disengaged)\n");
+                        break;
+                }
+        }
+        if (fan_control_commands & IBMACPI_FAN_CMD_ENABLE)
+                len += sprintf(p + len, "commands:\tenable, disable\n"
+                               "commands:\twatchdog <timeout> (<timeout> is 0 (off), "
+                               "1-120 (seconds))\n");
+        if (fan_control_commands & IBMACPI_FAN_CMD_SPEED)
                len += sprintf(p + len, "commands:\tspeed <speed>"
                               " (<speed> is 0-65535)\n");
        return len;
 }
-static int fan_write(char *buf)
+static int fan_set_level(int level)
 {
-        char *cmd;
+        switch (fan_control_access_mode) {
-        int level, speed;
+        case IBMACPI_FAN_WR_ACPI_SFAN:
+                if (level >= 0 && level <= 7) {
-        while ((cmd = next_cmd(&buf))) {
-                if (sfan_handle &&
-                    sscanf(cmd, "level %d", &level) == 1 &&
-                    level >= 0 && level <= 7) {
-                        /* 570, 770x-JL */
                        if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level))
                                return -EIO;
-                } else if (!gfan_handle && strlencmp(cmd, "enable") == 0) {
+                } else
-                        /* all except 570, 600e/x, 770e, 770x */
+                        return -EINVAL;
-                        if (!acpi_ec_write(fan_status_offset, 0x80))
+                break;
-                                return -EIO;
-                } else if (!gfan_handle && strlencmp(cmd, "disable") == 0) {
+        case IBMACPI_FAN_WR_ACPI_FANS:
-                        /* all except 570, 600e/x, 770e, 770x */
+        case IBMACPI_FAN_WR_TPEC:
-                        if (!acpi_ec_write(fan_status_offset, 0x00))
+                if ((level != IBMACPI_FAN_EC_AUTO) &&
-                                return -EIO;
+                    (level != IBMACPI_FAN_EC_DISENGAGED) &&
-                } else if (fans_handle &&
+                    ((level < 0) || (level > 7)))
-                           sscanf(cmd, "speed %d", &speed) == 1 &&
+                        return -EINVAL;
-                           speed >= 0 && speed <= 65535) {
-                        /* X31, X40 */
+                if (!acpi_ec_write(fan_status_offset, level))
+                        return -EIO;
+                else
+                        fan_control_status_known = 1;
+                break;
+        default:
+                return -ENXIO;
+        }
+        return 0;
+}
+static int fan_set_enable(void)
+{
+        u8 s;
+        int rc;
+        switch (fan_control_access_mode) {
+        case IBMACPI_FAN_WR_ACPI_FANS:
+        case IBMACPI_FAN_WR_TPEC:
+                if ((rc = fan_get_status(&s)) < 0)
+                        return rc;
+                /* Don't go out of emergency fan mode */
+                if (s != 7)
+                        s = IBMACPI_FAN_EC_AUTO;
+                if (!acpi_ec_write(fan_status_offset, s))
+                        return -EIO;
+                else
+                        fan_control_status_known = 1;
+                break;
+        case IBMACPI_FAN_WR_ACPI_SFAN:
+                if ((rc = fan_get_status(&s)) < 0)
+                        return rc;
+                s &= 0x07;
+                /* Set fan to at least level 4 */
+                if (s < 4)
+                        s = 4;
+                if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
+                        return -EIO;
+                break;
+        default:
+                return -ENXIO;
+        }
+        return 0;
+}
+static int fan_set_disable(void)
+{
+        switch (fan_control_access_mode) {
+        case IBMACPI_FAN_WR_ACPI_FANS:
+        case IBMACPI_FAN_WR_TPEC:
+                if (!acpi_ec_write(fan_status_offset, 0x00))
+                        return -EIO;
+                else
+                        fan_control_status_known = 1;
+                break;
+        case IBMACPI_FAN_WR_ACPI_SFAN:
+                if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
+                        return -EIO;
+                break;
+        default:
+                return -ENXIO;
+        }
+        return 0;
+}
+static int fan_set_speed(int speed)
+{
+        switch (fan_control_access_mode) {
+        case IBMACPI_FAN_WR_ACPI_FANS:
+                if (speed >= 0 && speed <= 65535) {
                        if (!acpi_evalf(fans_handle, NULL, NULL, "vddd",
                                        speed, speed, speed))
                                return -EIO;
                } else
                        return -EINVAL;
-        }
+                break;
+        default:
+                return -ENXIO;
+        }
        return 0;
 }
+static int fan_write_cmd_level(const char *cmd, int *rc)
+{
+        int level;
+        if (strlencmp(cmd, "level auto") == 0)
+                level = IBMACPI_FAN_EC_AUTO;
+        else if (strlencmp(cmd, "level disengaged") == 0)
+                level = IBMACPI_FAN_EC_DISENGAGED;
+        else if (sscanf(cmd, "level %d", &level) != 1)
+                return 0;
+        if ((*rc = fan_set_level(level)) == -ENXIO)
+                printk(IBM_ERR "level command accepted for unsupported "
+                       "access mode %d", fan_control_access_mode);
+        return 1;
+}
+static int fan_write_cmd_enable(const char *cmd, int *rc)
+{
+        if (strlencmp(cmd, "enable") != 0)
+                return 0;
+        if ((*rc = fan_set_enable()) == -ENXIO)
+                printk(IBM_ERR "enable command accepted for unsupported "
+                       "access mode %d", fan_control_access_mode);
+        return 1;
+}
+static int fan_write_cmd_disable(const char *cmd, int *rc)
+{
+        if (strlencmp(cmd, "disable") != 0)
+                return 0;
+        if ((*rc = fan_set_disable()) == -ENXIO)
+                printk(IBM_ERR "disable command accepted for unsupported "
+                       "access mode %d", fan_control_access_mode);
+        return 1;
+}
+static int fan_write_cmd_speed(const char *cmd, int *rc)
+{
+        int speed;
+        /* TODO:
+         * Support speed <low> <medium> <high> ? */
+        if (sscanf(cmd, "speed %d", &speed) != 1)
+                return 0;
+        if ((*rc = fan_set_speed(speed)) == -ENXIO)
+                printk(IBM_ERR "speed command accepted for unsupported "
+                       "access mode %d", fan_control_access_mode);
+        return 1;
+}
+static int fan_write_cmd_watchdog(const char *cmd, int *rc)
+{
+        int interval;
+        if (sscanf(cmd, "watchdog %d", &interval) != 1)
+                return 0;
+        if (interval < 0 || interval > 120)
+                *rc = -EINVAL;
+        else
+                fan_watchdog_maxinterval = interval;
+        return 1;
+}
+static int fan_write(char *buf)
+{
+        char *cmd;
+        int rc = 0;
+        while (!rc && (cmd = next_cmd(&buf))) {
+                if (!((fan_control_commands & IBMACPI_FAN_CMD_LEVEL) &&
+                      fan_write_cmd_level(cmd, &rc)) &&
+                    !((fan_control_commands & IBMACPI_FAN_CMD_ENABLE) &&
+                      (fan_write_cmd_enable(cmd, &rc) ||
+                       fan_write_cmd_disable(cmd, &rc) ||
+                       fan_write_cmd_watchdog(cmd, &rc))) &&
+                    !((fan_control_commands & IBMACPI_FAN_CMD_SPEED) &&
+                      fan_write_cmd_speed(cmd, &rc))
+                    )
+                        rc = -EINVAL;
+                else if (!rc)
+                        fan_watchdog_reset();
+        }
+        return rc;
+}
+static void fan_watchdog_fire(struct work_struct *ignored)
+{
+        printk(IBM_NOTICE "fan watchdog: enabling fan\n");
+        if (fan_set_enable()) {
+                printk(IBM_ERR "fan watchdog: error while enabling fan\n");
+                /* reschedule for later */
+                fan_watchdog_reset();
+        }
+}
 static struct ibm_struct ibms[] = {
        {
         .name = "driver",
@@ -1662,6 +2354,7 @@ static struct ibm_struct ibms[] = {
         .type = ACPI_SYSTEM_NOTIFY,
         },
 #endif
+#ifdef CONFIG_ACPI_IBM_BAY
        {
         .name = "bay",
         .init = bay_init,
@@ -1671,6 +2364,7 @@ static struct ibm_struct ibms[] = {
         .handle = &bay_handle,
         .type = ACPI_SYSTEM_NOTIFY,
         },
+#endif
        {
         .name = "cmos",
         .read = cmos_read,
@@ -1702,6 +2396,8 @@ static struct ibm_struct ibms[] = {
         .name = "brightness",
         .read = brightness_read,
         .write = brightness_write,
+         .init = brightness_init,
+         .exit = brightness_exit,
         },
        {
         .name = "volume",
@@ -1712,6 +2408,8 @@ static struct ibm_struct ibms[] = {
         .name = "fan",
         .read = fan_read,
         .write = fan_write,
+         .init = fan_init,
+         .exit = fan_exit,
         .experimental = 1,
         },
 };
@@ -1719,7 +2417,7 @@ static struct ibm_struct ibms[] = {
 static int dispatch_read(char *page, char **start, off_t off, int count,
                         int *eof, void *data)
 {
-        struct ibm_struct *ibm = (struct ibm_struct *)data;
+        struct ibm_struct *ibm = data;
        int len;
        if (!ibm || !ibm->read)
@@ -1744,7 +2442,7 @@ static int dispatch_read(char *page, char **start, off_t off, int count,
 static int dispatch_write(struct file *file, const char __user * userbuf,
                          unsigned long count, void *data)
 {
-        struct ibm_struct *ibm = (struct ibm_struct *)data;
+        struct ibm_struct *ibm = data;
        char *kernbuf;
        int ret;
@@ -1773,7 +2471,7 @@ static int dispatch_write(struct file *file, const char __user * userbuf,
 static void dispatch_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct ibm_struct *ibm = (struct ibm_struct *)data;
+        struct ibm_struct *ibm = data;
        if (!ibm || !ibm->notify)
                return;
@@ -1805,7 +2503,7 @@ static int __init setup_notify(struct ibm_struct *ibm)
                       ibm->name, status);
                return -ENODEV;
        }
+        ibm->notify_installed = 1;
        return 0;
 }
@@ -1818,14 +2516,13 @@ static int __init register_driver(struct ibm_struct *ibm)
 {
        int ret;
-        ibm->driver = kmalloc(sizeof(struct acpi_driver), GFP_KERNEL);
+        ibm->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
        if (!ibm->driver) {
                printk(IBM_ERR "kmalloc(ibm->driver) failed\n");
                return -1;
        }
-        memset(ibm->driver, 0, sizeof(struct acpi_driver));
+        sprintf(ibm->driver->name, "%s_%s", IBM_NAME, ibm->name);
-        sprintf(ibm->driver->name, "%s/%s", IBM_NAME, ibm->name);
        ibm->driver->ids = ibm->hid;
        ibm->driver->ops.add = &ibm_device_add;
@@ -1882,7 +2579,6 @@ static int __init ibm_init(struct ibm_struct *ibm)
                ret = setup_notify(ibm);
                if (ret < 0)
                        return ret;
-                ibm->notify_installed = 1;
        }
        return 0;
@@ -1954,7 +2650,9 @@ IBM_PARAM(light);
 #ifdef CONFIG_ACPI_IBM_DOCK
 IBM_PARAM(dock);
 #endif
+#ifdef CONFIG_ACPI_IBM_BAY
 IBM_PARAM(bay);
+#endif
 IBM_PARAM(cmos);
 IBM_PARAM(led);
 IBM_PARAM(beep);
@@ -1971,6 +2669,33 @@ static void acpi_ibm_exit(void)
                ibm_exit(&ibms[i]);
        remove_proc_entry(IBM_DIR, acpi_root_dir);
+        if (ibm_thinkpad_ec_found)
+                kfree(ibm_thinkpad_ec_found);
+}
+static char* __init check_dmi_for_ec(void)
+{
+        struct dmi_device *dev = NULL;
+        char ec_fw_string[18];
+        /*
+         * ThinkPad T23 or newer, A31 or newer, R50e or newer,
+         * X32 or newer, all Z series;  Some models must have an
+         * up-to-date BIOS or they will not be detected.
+         *
+         * See http://thinkwiki.org/wiki/List_of_DMI_IDs
+         */
+        while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
+                if (sscanf(dev->name,
+                           "IBM ThinkPad Embedded Controller -[%17c",
+                           ec_fw_string) == 1) {
+                        ec_fw_string[sizeof(ec_fw_string) - 1] = 0;
+                        ec_fw_string[strcspn(ec_fw_string, " ]")] = 0;
+                        return kstrdup(ec_fw_string, GFP_KERNEL);
+                }
+        }
+        return NULL;
 }
 static int __init acpi_ibm_init(void)
@@ -1992,6 +2717,12 @@ static int __init acpi_ibm_init(void)
                return -ENODEV;
        }
+        /* Models with newer firmware report the EC in DMI */
+        ibm_thinkpad_ec_found = check_dmi_for_ec();
+        if (ibm_thinkpad_ec_found)
+                printk(IBM_INFO "ThinkPad EC firmware %s\n",
+                       ibm_thinkpad_ec_found);
        /* these handles are not required */
        IBM_HANDLE_INIT(vid);
        IBM_HANDLE_INIT(vid2);
@@ -2004,12 +2735,14 @@ static int __init acpi_ibm_init(void)
        IBM_HANDLE_INIT(dock);
 #endif
        IBM_HANDLE_INIT(pci);
+#ifdef CONFIG_ACPI_IBM_BAY
        IBM_HANDLE_INIT(bay);
        if (bay_handle)
                IBM_HANDLE_INIT(bay_ej);
        IBM_HANDLE_INIT(bay2);
        if (bay2_handle)
                IBM_HANDLE_INIT(bay2_ej);
+#endif
        IBM_HANDLE_INIT(beep);
        IBM_HANDLE_INIT(ecrd);
        IBM_HANDLE_INIT(ecwr);
diff --git a/drivers/acpi/namespace/nsxfobj.c b/drivers/acpi/namespace/nsxfobj.c
index a163e1d3708d..a18b1c223129 100644
--- a/drivers/acpi/namespace/nsxfobj.c
+++ b/drivers/acpi/namespace/nsxfobj.c
@@ -50,6 +50,50 @@ ACPI_MODULE_NAME("nsxfobj")
 /*******************************************************************************
 *
+ * FUNCTION:    acpi_get_id
+ *
+ * PARAMETERS:  Handle          - Handle of object whose id is desired
+ *              ret_id          - Where the id will be placed
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: This routine returns the owner id associated with a handle
+ *
+ ******************************************************************************/
+acpi_status acpi_get_id(acpi_handle handle, acpi_owner_id * ret_id)
+{
+        struct acpi_namespace_node *node;
+        acpi_status status;
+        /* Parameter Validation */
+        if (!ret_id) {
+                return (AE_BAD_PARAMETER);
+        }
+        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+        if (ACPI_FAILURE(status)) {
+                return (status);
+        }
+        /* Convert and validate the handle */
+        node = acpi_ns_map_handle_to_node(handle);
+        if (!node) {
+                (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+                return (AE_BAD_PARAMETER);
+        }
+        *ret_id = node->owner_id;
+        status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+        return (status);
+}
+ACPI_EXPORT_SYMBOL(acpi_get_id)
+/*******************************************************************************
+ *
 * FUNCTION:    acpi_get_type
 *
 * PARAMETERS:  Handle          - Handle of object whose type is desired
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index e5e448edca41..bd96a7045925 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -248,7 +248,7 @@ int acpi_get_pxm(acpi_handle h)
                handle = phandle;
                status = acpi_evaluate_integer(handle, "_PXM", NULL, &pxm);
                if (ACPI_SUCCESS(status))
-                        return (int)pxm;
+                        return pxm;
                status = acpi_get_parent(handle, &phandle);
        } while (ACPI_SUCCESS(status));
        return -1;
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 02b30ae6a68e..57ae1e5cde0a 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -568,6 +568,7 @@ void acpi_os_derive_pci_id(acpi_handle rhandle,	/* upper bound  */
 static void acpi_os_execute_deferred(struct work_struct *work)
 {
        struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
        if (!dpc) {
                printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
                return;
@@ -1031,7 +1032,7 @@ acpi_status
 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
 {
        *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
-        if (cache == NULL)
+        if (*cache == NULL)
                return AE_ERROR;
        else
                return AE_OK;
@@ -1051,7 +1052,7 @@ acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
 acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
 {
-        (void)kmem_cache_shrink(cache);
+        kmem_cache_shrink(cache);
        return (AE_OK);
 }
diff --git a/drivers/acpi/pci_bind.c b/drivers/acpi/pci_bind.c
index 1e2ae6e7a7e4..55f57a61c55e 100644
--- a/drivers/acpi/pci_bind.c
+++ b/drivers/acpi/pci_bind.c
@@ -122,19 +122,17 @@ int acpi_pci_bind(struct acpi_device *device)
        if (!device || !device->parent)
                return -EINVAL;
-        pathname = kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
+        pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
        if (!pathname)
                return -ENOMEM;
-        memset(pathname, 0, ACPI_PATHNAME_MAX);
        buffer.length = ACPI_PATHNAME_MAX;
        buffer.pointer = pathname;
-        data = kmalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
+        data = kzalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
        if (!data) {
                kfree(pathname);
                return -ENOMEM;
        }
-        memset(data, 0, sizeof(struct acpi_pci_data));
        acpi_get_name(device->handle, ACPI_FULL_PATHNAME, &buffer);
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Binding PCI device [%s]...\n",
@@ -281,10 +279,9 @@ int acpi_pci_unbind(struct acpi_device *device)
        if (!device || !device->parent)
                return -EINVAL;
-        pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
+        pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
        if (!pathname)
                return -ENOMEM;
-        memset(pathname, 0, ACPI_PATHNAME_MAX);
        buffer.length = ACPI_PATHNAME_MAX;
        buffer.pointer = pathname;
@@ -331,11 +328,9 @@ acpi_pci_bind_root(struct acpi_device *device,
        char *pathname = NULL;
        struct acpi_buffer buffer = { 0, NULL };
+        pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
-        pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
        if (!pathname)
                return -ENOMEM;
-        memset(pathname, 0, ACPI_PATHNAME_MAX);
        buffer.length = ACPI_PATHNAME_MAX;
        buffer.pointer = pathname;
@@ -345,12 +340,11 @@ acpi_pci_bind_root(struct acpi_device *device,
                return -EINVAL;
        }
-        data = kmalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
+        data = kzalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
        if (!data) {
                kfree(pathname);
                return -ENOMEM;
        }
-        memset(data, 0, sizeof(struct acpi_pci_data));
        data->id = *id;
        data->bus = bus;
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index feda0341f5a7..fe7d007833ad 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -89,10 +89,9 @@ acpi_pci_irq_add_entry(acpi_handle handle,
        if (!prt)
                return -EINVAL;
-        entry = kmalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
+        entry = kzalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
        if (!entry)
                return -ENOMEM;
-        memset(entry, 0, sizeof(struct acpi_prt_entry));
        entry->id.segment = segment;
        entry->id.bus = bus;
@@ -161,10 +160,9 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
        static int first_time = 1;
-        pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
+        pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
        if (!pathname)
                return -ENOMEM;
-        memset(pathname, 0, ACPI_PATHNAME_MAX);
        if (first_time) {
                acpi_prt.count = 0;
@@ -198,11 +196,10 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
                return -ENODEV;
        }
-        prt = kmalloc(buffer.length, GFP_KERNEL);
+        prt = kzalloc(buffer.length, GFP_KERNEL);
        if (!prt) {
                return -ENOMEM;
        }
-        memset(prt, 0, buffer.length);
        buffer.pointer = prt;
        status = acpi_get_irq_routing_table(handle, &buffer);
diff --git a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c
index d53bd9878ca2..481e633bbf41 100644
--- a/drivers/acpi/pci_link.c
+++ b/drivers/acpi/pci_link.c
@@ -103,7 +103,7 @@ DEFINE_MUTEX(acpi_link_lock);
 static acpi_status
 acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
 {
-        struct acpi_pci_link *link = (struct acpi_pci_link *)context;
+        struct acpi_pci_link *link = context;
        u32 i = 0;
@@ -307,11 +307,10 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
        if (!link || !irq)
                return -EINVAL;
-        resource = kmalloc(sizeof(*resource) + 1, irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
+        resource = kzalloc(sizeof(*resource) + 1, irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
        if (!resource)
                return -ENOMEM;
-        memset(resource, 0, sizeof(*resource) + 1);
        buffer.length = sizeof(*resource) + 1;
        buffer.pointer = resource;
@@ -613,7 +612,7 @@ acpi_pci_link_allocate_irq(acpi_handle handle,
                return -1;
        }
-        link = (struct acpi_pci_link *)acpi_driver_data(device);
+        link = acpi_driver_data(device);
        if (!link) {
                printk(KERN_ERR PREFIX "Invalid link context\n");
                return -1;
@@ -668,7 +667,7 @@ int acpi_pci_link_free_irq(acpi_handle handle)
                return -1;
        }
-        link = (struct acpi_pci_link *)acpi_driver_data(device);
+        link = acpi_driver_data(device);
        if (!link) {
                printk(KERN_ERR PREFIX "Invalid link context\n");
                return -1;
@@ -718,10 +717,9 @@ static int acpi_pci_link_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        link = kmalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
+        link = kzalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
        if (!link)
                return -ENOMEM;
-        memset(link, 0, sizeof(struct acpi_pci_link));
        link->device = device;
        strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
@@ -808,7 +806,7 @@ static int acpi_pci_link_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        link = (struct acpi_pci_link *)acpi_driver_data(device);
+        link = acpi_driver_data(device);
        mutex_lock(&acpi_link_lock);
        list_del(&link->node);
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 0984a1ee24ed..a860efa2c562 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -98,11 +98,12 @@ void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
        struct acpi_pci_driver **pptr = &sub_driver;
        while (*pptr) {
-                if (*pptr != driver)
+                if (*pptr == driver)
-                        continue;
+                        break;
-                *pptr = (*pptr)->next;
+                pptr = &(*pptr)->next;
-                break;
        }
+        BUG_ON(!*pptr);
+        *pptr = (*pptr)->next;
        if (!driver->remove)
                return;
@@ -119,7 +120,7 @@ EXPORT_SYMBOL(acpi_pci_unregister_driver);
 static acpi_status
 get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
 {
-        int *busnr = (int *)data;
+        int *busnr = data;
        struct acpi_resource_address64 address;
        if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
@@ -164,10 +165,9 @@ static int acpi_pci_root_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        root = kmalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
+        root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
        if (!root)
                return -ENOMEM;
-        memset(root, 0, sizeof(struct acpi_pci_root));
        INIT_LIST_HEAD(&root->node);
        root->device = device;
@@ -331,7 +331,7 @@ static int acpi_pci_root_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        root = (struct acpi_pci_root *)acpi_driver_data(device);
+        root = acpi_driver_data(device);
        kfree(root);
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index fe67a8af520e..0ba7dfbbb2ee 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -108,7 +108,7 @@ acpi_power_get_context(acpi_handle handle,
                return result;
        }
-        *resource = (struct acpi_power_resource *)acpi_driver_data(device);
+        *resource = acpi_driver_data(device);
        if (!resource)
                return -ENODEV;
@@ -442,7 +442,7 @@ static int acpi_power_seq_show(struct seq_file *seq, void *offset)
        struct acpi_power_resource *resource = NULL;
-        resource = (struct acpi_power_resource *)seq->private;
+        resource = seq->private;
        if (!resource)
                goto end;
@@ -532,10 +532,9 @@ static int acpi_power_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        resource = kmalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
+        resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
        if (!resource)
                return -ENOMEM;
-        memset(resource, 0, sizeof(struct acpi_power_resource));
        resource->device = device;
        strcpy(resource->name, device->pnp.bus_id);
@@ -590,7 +589,7 @@ static int acpi_power_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        resource = (struct acpi_power_resource *)acpi_driver_data(device);
+        resource = acpi_driver_data(device);
        acpi_power_remove_fs(device);
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 1908e0d20222..25718fed39f1 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -277,7 +277,7 @@ static struct proc_dir_entry *acpi_processor_dir = NULL;
 static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_processor *pr = (struct acpi_processor *)seq->private;
+        struct acpi_processor *pr = seq->private;
        if (!pr)
@@ -542,12 +542,12 @@ static int __cpuinit acpi_processor_start(struct acpi_device *device)
         * Don't trust it blindly
         */
        if (processor_device_array[pr->id] != NULL &&
-            processor_device_array[pr->id] != (void *)device) {
+            processor_device_array[pr->id] != device) {
                printk(KERN_WARNING "BIOS reported wrong ACPI id"
                        "for the processor\n");
                return -ENODEV;
        }
-        processor_device_array[pr->id] = (void *)device;
+        processor_device_array[pr->id] = device;
        processors[pr->id] = pr;
@@ -578,7 +578,7 @@ static int __cpuinit acpi_processor_start(struct acpi_device *device)
 static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_processor *pr = (struct acpi_processor *)data;
+        struct acpi_processor *pr = data;
        struct acpi_device *device = NULL;
@@ -615,10 +615,9 @@ static int acpi_processor_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        pr = kmalloc(sizeof(struct acpi_processor), GFP_KERNEL);
+        pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
        if (!pr)
                return -ENOMEM;
-        memset(pr, 0, sizeof(struct acpi_processor));
        pr->handle = device->handle;
        strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
@@ -637,7 +636,7 @@ static int acpi_processor_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        pr = (struct acpi_processor *)acpi_driver_data(device);
+        pr = acpi_driver_data(device);
        if (pr->id >= NR_CPUS) {
                kfree(pr);
@@ -901,13 +900,13 @@ static int __init acpi_processor_init(void)
        acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
        if (!acpi_processor_dir)
-                return 0;
+                return -ENOMEM;
        acpi_processor_dir->owner = THIS_MODULE;
        result = acpi_bus_register_driver(&acpi_processor_driver);
        if (result < 0) {
                remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
-                return 0;
+                return result;
        }
        acpi_processor_install_hotplug_notify();
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 6dac6050bb5a..3f30af21574e 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -681,7 +681,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
                return -ENODEV;
        }
-        cst = (union acpi_object *)buffer.pointer;
+        cst = buffer.pointer;
        /* There must be at least 2 elements */
        if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
@@ -710,14 +710,14 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
                memset(&cx, 0, sizeof(cx));
-                element = (union acpi_object *)&(cst->package.elements[i]);
+                element = &(cst->package.elements[i]);
                if (element->type != ACPI_TYPE_PACKAGE)
                        continue;
                if (element->package.count != 4)
                        continue;
-                obj = (union acpi_object *)&(element->package.elements[0]);
+                obj = &(element->package.elements[0]);
                if (obj->type != ACPI_TYPE_BUFFER)
                        continue;
@@ -729,7 +729,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
                        continue;
                /* There should be an easy way to extract an integer... */
-                obj = (union acpi_object *)&(element->package.elements[1]);
+                obj = &(element->package.elements[1]);
                if (obj->type != ACPI_TYPE_INTEGER)
                        continue;
@@ -762,13 +762,13 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
                        }
                }
-                obj = (union acpi_object *)&(element->package.elements[2]);
+                obj = &(element->package.elements[2]);
                if (obj->type != ACPI_TYPE_INTEGER)
                        continue;
                cx.latency = obj->integer.value;
-                obj = (union acpi_object *)&(element->package.elements[3]);
+                obj = &(element->package.elements[3]);
                if (obj->type != ACPI_TYPE_INTEGER)
                        continue;
@@ -1037,7 +1037,7 @@ int acpi_processor_cst_has_changed(struct acpi_processor *pr)
 static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_processor *pr = (struct acpi_processor *)seq->private;
+        struct acpi_processor *pr = seq->private;
        unsigned int i;
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index 6fd174a37149..0e60382714bb 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -236,7 +236,7 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr)
                return -ENODEV;
        }
-        pss = (union acpi_object *)buffer.pointer;
+        pss = buffer.pointer;
        if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
                printk(KERN_ERR PREFIX "Invalid _PSS data\n");
                result = -EFAULT;
@@ -410,7 +410,7 @@ static struct file_operations acpi_processor_perf_fops = {
 static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_processor *pr = (struct acpi_processor *)seq->private;
+        struct acpi_processor *pr = seq->private;
        int i;
@@ -451,8 +451,8 @@ acpi_processor_write_performance(struct file *file,
                                 size_t count, loff_t * data)
 {
        int result = 0;
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_processor *pr = (struct acpi_processor *)m->private;
+        struct acpi_processor *pr = m->private;
        struct acpi_processor_performance *perf;
        char state_string[12] = { '\0' };
        unsigned int new_state = 0;
@@ -551,7 +551,7 @@ static int acpi_processor_get_psd(struct acpi_processor	*pr)
                return -ENODEV;
        }
-        psd = (union acpi_object *) buffer.pointer;
+        psd = buffer.pointer;
        if (!psd || (psd->type != ACPI_TYPE_PACKAGE)) {
                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
                result = -EFAULT;
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index ef5e0f6efdba..40fecd67ad83 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -208,7 +208,7 @@ int acpi_processor_set_thermal_limit(acpi_handle handle, int type)
        if (result)
                return result;
-        pr = (struct acpi_processor *)acpi_driver_data(device);
+        pr = acpi_driver_data(device);
        if (!pr)
                return -ENODEV;
@@ -348,8 +348,8 @@ static ssize_t acpi_processor_write_limit(struct file * file,
                                          size_t count, loff_t * data)
 {
        int result = 0;
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_processor *pr = (struct acpi_processor *)m->private;
+        struct acpi_processor *pr = m->private;
        char limit_string[25] = { '\0' };
        int px = 0;
        int tx = 0;
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index d044ec519db0..0ec7dcde0063 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -259,7 +259,7 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
 static int acpi_processor_throttling_seq_show(struct seq_file *seq,
                                              void *offset)
 {
-        struct acpi_processor *pr = (struct acpi_processor *)seq->private;
+        struct acpi_processor *pr = seq->private;
        int i = 0;
        int result = 0;
@@ -307,8 +307,8 @@ static ssize_t acpi_processor_write_throttling(struct file * file,
                                               size_t count, loff_t * data)
 {
        int result = 0;
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_processor *pr = (struct acpi_processor *)m->private;
+        struct acpi_processor *pr = m->private;
        char state_string[12] = { '\0' };
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 8908a975e575..f58fc7447ab4 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -923,7 +923,7 @@ static struct proc_dir_entry *acpi_battery_dir = NULL;
 static int acpi_battery_read_info(struct seq_file *seq, void *offset)
 {
-        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        struct acpi_battery *battery = seq->private;
        int cscale;
        int result = 0;
@@ -1076,7 +1076,7 @@ static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
 {
-        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        struct acpi_battery *battery = seq->private;
        int result = 0;
        int cscale;
@@ -1125,8 +1125,8 @@ static ssize_t
 acpi_battery_write_alarm(struct file *file, const char __user * buffer,
                         size_t count, loff_t * ppos)
 {
-        struct seq_file *seq = (struct seq_file *)file->private_data;
+        struct seq_file *seq = file->private_data;
-        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        struct acpi_battery *battery = seq->private;
        char alarm_string[12] = { '\0' };
        int result, old_alarm, new_alarm;
@@ -1160,14 +1160,14 @@ acpi_battery_write_alarm(struct file *file, const char __user * buffer,
        if (result) {
                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                                  "acpi_battery_set_alarm() failed\n"));
-                (void)acpi_battery_set_alarm(battery, old_alarm);
+                acpi_battery_set_alarm(battery, old_alarm);
                goto end;
        }
        result = acpi_battery_get_alarm(battery);
        if (result) {
                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                                  "acpi_battery_get_alarm() failed\n"));
-                (void)acpi_battery_set_alarm(battery, old_alarm);
+                acpi_battery_set_alarm(battery, old_alarm);
                goto end;
        }
@@ -1217,7 +1217,7 @@ static struct proc_dir_entry *acpi_ac_dir = NULL;
 static int acpi_ac_read_state(struct seq_file *seq, void *offset)
 {
-        struct acpi_sbs *sbs = (struct acpi_sbs *)seq->private;
+        struct acpi_sbs *sbs = seq->private;
        int result;
        if (sbs->zombie) {
@@ -1302,7 +1302,7 @@ static int acpi_battery_add(struct acpi_sbs *sbs, int id)
                battery->init_state = 1;
        }
-        (void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
+        sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
        result = acpi_sbs_generic_add_fs(&battery->battery_entry,
                                         acpi_battery_dir,
@@ -1485,7 +1485,7 @@ static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
                }
                if (old_battery_present != new_battery_present) {
-                        (void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
+                        sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
                        result = acpi_sbs_generate_event(sbs->device,
                                                         ACPI_SBS_BATTERY_NOTIFY_STATUS,
                                                         new_battery_present,
@@ -1498,7 +1498,7 @@ static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
                        }
                }
                if (old_remaining_capacity != battery->state.remaining_capacity) {
-                        (void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
+                        sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
                        result = acpi_sbs_generate_event(sbs->device,
                                                         ACPI_SBS_BATTERY_NOTIFY_STATUS,
                                                         new_battery_present,
@@ -1576,12 +1576,11 @@ static int acpi_sbs_add(struct acpi_device *device)
        int id, cnt;
        acpi_status status = AE_OK;
-        sbs = kmalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
+        sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
        if (!sbs) {
                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n"));
                return -ENOMEM;
        }
-        memset(sbs, 0, sizeof(struct acpi_sbs));
        cnt = 0;
        while (cnt < 10) {
@@ -1659,7 +1658,7 @@ static int acpi_sbs_add(struct acpi_device *device)
        init_timer(&sbs->update_timer);
        if (update_mode == QUEUE_UPDATE_MODE) {
                status = acpi_os_execute(OSL_GPE_HANDLER,
-                                         acpi_sbs_update_queue, (void *)sbs);
+                                         acpi_sbs_update_queue, sbs);
                if (status != AE_OK) {
                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                                          "acpi_os_execute() failed\n"));
@@ -1685,7 +1684,7 @@ static int acpi_sbs_add(struct acpi_device *device)
 int acpi_sbs_remove(struct acpi_device *device, int type)
 {
-        struct acpi_sbs *sbs = NULL;
+        struct acpi_sbs *sbs;
        int id;
        if (!device) {
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 698a1540e303..283d87522c5d 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -984,12 +984,11 @@ acpi_add_single_object(struct acpi_device **child,
        if (!child)
                return -EINVAL;
-        device = kmalloc(sizeof(struct acpi_device), GFP_KERNEL);
+        device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
        if (!device) {
                printk(KERN_ERR PREFIX "Memory allocation error\n");
                return -ENOMEM;
        }
-        memset(device, 0, sizeof(struct acpi_device));
        device->handle = handle;
        device->parent = parent;
diff --git a/drivers/acpi/sleep/wakeup.c b/drivers/acpi/sleep/wakeup.c
index af1dbabaf0b1..fab8f2694f03 100644
--- a/drivers/acpi/sleep/wakeup.c
+++ b/drivers/acpi/sleep/wakeup.c
@@ -183,11 +183,11 @@ late_initcall(acpi_wakeup_device_init);
 #endif
 /*
- * Disable all wakeup GPEs before power off.
+ * Disable all wakeup GPEs before entering requested sleep state.
- * 
+ *      @sleep_state:   ACPI state
 * Since acpi_enter_sleep_state() will disable all
 * RUNTIME GPEs, we simply mark all GPES that
- * are not enabled for wakeup from S5 as RUNTIME.
+ * are not enabled for wakeup from requested state as RUNTIME.
 */
 void acpi_gpe_sleep_prepare(u32 sleep_state)
 {
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index bfb3bfcf9e91..ffa30c9fccbf 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -228,7 +228,7 @@ void acpi_table_print_madt_entry(acpi_table_entry_header * header)
 static int
 acpi_table_compute_checksum(void *table_pointer, unsigned long length)
 {
-        u8 *p = (u8 *) table_pointer;
+        u8 *p = table_pointer;
        unsigned long remains = length;
        unsigned long sum = 0;
diff --git a/drivers/acpi/tables/tbxface.c b/drivers/acpi/tables/tbxface.c
index 7767987be15a..5ba9303293ad 100644
--- a/drivers/acpi/tables/tbxface.c
+++ b/drivers/acpi/tables/tbxface.c
@@ -123,7 +123,6 @@ acpi_status acpi_load_tables(void)
 ACPI_EXPORT_SYMBOL(acpi_load_tables)
-#ifdef ACPI_FUTURE_USAGE
 /*******************************************************************************
 *
 * FUNCTION:    acpi_load_table
@@ -221,6 +220,59 @@ ACPI_EXPORT_SYMBOL(acpi_load_table)
 /*******************************************************************************
 *
+ * FUNCTION:    acpi_unload_table_id
+ *
+ * PARAMETERS:  table_type    - Type of table to be unloaded
+ *              id            - Owner ID of the table to be removed.
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: This routine is used to force the unload of a table (by id)
+ *
+ ******************************************************************************/
+acpi_status acpi_unload_table_id(acpi_table_type table_type, acpi_owner_id id)
+{
+        struct acpi_table_desc *table_desc;
+        acpi_status status;
+        ACPI_FUNCTION_TRACE(acpi_unload_table);
+        /* Parameter validation */
+        if (table_type > ACPI_TABLE_ID_MAX)
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
+        /* Find table from the requested type list */
+        table_desc = acpi_gbl_table_lists[table_type].next;
+        while (table_desc && table_desc->owner_id != id)
+                table_desc = table_desc->next;
+        if (!table_desc)
+                return_ACPI_STATUS(AE_NOT_EXIST);
+        /*
+         * Delete all namespace objects owned by this table. Note that these
+         * objects can appear anywhere in the namespace by virtue of the AML
+         * "Scope" operator. Thus, we need to track ownership by an ID, not
+         * simply a position within the hierarchy
+         */
+        acpi_ns_delete_namespace_by_owner(table_desc->owner_id);
+        status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        if (ACPI_FAILURE(status))
+                return_ACPI_STATUS(status);
+        (void)acpi_tb_uninstall_table(table_desc);
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        return_ACPI_STATUS(AE_OK);
+}
+ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
+#ifdef ACPI_FUTURE_USAGE
+/*******************************************************************************
+ *
 * FUNCTION:    acpi_unload_table
 *
 * PARAMETERS:  table_type    - Type of table to be unloaded
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 5753d06b7860..40ddb4dd9631 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -663,7 +663,7 @@ static void acpi_thermal_run(unsigned long data)
 static void acpi_thermal_check(void *data)
 {
        int result = 0;
-        struct acpi_thermal *tz = (struct acpi_thermal *)data;
+        struct acpi_thermal *tz = data;
        unsigned long sleep_time = 0;
        int i = 0;
        struct acpi_thermal_state state;
@@ -778,7 +778,7 @@ static struct proc_dir_entry *acpi_thermal_dir;
 static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
+        struct acpi_thermal *tz = seq->private;
        if (!tz)
@@ -813,7 +813,7 @@ static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
 static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
 {
        int result = 0;
-        struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
+        struct acpi_thermal *tz = seq->private;
        if (!tz)
@@ -837,7 +837,7 @@ static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
 static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
+        struct acpi_thermal *tz = seq->private;
        int i = 0;
        int j = 0;
@@ -893,8 +893,8 @@ acpi_thermal_write_trip_points(struct file *file,
                               const char __user * buffer,
                               size_t count, loff_t * ppos)
 {
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
+        struct acpi_thermal *tz = m->private;
        char *limit_string;
        int num, critical, hot, passive;
@@ -902,12 +902,10 @@ acpi_thermal_write_trip_points(struct file *file,
        int i = 0;
-        limit_string = kmalloc(ACPI_THERMAL_MAX_LIMIT_STR_LEN, GFP_KERNEL);
+        limit_string = kzalloc(ACPI_THERMAL_MAX_LIMIT_STR_LEN, GFP_KERNEL);
        if (!limit_string)
                return -ENOMEM;
-        memset(limit_string, 0, ACPI_THERMAL_MAX_LIMIT_STR_LEN);
        active = kmalloc(ACPI_THERMAL_MAX_ACTIVE * sizeof(int), GFP_KERNEL);
        if (!active) {
                kfree(limit_string);
@@ -953,7 +951,7 @@ acpi_thermal_write_trip_points(struct file *file,
 static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
+        struct acpi_thermal *tz = seq->private;
        if (!tz)
@@ -984,8 +982,8 @@ acpi_thermal_write_cooling_mode(struct file *file,
                                const char __user * buffer,
                                size_t count, loff_t * ppos)
 {
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
+        struct acpi_thermal *tz = m->private;
        int result = 0;
        char mode_string[12] = { '\0' };
@@ -1014,7 +1012,7 @@ acpi_thermal_write_cooling_mode(struct file *file,
 static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
+        struct acpi_thermal *tz = seq->private;
        if (!tz)
@@ -1043,8 +1041,8 @@ acpi_thermal_write_polling(struct file *file,
                           const char __user * buffer,
                           size_t count, loff_t * ppos)
 {
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
+        struct acpi_thermal *tz = m->private;
        int result = 0;
        char polling_string[12] = { '\0' };
        int seconds = 0;
@@ -1170,7 +1168,7 @@ static int acpi_thermal_remove_fs(struct acpi_device *device)
 static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_thermal *tz = (struct acpi_thermal *)data;
+        struct acpi_thermal *tz = data;
        struct acpi_device *device = NULL;
@@ -1271,10 +1269,9 @@ static int acpi_thermal_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        tz = kmalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
+        tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
        if (!tz)
                return -ENOMEM;
-        memset(tz, 0, sizeof(struct acpi_thermal));
        tz->device = device;
        strcpy(tz->name, device->pnp.bus_id);
@@ -1324,7 +1321,7 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        tz = (struct acpi_thermal *)acpi_driver_data(device);
+        tz = acpi_driver_data(device);
        /* avoid timer adding new defer task */
        tz->zombie = 1;
@@ -1364,7 +1361,7 @@ static int acpi_thermal_resume(struct acpi_device *device, int state)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        tz = (struct acpi_thermal *)acpi_driver_data(device);
+        tz = acpi_driver_data(device);
        acpi_thermal_get_temperature(tz);
diff --git a/drivers/acpi/toshiba_acpi.c b/drivers/acpi/toshiba_acpi.c
index 7fe0b7ae9733..88aeccbafaaf 100644
--- a/drivers/acpi/toshiba_acpi.c
+++ b/drivers/acpi/toshiba_acpi.c
@@ -41,6 +41,8 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/proc_fs.h>
+#include <linux/backlight.h>
 #include <asm/uaccess.h>
 #include <acpi/acpi_drivers.h>
@@ -210,6 +212,7 @@ static acpi_status hci_read1(u32 reg, u32 * out1, u32 * result)
 }
 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
+static struct backlight_device *toshiba_backlight_device;
 static int force_fan;
 static int last_key_event;
 static int key_event_valid;
@@ -271,14 +274,23 @@ dispatch_write(struct file *file, const char __user * buffer,
        return result;
 }
-static char *read_lcd(char *p)
+static int get_lcd(struct backlight_device *bd)
 {
        u32 hci_result;
        u32 value;
        hci_read1(HCI_LCD_BRIGHTNESS, &value, &hci_result);
        if (hci_result == HCI_SUCCESS) {
-                value = value >> HCI_LCD_BRIGHTNESS_SHIFT;
+                return (value >> HCI_LCD_BRIGHTNESS_SHIFT);
+        } else
+                return -EFAULT;
+}
+static char *read_lcd(char *p)
+{
+        int value = get_lcd(NULL);
+        if (value >= 0) {
                p += sprintf(p, "brightness:              %d\n", value);
                p += sprintf(p, "brightness_levels:       %d\n",
                             HCI_LCD_BRIGHTNESS_LEVELS);
@@ -289,22 +301,34 @@ static char *read_lcd(char *p)
        return p;
 }
+static int set_lcd(int value)
+{
+        u32 hci_result;
+        value = value << HCI_LCD_BRIGHTNESS_SHIFT;
+        hci_write1(HCI_LCD_BRIGHTNESS, value, &hci_result);
+        if (hci_result != HCI_SUCCESS)
+                return -EFAULT;
+        return 0;
+}
+static int set_lcd_status(struct backlight_device *bd)
+{
+        return set_lcd(bd->props->brightness);
+}
 static unsigned long write_lcd(const char *buffer, unsigned long count)
 {
        int value;
-        u32 hci_result;
+        int ret = count;
        if (sscanf(buffer, " brightness : %i", &value) == 1 &&
-            value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS) {
+            value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS)
-                value = value << HCI_LCD_BRIGHTNESS_SHIFT;
+                ret = set_lcd(value);
-                hci_write1(HCI_LCD_BRIGHTNESS, value, &hci_result);
+        else
-                if (hci_result != HCI_SUCCESS)
+                ret = -EINVAL;
-                        return -EFAULT;
+        return ret;
-        } else {
-                return -EINVAL;
-        }
-        return count;
 }
 static char *read_video(char *p)
@@ -506,6 +530,26 @@ static acpi_status __exit remove_device(void)
        return AE_OK;
 }
+static struct backlight_properties toshiba_backlight_data = {
+        .owner          = THIS_MODULE,
+        .get_brightness = get_lcd,
+        .update_status  = set_lcd_status,
+        .max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1,
+};
+static void __exit toshiba_acpi_exit(void)
+{
+        if (toshiba_backlight_device)
+                backlight_device_unregister(toshiba_backlight_device);
+        remove_device();
+        if (toshiba_proc_dir)
+                remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
+        return;
+}
 static int __init toshiba_acpi_init(void)
 {
        acpi_status status = AE_OK;
@@ -546,17 +590,16 @@ static int __init toshiba_acpi_init(void)
                        remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
        }
-        return (ACPI_SUCCESS(status)) ? 0 : -ENODEV;
+        toshiba_backlight_device = backlight_device_register("toshiba",NULL,
-}
+                                                NULL,
+                                                &toshiba_backlight_data);
-static void __exit toshiba_acpi_exit(void)
+        if (IS_ERR(toshiba_backlight_device)) {
-{
+                printk(KERN_ERR "Could not register toshiba backlight device\n");
-        remove_device();
+                toshiba_backlight_device = NULL;
+                toshiba_acpi_exit();
-        if (toshiba_proc_dir)
+        }
-                remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
-        return;
+        return (ACPI_SUCCESS(status)) ? 0 : -ENODEV;
 }
 module_init(toshiba_acpi_init);
diff --git a/drivers/acpi/utilities/utdebug.c b/drivers/acpi/utilities/utdebug.c
index bb1eaf9aa653..9e9054e155c1 100644
--- a/drivers/acpi/utilities/utdebug.c
+++ b/drivers/acpi/utilities/utdebug.c
@@ -180,8 +180,9 @@ acpi_ut_debug_print(u32 requested_debug_level,
        if (thread_id != acpi_gbl_prev_thread_id) {
                if (ACPI_LV_THREADS & acpi_dbg_level) {
                        acpi_os_printf
-                            ("\n**** Context Switch from TID %X to TID %X ****\n\n",
+                            ("\n**** Context Switch from TID %lX to TID %lX ****\n\n",
-                             (u32) acpi_gbl_prev_thread_id, (u32) thread_id);
+                             (unsigned long) acpi_gbl_prev_thread_id,
+                             (unsigned long) thread_id);
                }
                acpi_gbl_prev_thread_id = thread_id;
diff --git a/drivers/acpi/utilities/utmutex.c b/drivers/acpi/utilities/utmutex.c
index c39062a047cd..180e73ceb6e2 100644
--- a/drivers/acpi/utilities/utmutex.c
+++ b/drivers/acpi/utilities/utmutex.c
@@ -243,23 +243,24 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
 #endif
        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
-                          "Thread %X attempting to acquire Mutex [%s]\n",
+                          "Thread %lX attempting to acquire Mutex [%s]\n",
-                          (u32) this_thread_id, acpi_ut_get_mutex_name(mutex_id)));
+                          (unsigned long) this_thread_id,
+                          acpi_ut_get_mutex_name(mutex_id)));
        status = acpi_os_acquire_mutex(acpi_gbl_mutex_info[mutex_id].mutex,
                                       ACPI_WAIT_FOREVER);
        if (ACPI_SUCCESS(status)) {
                ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
-                                  "Thread %X acquired Mutex [%s]\n",
+                                  "Thread %lX acquired Mutex [%s]\n",
-                                  (u32) this_thread_id,
+                                  (unsigned long) this_thread_id,
                                  acpi_ut_get_mutex_name(mutex_id)));
                acpi_gbl_mutex_info[mutex_id].use_count++;
                acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
        } else {
                ACPI_EXCEPTION((AE_INFO, status,
-                                "Thread %X could not acquire Mutex [%X]",
+                                "Thread %lX could not acquire Mutex [%X]",
-                                (u32) this_thread_id, mutex_id));
+                                (unsigned long) this_thread_id, mutex_id));
        }
        return (status);
@@ -285,7 +286,8 @@ acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
        this_thread_id = acpi_os_get_thread_id();
        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
-                          "Thread %X releasing Mutex [%s]\n", (u32) this_thread_id,
+                          "Thread %lX releasing Mutex [%s]\n",
+                          (unsigned long) this_thread_id,
                          acpi_ut_get_mutex_name(mutex_id)));
        if (mutex_id > ACPI_MAX_MUTEX) {
diff --git a/drivers/acpi/utils.c b/drivers/acpi/utils.c
index d0d84c43a9d4..68a809fa7b19 100644
--- a/drivers/acpi/utils.c
+++ b/drivers/acpi/utils.c
@@ -83,7 +83,7 @@ acpi_extract_package(union acpi_object *package,
                return AE_BAD_DATA;
        }
-        format_string = (char *)format->pointer;
+        format_string = format->pointer;
        /*
         * Calculate size_required.
@@ -262,11 +262,10 @@ acpi_evaluate_integer(acpi_handle handle,
        if (!data)
                return AE_BAD_PARAMETER;
-        element = kmalloc(sizeof(union acpi_object), irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
+        element = kzalloc(sizeof(union acpi_object), irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
        if (!element)
                return AE_NO_MEMORY;
-        memset(element, 0, sizeof(union acpi_object));
        buffer.length = sizeof(union acpi_object);
        buffer.pointer = element;
        status = acpi_evaluate_object(handle, pathname, arguments, &buffer);
@@ -321,12 +320,11 @@ acpi_evaluate_string(acpi_handle handle,
                return AE_BAD_DATA;
        }
-        *data = kmalloc(element->string.length + 1, GFP_KERNEL);
+        *data = kzalloc(element->string.length + 1, GFP_KERNEL);
        if (!data) {
                printk(KERN_ERR PREFIX "Memory allocation\n");
                return -ENOMEM;
        }
-        memset(*data, 0, element->string.length + 1);
        memcpy(*data, element->string.pointer, element->string.length);
@@ -361,7 +359,7 @@ acpi_evaluate_reference(acpi_handle handle,
        if (ACPI_FAILURE(status))
                goto end;
-        package = (union acpi_object *)buffer.pointer;
+        package = buffer.pointer;
        if ((buffer.length == 0) || !package) {
                printk(KERN_ERR PREFIX "No return object (len %X ptr %p)\n",
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 56666a982476..36b37d755dbc 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -3,6 +3,7 @@
 *
 *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
 *  Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
+ *  Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
@@ -47,11 +48,11 @@
 #define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT   0x83
 #define ACPI_VIDEO_NOTIFY_PREV_OUTPUT   0x84
-#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS      0x82
+#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS      0x85
-#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS        0x83
+#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS        0x86
-#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS        0x84
+#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS        0x87
-#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS       0x85
+#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS       0x88
-#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF           0x86
+#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF           0x89
 #define ACPI_VIDEO_HEAD_INVALID         (~0u - 1)
 #define ACPI_VIDEO_HEAD_END             (~0u)
@@ -386,7 +387,7 @@ acpi_video_device_EDID(struct acpi_video_device *device,
        if (ACPI_FAILURE(status))
                return -ENODEV;
-        obj = (union acpi_object *)buffer.pointer;
+        obj = buffer.pointer;
        if (obj && obj->type == ACPI_TYPE_BUFFER)
                *edid = obj;
@@ -532,11 +533,10 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                int count = 0;
                union acpi_object *o;
-                br = kmalloc(sizeof(*br), GFP_KERNEL);
+                br = kzalloc(sizeof(*br), GFP_KERNEL);
                if (!br) {
                        printk(KERN_ERR "can't allocate memory\n");
                } else {
-                        memset(br, 0, sizeof(*br));
                        br->levels = kmalloc(obj->package.count *
                                             sizeof *(br->levels), GFP_KERNEL);
                        if (!br->levels)
@@ -654,8 +654,7 @@ static struct proc_dir_entry *acpi_video_dir;
 static int acpi_video_device_info_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_device *dev =
+        struct acpi_video_device *dev = seq->private;
-            (struct acpi_video_device *)seq->private;
        if (!dev)
@@ -688,8 +687,7 @@ acpi_video_device_info_open_fs(struct inode *inode, struct file *file)
 static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
 {
        int status;
-        struct acpi_video_device *dev =
+        struct acpi_video_device *dev = seq->private;
-            (struct acpi_video_device *)seq->private;
        unsigned long state;
@@ -727,8 +725,8 @@ acpi_video_device_write_state(struct file *file,
                              size_t count, loff_t * data)
 {
        int status;
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_video_device *dev = (struct acpi_video_device *)m->private;
+        struct acpi_video_device *dev = m->private;
        char str[12] = { 0 };
        u32 state = 0;
@@ -754,8 +752,7 @@ acpi_video_device_write_state(struct file *file,
 static int
 acpi_video_device_brightness_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_device *dev =
+        struct acpi_video_device *dev = seq->private;
-            (struct acpi_video_device *)seq->private;
        int i;
@@ -784,8 +781,8 @@ acpi_video_device_write_brightness(struct file *file,
                                   const char __user * buffer,
                                   size_t count, loff_t * data)
 {
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_video_device *dev = (struct acpi_video_device *)m->private;
+        struct acpi_video_device *dev = m->private;
        char str[4] = { 0 };
        unsigned int level = 0;
        int i;
@@ -817,8 +814,7 @@ acpi_video_device_write_brightness(struct file *file,
 static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_device *dev =
+        struct acpi_video_device *dev = seq->private;
-            (struct acpi_video_device *)seq->private;
        int status;
        int i;
        union acpi_object *edid = NULL;
@@ -866,7 +862,7 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
        if (!device)
                return -ENODEV;
-        vid_dev = (struct acpi_video_device *)acpi_driver_data(device);
+        vid_dev = acpi_driver_data(device);
        if (!vid_dev)
                return -ENODEV;
@@ -931,7 +927,7 @@ static int acpi_video_device_remove_fs(struct acpi_device *device)
 {
        struct acpi_video_device *vid_dev;
-        vid_dev = (struct acpi_video_device *)acpi_driver_data(device);
+        vid_dev = acpi_driver_data(device);
        if (!vid_dev || !vid_dev->video || !vid_dev->video->dir)
                return -ENODEV;
@@ -950,7 +946,7 @@ static int acpi_video_device_remove_fs(struct acpi_device *device)
 /* video bus */
 static int acpi_video_bus_info_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
+        struct acpi_video_bus *video = seq->private;
        if (!video)
@@ -975,7 +971,7 @@ static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file)
 static int acpi_video_bus_ROM_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
+        struct acpi_video_bus *video = seq->private;
        if (!video)
@@ -995,7 +991,7 @@ static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
 static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
+        struct acpi_video_bus *video = seq->private;
        unsigned long options;
        int status;
@@ -1033,7 +1029,7 @@ acpi_video_bus_POST_info_open_fs(struct inode *inode, struct file *file)
 static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
+        struct acpi_video_bus *video = seq->private;
        int status;
        unsigned long id;
@@ -1054,7 +1050,7 @@ static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
 static int acpi_video_bus_DOS_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
+        struct acpi_video_bus *video = seq->private;
        seq_printf(seq, "DOS setting: <%d>\n", video->dos_setting);
@@ -1079,8 +1075,8 @@ acpi_video_bus_write_POST(struct file *file,
                          size_t count, loff_t * data)
 {
        int status;
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_video_bus *video = (struct acpi_video_bus *)m->private;
+        struct acpi_video_bus *video = m->private;
        char str[12] = { 0 };
        unsigned long opt, options;
@@ -1119,8 +1115,8 @@ acpi_video_bus_write_DOS(struct file *file,
                         size_t count, loff_t * data)
 {
        int status;
-        struct seq_file *m = (struct seq_file *)file->private_data;
+        struct seq_file *m = file->private_data;
-        struct acpi_video_bus *video = (struct acpi_video_bus *)m->private;
+        struct acpi_video_bus *video = m->private;
        char str[12] = { 0 };
        unsigned long opt;
@@ -1150,7 +1146,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
        struct acpi_video_bus *video;
-        video = (struct acpi_video_bus *)acpi_driver_data(device);
+        video = acpi_driver_data(device);
        if (!acpi_device_dir(device)) {
                acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
@@ -1226,7 +1222,7 @@ static int acpi_video_bus_remove_fs(struct acpi_device *device)
        struct acpi_video_bus *video;
-        video = (struct acpi_video_bus *)acpi_driver_data(device);
+        video = acpi_driver_data(device);
        if (acpi_device_dir(device)) {
                remove_proc_entry("info", acpi_device_dir(device));
@@ -1263,12 +1259,10 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
            acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
        if (ACPI_SUCCESS(status)) {
-                data = kmalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
+                data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
                if (!data)
                        return -ENOMEM;
-                memset(data, 0, sizeof(struct acpi_video_device));
                strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
                strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
                acpi_driver_data(device) = data;
@@ -1403,7 +1397,7 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
                return status;
        }
-        dod = (union acpi_object *)buffer.pointer;
+        dod = buffer.pointer;
        if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
                ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
                status = -EFAULT;
@@ -1426,7 +1420,7 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
        count = 0;
        for (i = 0; i < dod->package.count; i++) {
-                obj = (union acpi_object *)&dod->package.elements[i];
+                obj = &dod->package.elements[i];
                if (obj->type != ACPI_TYPE_INTEGER) {
                        printk(KERN_ERR PREFIX "Invalid _DOD data\n");
@@ -1509,8 +1503,34 @@ static int
 acpi_video_get_next_level(struct acpi_video_device *device,
                          u32 level_current, u32 event)
 {
-        /*Fix me */
+        int min, max, min_above, max_below, i, l;
-        return level_current;
+        max = max_below = 0;
+        min = min_above = 255;
+        for (i = 0; i < device->brightness->count; i++) {
+                l = device->brightness->levels[i];
+                if (l < min)
+                        min = l;
+                if (l > max)
+                        max = l;
+                if (l < min_above && l > level_current)
+                        min_above = l;
+                if (l > max_below && l < level_current)
+                        max_below = l;
+        }
+        switch (event) {
+        case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
+                return (level_current < max) ? min_above : min;
+        case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
+                return (level_current < max) ? min_above : max;
+        case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
+                return (level_current > min) ? max_below : min;
+        case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
+        case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
+                return 0;
+        default:
+                return level_current;
+        }
 }
 static void
@@ -1612,7 +1632,7 @@ static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
 static void acpi_video_bus_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_video_bus *video = (struct acpi_video_bus *)data;
+        struct acpi_video_bus *video = data;
        struct acpi_device *device = NULL;
        printk("video bus notify\n");
@@ -1654,8 +1674,7 @@ static void acpi_video_bus_notify(acpi_handle handle, u32 event, void *data)
 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_video_device *video_device =
+        struct acpi_video_device *video_device = data;
-            (struct acpi_video_device *)data;
        struct acpi_device *device = NULL;
@@ -1696,10 +1715,9 @@ static int acpi_video_bus_add(struct acpi_device *device)
        if (!device)
                return -EINVAL;
-        video = kmalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
+        video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
        if (!video)
                return -ENOMEM;
-        memset(video, 0, sizeof(struct acpi_video_bus));
        video->device = device;
        strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
@@ -1757,7 +1775,7 @@ static int acpi_video_bus_remove(struct acpi_device *device, int type)
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
-        video = (struct acpi_video_bus *)acpi_driver_data(device);
+        video = acpi_driver_data(device);
        acpi_video_bus_stop_devices(video);
diff --git a/drivers/misc/msi-laptop.c b/drivers/misc/msi-laptop.c
index fdb7153f4426..8e5e07e4c1cf 100644
--- a/drivers/misc/msi-laptop.c
+++ b/drivers/misc/msi-laptop.c
@@ -317,7 +317,8 @@ static int __init msi_init(void)
        /* Register backlight stuff */
-        msibl_device = backlight_device_register("msi-laptop-bl", NULL, &msibl_props);
+        msibl_device = backlight_device_register("msi-laptop-bl", NULL, NULL,
+                                                &msibl_props);
        if (IS_ERR(msibl_device))
                return PTR_ERR(msibl_device);
diff --git a/drivers/pci/hotplug/acpiphp_ibm.c b/drivers/pci/hotplug/acpiphp_ibm.c
index bd40aee10e16..7f03881a8b68 100644
--- a/drivers/pci/hotplug/acpiphp_ibm.c
+++ b/drivers/pci/hotplug/acpiphp_ibm.c
@@ -319,13 +319,12 @@ static int ibm_get_table_from_acpi(char **bufp)
        if (bufp == NULL)
                goto read_table_done;
-        lbuf = kmalloc(size, GFP_KERNEL);
+        lbuf = kzalloc(size, GFP_KERNEL);
        dbg("%s: element count: %i, ASL table size: %i, &table = 0x%p\n",
                        __FUNCTION__, package->package.count, size, lbuf);
        if (lbuf) {
                *bufp = lbuf;
-                memset(lbuf, 0, size);
        } else {
                size = -ENOMEM;
                goto read_table_done;
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index 02cbb7fff24f..a7932a72d298 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -281,7 +281,7 @@ static int appledisplay_probe(struct usb_interface *iface,
        /* Register backlight device */
        snprintf(bl_name, sizeof(bl_name), "appledisplay%d",
                atomic_inc_return(&count_displays) - 1);
-        pdata->bd = backlight_device_register(bl_name, pdata,
+        pdata->bd = backlight_device_register(bl_name, NULL, NULL,
                                                &appledisplay_bl_data);
        if (IS_ERR(pdata->bd)) {
                err("appledisplay: Backlight registration failed");
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 3feddf89d100..2e976ffcde0f 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1834,7 +1834,7 @@ static void aty128_bl_init(struct aty128fb_par *par)
        snprintf(name, sizeof(name), "aty128bl%d", info->node);
-        bd = backlight_device_register(name, par, &aty128_bl_data);
+        bd = backlight_device_register(name, info->dev, par, &aty128_bl_data);
        if (IS_ERR(bd)) {
                info->bl_dev = NULL;
                printk(KERN_WARNING "aty128: Backlight registration failed\n");
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 09684d7a7ce9..f2ebdd880085 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -2211,7 +2211,7 @@ static void aty_bl_init(struct atyfb_par *par)
        snprintf(name, sizeof(name), "atybl%d", info->node);
-        bd = backlight_device_register(name, par, &aty_bl_data);
+        bd = backlight_device_register(name, info->dev, par, &aty_bl_data);
        if (IS_ERR(bd)) {
                info->bl_dev = NULL;
                printk(KERN_WARNING "aty: Backlight registration failed\n");
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
index 585eb7b9e636..3abfd4a380cc 100644
--- a/drivers/video/aty/radeon_backlight.c
+++ b/drivers/video/aty/radeon_backlight.c
@@ -163,7 +163,7 @@ void radeonfb_bl_init(struct radeonfb_info *rinfo)
        snprintf(name, sizeof(name), "radeonbl%d", rinfo->info->node);
-        bd = backlight_device_register(name, pdata, &radeon_bl_data);
+        bd = backlight_device_register(name, rinfo->info->dev, pdata, &radeon_bl_data);
        if (IS_ERR(bd)) {
                rinfo->info->bl_dev = NULL;
                printk("radeonfb: Backlight registration failed\n");
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index db8c191b1201..9601bfe309ac 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -216,8 +216,10 @@ static const struct class_device_attribute bl_class_device_attributes[] = {
 * Creates and registers new backlight class_device. Returns either an
 * ERR_PTR() or a pointer to the newly allocated device.
 */
-struct backlight_device *backlight_device_register(const char *name, void *devdata,
+struct backlight_device *backlight_device_register(const char *name,
-                                                   struct backlight_properties *bp)
+        struct device *dev,
+        void *devdata,
+        struct backlight_properties *bp)
 {
        int i, rc;
        struct backlight_device *new_bd;
@@ -232,6 +234,7 @@ struct backlight_device *backlight_device_register(const char *name, void *devda
        new_bd->props = bp;
        memset(&new_bd->class_dev, 0, sizeof(new_bd->class_dev));
        new_bd->class_dev.class = &backlight_class;
+        new_bd->class_dev.dev = dev;
        strlcpy(new_bd->class_dev.class_id, name, KOBJ_NAME_LEN);
        class_set_devdata(&new_bd->class_dev, devdata);
diff --git a/drivers/video/nvidia/nv_backlight.c b/drivers/video/nvidia/nv_backlight.c
index 5b75ae4e9457..df934bd21899 100644
--- a/drivers/video/nvidia/nv_backlight.c
+++ b/drivers/video/nvidia/nv_backlight.c
@@ -141,7 +141,7 @@ void nvidia_bl_init(struct nvidia_par *par)
        snprintf(name, sizeof(name), "nvidiabl%d", info->node);
-        bd = backlight_device_register(name, par, &nvidia_bl_data);
+        bd = backlight_device_register(name, info->dev, par, &nvidia_bl_data);
        if (IS_ERR(bd)) {
                info->bl_dev = NULL;
                printk(KERN_WARNING "nvidia: Backlight registration failed\n");
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 345e8b1c1af8..1a13966b7d5b 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -384,7 +384,7 @@ static void riva_bl_init(struct riva_par *par)
        snprintf(name, sizeof(name), "rivabl%d", info->node);
-        bd = backlight_device_register(name, par, &riva_bl_data);
+        bd = backlight_device_register(name, info->dev, par, &riva_bl_data);
        if (IS_ERR(bd)) {
                info->bl_dev = NULL;
                printk(KERN_WARNING "riva: Backlight registration failed\n");